md4.c

00001 /* md4.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 #ifdef HAVE_CONFIG_H
00024     #include <config.h>
00025 #endif
00026 
00027 #include <wolfssl/wolfcrypt/settings.h>
00028 
00029 #ifndef NO_MD4
00030 
00031 #include <wolfssl/wolfcrypt/md4.h>
00032 #ifdef NO_INLINE
00033     #include <wolfssl/wolfcrypt/misc.h>
00034 #else
00035     #define WOLFSSL_MISC_INCLUDED
00036     #include <wolfcrypt/src/misc.c>
00037 #endif
00038 
00039 
00040 void wc_InitMd4(Md4* md4)
00041 {
00042     md4->digest[0] = 0x67452301L;
00043     md4->digest[1] = 0xefcdab89L;
00044     md4->digest[2] = 0x98badcfeL;
00045     md4->digest[3] = 0x10325476L;
00046 
00047     md4->buffLen = 0;
00048     md4->loLen   = 0;
00049     md4->hiLen   = 0;
00050 }
00051 
00052 
00053 static void Transform(Md4* md4)
00054 {
00055 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
00056 #define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
00057 #define H(x, y, z) ((x) ^ (y) ^ (z))
00058 
00059     /* Copy context->state[] to working vars  */
00060     word32 A = md4->digest[0];
00061     word32 B = md4->digest[1];
00062     word32 C = md4->digest[2];
00063     word32 D = md4->digest[3];
00064 
00065 #define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+md4->buffer[k],s);
00066     function(A,B,C,D, 0, 3);
00067     function(D,A,B,C, 1, 7);
00068     function(C,D,A,B, 2,11);
00069     function(B,C,D,A, 3,19);
00070     function(A,B,C,D, 4, 3);
00071     function(D,A,B,C, 5, 7);
00072     function(C,D,A,B, 6,11);
00073     function(B,C,D,A, 7,19);
00074     function(A,B,C,D, 8, 3);
00075     function(D,A,B,C, 9, 7);
00076     function(C,D,A,B,10,11);
00077     function(B,C,D,A,11,19);
00078     function(A,B,C,D,12, 3);
00079     function(D,A,B,C,13, 7);
00080     function(C,D,A,B,14,11);
00081     function(B,C,D,A,15,19);
00082 
00083 #undef function   
00084 #define function(a,b,c,d,k,s) \
00085     a=rotlFixed(a+G(b,c,d)+md4->buffer[k]+0x5a827999,s);
00086 
00087     function(A,B,C,D, 0, 3);
00088     function(D,A,B,C, 4, 5);
00089     function(C,D,A,B, 8, 9);
00090     function(B,C,D,A,12,13);
00091     function(A,B,C,D, 1, 3);
00092     function(D,A,B,C, 5, 5);
00093     function(C,D,A,B, 9, 9);
00094     function(B,C,D,A,13,13);
00095     function(A,B,C,D, 2, 3);
00096     function(D,A,B,C, 6, 5);
00097     function(C,D,A,B,10, 9);
00098     function(B,C,D,A,14,13);
00099     function(A,B,C,D, 3, 3);
00100     function(D,A,B,C, 7, 5);
00101     function(C,D,A,B,11, 9);
00102     function(B,C,D,A,15,13);
00103 
00104 #undef function  
00105 #define function(a,b,c,d,k,s) \
00106     a=rotlFixed(a+H(b,c,d)+md4->buffer[k]+0x6ed9eba1,s);
00107 
00108     function(A,B,C,D, 0, 3);
00109     function(D,A,B,C, 8, 9);
00110     function(C,D,A,B, 4,11);
00111     function(B,C,D,A,12,15);
00112     function(A,B,C,D, 2, 3);
00113     function(D,A,B,C,10, 9);
00114     function(C,D,A,B, 6,11);
00115     function(B,C,D,A,14,15);
00116     function(A,B,C,D, 1, 3);
00117     function(D,A,B,C, 9, 9);
00118     function(C,D,A,B, 5,11);
00119     function(B,C,D,A,13,15);
00120     function(A,B,C,D, 3, 3);
00121     function(D,A,B,C,11, 9);
00122     function(C,D,A,B, 7,11);
00123     function(B,C,D,A,15,15);
00124     
00125     /* Add the working vars back into digest state[]  */
00126     md4->digest[0] += A;
00127     md4->digest[1] += B;
00128     md4->digest[2] += C;
00129     md4->digest[3] += D;
00130 }
00131 
00132 
00133 static INLINE void AddLength(Md4* md4, word32 len)
00134 {
00135     word32 tmp = md4->loLen;
00136     if ( (md4->loLen += len) < tmp)
00137         md4->hiLen++;                       /* carry low to high */
00138 }
00139 
00140 
00141 void wc_Md4Update(Md4* md4, const byte* data, word32 len)
00142 {
00143     /* do block size increments */
00144     byte* local = (byte*)md4->buffer;
00145 
00146     while (len) {
00147         word32 add = min(len, MD4_BLOCK_SIZE - md4->buffLen);
00148         XMEMCPY(&local[md4->buffLen], data, add);
00149 
00150         md4->buffLen += add;
00151         data         += add;
00152         len          -= add;
00153 
00154         if (md4->buffLen == MD4_BLOCK_SIZE) {
00155             #ifdef BIG_ENDIAN_ORDER
00156                 ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
00157             #endif
00158             Transform(md4);
00159             AddLength(md4, MD4_BLOCK_SIZE);
00160             md4->buffLen = 0;
00161         }
00162     }
00163 }
00164 
00165 
00166 void wc_Md4Final(Md4* md4, byte* hash)
00167 {
00168     byte* local = (byte*)md4->buffer;
00169 
00170     AddLength(md4, md4->buffLen);               /* before adding pads */
00171 
00172     local[md4->buffLen++] = 0x80;  /* add 1 */
00173 
00174     /* pad with zeros */
00175     if (md4->buffLen > MD4_PAD_SIZE) {
00176         XMEMSET(&local[md4->buffLen], 0, MD4_BLOCK_SIZE - md4->buffLen);
00177         md4->buffLen += MD4_BLOCK_SIZE - md4->buffLen;
00178 
00179         #ifdef BIG_ENDIAN_ORDER
00180             ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
00181         #endif
00182         Transform(md4);
00183         md4->buffLen = 0;
00184     }
00185     XMEMSET(&local[md4->buffLen], 0, MD4_PAD_SIZE - md4->buffLen);
00186    
00187     /* put lengths in bits */
00188     md4->hiLen = (md4->loLen >> (8*sizeof(md4->loLen) - 3)) + 
00189                  (md4->hiLen << 3);
00190     md4->loLen = md4->loLen << 3;
00191 
00192     /* store lengths */
00193     #ifdef BIG_ENDIAN_ORDER
00194         ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
00195     #endif
00196     /* ! length ordering dependent on digest endian type ! */
00197     XMEMCPY(&local[MD4_PAD_SIZE], &md4->loLen, sizeof(word32));
00198     XMEMCPY(&local[MD4_PAD_SIZE + sizeof(word32)], &md4->hiLen, sizeof(word32));
00199 
00200     Transform(md4);
00201     #ifdef BIG_ENDIAN_ORDER
00202         ByteReverseWords(md4->digest, md4->digest, MD4_DIGEST_SIZE);
00203     #endif
00204     XMEMCPY(hash, md4->digest, MD4_DIGEST_SIZE);
00205 
00206     wc_InitMd4(md4);  /* reset state */
00207 }
00208 
00209 
00210 #endif /* NO_MD4 */
00211 
00212