md2.c

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