md4.c

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