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