md2.c

00001 /* md2.c
00002  *
00003  * Copyright (C) 2006-2014 wolfSSL Inc.
00004  *
00005  * This file is part of CyaSSL.
00006  *
00007  * CyaSSL is free software; you can redistribute it and/or modify
00008  * it under the terms of the GNU General Public License as published by
00009  * the Free Software Foundation; either version 2 of the License, or
00010  * (at your option) any later version.
00011  *
00012  * CyaSSL is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU General Public License
00018  * along with this program; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
00020  */
00021 
00022 
00023 #ifdef HAVE_CONFIG_H
00024     #include <config.h>
00025 #endif
00026 
00027 #include <cyassl/ctaocrypt/settings.h>
00028 
00029 #ifdef CYASSL_MD2
00030 
00031 #include <cyassl/ctaocrypt/md2.h>
00032 #include <cyassl/ctaocrypt/error-crypt.h>
00033 
00034 #ifdef NO_INLINE
00035     #include <cyassl/ctaocrypt/misc.h>
00036 #else
00037     #include <ctaocrypt/src/misc.c>
00038 #endif
00039 
00040 
00041 void InitMd2(Md2* md2)
00042 {
00043     XMEMSET(md2->X, 0, MD2_X_SIZE);
00044     XMEMSET(md2->C, 0, MD2_BLOCK_SIZE);
00045     XMEMSET(md2->buffer, 0, MD2_BLOCK_SIZE);
00046     md2->count = 0;
00047 }
00048 
00049 
00050 void Md2Update(Md2* md2, const byte* data, word32 len)
00051 {
00052     static const byte S[256] = 
00053     {
00054         41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
00055         19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
00056         76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
00057         138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
00058         245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
00059         148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
00060         39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
00061         181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
00062         150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
00063         112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
00064         96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
00065         85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
00066         234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
00067         129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
00068         8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
00069         203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
00070         166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
00071         31, 26, 219, 153, 141, 51, 159, 17, 131, 20
00072     };
00073 
00074     while (len) {
00075         word32 L = (MD2_PAD_SIZE - md2->count) < len ?
00076                    (MD2_PAD_SIZE - md2->count) : len;
00077         XMEMCPY(md2->buffer + md2->count, data, L);
00078         md2->count += L;
00079         data += L;
00080         len  -= L;
00081 
00082         if (md2->count == MD2_PAD_SIZE) {
00083             int  i;
00084             byte t;
00085 
00086             md2->count = 0;
00087             XMEMCPY(md2->X + MD2_PAD_SIZE, md2->buffer, MD2_PAD_SIZE);
00088             t = md2->C[15];
00089 
00090             for(i = 0; i < MD2_PAD_SIZE; i++) {
00091                 md2->X[32 + i] = md2->X[MD2_PAD_SIZE + i] ^ md2->X[i];
00092                 t = md2->C[i] ^= S[md2->buffer[i] ^ t];
00093             }
00094 
00095             t=0;
00096             for(i = 0; i < 18; i++) {
00097                 int j;
00098                 for(j = 0; j < MD2_X_SIZE; j += 8) {
00099                     t = md2->X[j+0] ^= S[t];
00100                     t = md2->X[j+1] ^= S[t];
00101                     t = md2->X[j+2] ^= S[t];
00102                     t = md2->X[j+3] ^= S[t];
00103                     t = md2->X[j+4] ^= S[t];
00104                     t = md2->X[j+5] ^= S[t];
00105                     t = md2->X[j+6] ^= S[t];
00106                     t = md2->X[j+7] ^= S[t];
00107                 }
00108                 t = (t + i) & 0xFF;
00109             }
00110         }
00111     }
00112 }
00113 
00114 
00115 void Md2Final(Md2* md2, byte* hash)
00116 {
00117     byte   padding[MD2_BLOCK_SIZE];
00118     word32 padLen = MD2_PAD_SIZE - md2->count;
00119     word32 i;
00120 
00121     for (i = 0; i < padLen; i++)
00122         padding[i] = (byte)padLen;
00123 
00124     Md2Update(md2, padding, padLen);
00125     Md2Update(md2, md2->C, MD2_BLOCK_SIZE);
00126 
00127     XMEMCPY(hash, md2->X, MD2_DIGEST_SIZE);
00128 
00129     InitMd2(md2);
00130 }
00131 
00132 
00133 int Md2Hash(const byte* data, word32 len, byte* hash)
00134 {
00135 #ifdef CYASSL_SMALL_STACK
00136     Md2* md2;
00137 #else
00138     Md2 md2[1];
00139 #endif
00140 
00141 #ifdef CYASSL_SMALL_STACK
00142     md2 = (Md2*)XMALLOC(sizeof(Md2), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00143     if (md2 == NULL)
00144         return MEMORY_E;
00145 #endif
00146 
00147     InitMd2(md2);
00148     Md2Update(md2, data, len);
00149     Md2Final(md2, hash);
00150 
00151 #ifdef CYASSL_SMALL_STACK
00152     XFREE(md2, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00153 #endif
00154 
00155     return 0;
00156 }
00157 
00158 
00159 #endif /* CYASSL_MD2 */