md4.c

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