git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/CyaSSL/ctaocrypt/src/md4.c

   1 /* md4.c
   2  *
   3  * Copyright (C) 2006-2014 wolfSSL Inc.
   4  *
   5  * This file is part of CyaSSL.
   6  *
   7  * CyaSSL is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * CyaSSL is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23     #include <config.h>
  24 #endif
  25
  26 #include <cyassl/ctaocrypt/settings.h>
  27
  28 #ifndef NO_MD4
  29
  30 #include <cyassl/ctaocrypt/md4.h>
  31 #ifdef NO_INLINE
  32     #include <cyassl/ctaocrypt/misc.h>
  33 #else
  34     #include <ctaocrypt/src/misc.c>
  35 #endif
  36
  37
  38 #ifndef min
  39
  40     static INLINE word32 min(word32 a, word32 b)
  41     {
  42         return a > b ? b : a;
  43     }
  44
  45 #endif /* min */
  46
  47
  48 void InitMd4(Md4* md4)
  49 {
  50     md4->digest[0] = 0x67452301L;
  51     md4->digest[1] = 0xefcdab89L;
  52     md4->digest[2] = 0x98badcfeL;
  53     md4->digest[3] = 0x10325476L;
  54
  55     md4->buffLen = 0;
  56     md4->loLen   = 0;
  57     md4->hiLen   = 0;
  58 }
  59
  60
  61 static void Transform(Md4* md4)
  62 {
  63 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
  64 #define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
  65 #define H(x, y, z) ((x) ^ (y) ^ (z))
  66
  67     /* Copy context->state[] to working vars  */
  68     word32 A = md4->digest[0];
  69     word32 B = md4->digest[1];
  70     word32 C = md4->digest[2];
  71     word32 D = md4->digest[3];
  72
  73 #define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+md4->buffer[k],s);
  74     function(A,B,C,D, 0, 3);
  75     function(D,A,B,C, 1, 7);
  76     function(C,D,A,B, 2,11);
  77     function(B,C,D,A, 3,19);
  78     function(A,B,C,D, 4, 3);
  79     function(D,A,B,C, 5, 7);
  80     function(C,D,A,B, 6,11);
  81     function(B,C,D,A, 7,19);
  82     function(A,B,C,D, 8, 3);
  83     function(D,A,B,C, 9, 7);
  84     function(C,D,A,B,10,11);
  85     function(B,C,D,A,11,19);
  86     function(A,B,C,D,12, 3);
  87     function(D,A,B,C,13, 7);
  88     function(C,D,A,B,14,11);
  89     function(B,C,D,A,15,19);
  90
  91 #undef function
  92 #define function(a,b,c,d,k,s) \
  93     a=rotlFixed(a+G(b,c,d)+md4->buffer[k]+0x5a827999,s);
  94
  95     function(A,B,C,D, 0, 3);
  96     function(D,A,B,C, 4, 5);
  97     function(C,D,A,B, 8, 9);
  98     function(B,C,D,A,12,13);
  99     function(A,B,C,D, 1, 3);
 100     function(D,A,B,C, 5, 5);
 101     function(C,D,A,B, 9, 9);
 102     function(B,C,D,A,13,13);
 103     function(A,B,C,D, 2, 3);
 104     function(D,A,B,C, 6, 5);
 105     function(C,D,A,B,10, 9);
 106     function(B,C,D,A,14,13);
 107     function(A,B,C,D, 3, 3);
 108     function(D,A,B,C, 7, 5);
 109     function(C,D,A,B,11, 9);
 110     function(B,C,D,A,15,13);
 111
 112 #undef function
 113 #define function(a,b,c,d,k,s) \
 114     a=rotlFixed(a+H(b,c,d)+md4->buffer[k]+0x6ed9eba1,s);
 115
 116     function(A,B,C,D, 0, 3);
 117     function(D,A,B,C, 8, 9);
 118     function(C,D,A,B, 4,11);
 119     function(B,C,D,A,12,15);
 120     function(A,B,C,D, 2, 3);
 121     function(D,A,B,C,10, 9);
 122     function(C,D,A,B, 6,11);
 123     function(B,C,D,A,14,15);
 124     function(A,B,C,D, 1, 3);
 125     function(D,A,B,C, 9, 9);
 126     function(C,D,A,B, 5,11);
 127     function(B,C,D,A,13,15);
 128     function(A,B,C,D, 3, 3);
 129     function(D,A,B,C,11, 9);
 130     function(C,D,A,B, 7,11);
 131     function(B,C,D,A,15,15);
 132
 133     /* Add the working vars back into digest state[]  */
 134     md4->digest[0] += A;
 135     md4->digest[1] += B;
 136     md4->digest[2] += C;
 137     md4->digest[3] += D;
 138 }
 139
 140
 141 static INLINE void AddLength(Md4* md4, word32 len)
 142 {
 143     word32 tmp = md4->loLen;
 144     if ( (md4->loLen += len) < tmp)
 145         md4->hiLen++;                       /* carry low to high */
 146 }
 147
 148
 149 void Md4Update(Md4* md4, const byte* data, word32 len)
 150 {
 151     /* do block size increments */
 152     byte* local = (byte*)md4->buffer;
 153
 154     while (len) {
 155         word32 add = min(len, MD4_BLOCK_SIZE - md4->buffLen);
 156         XMEMCPY(&local[md4->buffLen], data, add);
 157
 158         md4->buffLen += add;
 159         data         += add;
 160         len          -= add;
 161
 162         if (md4->buffLen == MD4_BLOCK_SIZE) {
 163             #ifdef BIG_ENDIAN_ORDER
 164                 ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
 165             #endif
 166             Transform(md4);
 167             AddLength(md4, MD4_BLOCK_SIZE);
 168             md4->buffLen = 0;
 169         }
 170     }
 171 }
 172
 173
 174 void Md4Final(Md4* md4, byte* hash)
 175 {
 176     byte* local = (byte*)md4->buffer;
 177
 178     AddLength(md4, md4->buffLen);               /* before adding pads */
 179
 180     local[md4->buffLen++] = 0x80;  /* add 1 */
 181
 182     /* pad with zeros */
 183     if (md4->buffLen > MD4_PAD_SIZE) {
 184         XMEMSET(&local[md4->buffLen], 0, MD4_BLOCK_SIZE - md4->buffLen);
 185         md4->buffLen += MD4_BLOCK_SIZE - md4->buffLen;
 186
 187         #ifdef BIG_ENDIAN_ORDER
 188             ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
 189         #endif
 190         Transform(md4);
 191         md4->buffLen = 0;
 192     }
 193     XMEMSET(&local[md4->buffLen], 0, MD4_PAD_SIZE - md4->buffLen);
 194
 195     /* put lengths in bits */
 196     md4->hiLen = (md4->loLen >> (8*sizeof(md4->loLen) - 3)) +
 197                  (md4->hiLen << 3);
 198     md4->loLen = md4->loLen << 3;
 199
 200     /* store lengths */
 201     #ifdef BIG_ENDIAN_ORDER
 202         ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
 203     #endif
 204     /* ! length ordering dependent on digest endian type ! */
 205     XMEMCPY(&local[MD4_PAD_SIZE], &md4->loLen, sizeof(word32));
 206     XMEMCPY(&local[MD4_PAD_SIZE + sizeof(word32)], &md4->hiLen, sizeof(word32));
 207
 208     Transform(md4);
 209     #ifdef BIG_ENDIAN_ORDER
 210         ByteReverseWords(md4->digest, md4->digest, MD4_DIGEST_SIZE);
 211     #endif
 212     XMEMCPY(hash, md4->digest, MD4_DIGEST_SIZE);
 213
 214     InitMd4(md4);  /* reset state */
 215 }
 216
 217
 218 #endif /* NO_MD4 */
 219