Blob
1 #include "os.h"2 #include <libsec.h>4 /*5 * This MD4 is implemented from the description in Stinson's Cryptography,6 * theory and practice. -- presotto7 */9 /*10 * Rotate ammounts used in the algorithm11 */12 enum13 {14 S11= 3,15 S12= 7,16 S13= 11,17 S14= 19,19 S21= 3,20 S22= 5,21 S23= 9,22 S24= 13,24 S31= 3,25 S32= 9,26 S33= 11,27 S34= 15,28 };30 typedef struct MD4Table MD4Table;31 struct MD4Table32 {33 uchar x; /* index into data block */34 uchar rot; /* amount to rotate left by */35 };37 static MD4Table tab[] =38 {39 /* round 1 */40 /*[0]*/ { 0, S11},41 { 1, S12},42 { 2, S13},43 { 3, S14},44 { 4, S11},45 { 5, S12},46 { 6, S13},47 { 7, S14},48 { 8, S11},49 { 9, S12},50 { 10, S13},51 { 11, S14},52 { 12, S11},53 { 13, S12},54 { 14, S13},55 { 15, S14},57 /* round 2 */58 /*[16]*/{ 0, S21},59 { 4, S22},60 { 8, S23},61 { 12, S24},62 { 1, S21},63 { 5, S22},64 { 9, S23},65 { 13, S24},66 { 2, S21},67 { 6, S22},68 { 10, S23},69 { 14, S24},70 { 3, S21},71 { 7, S22},72 { 11, S23},73 { 15, S24},75 /* round 3 */76 /*[32]*/{ 0, S31},77 { 8, S32},78 { 4, S33},79 { 12, S34},80 { 2, S31},81 { 10, S32},82 { 6, S33},83 { 14, S34},84 { 1, S31},85 { 9, S32},86 { 5, S33},87 { 13, S34},88 { 3, S31},89 { 11, S32},90 { 7, S33},91 { 15, S34},92 };94 static void encode(uchar*, u32int*, ulong);95 static void decode(u32int*, uchar*, ulong);97 static void98 md4block(uchar *p, ulong len, MD4state *s)99 {100 int i;101 u32int a, b, c, d, tmp;102 MD4Table *t;103 uchar *end;104 u32int x[16];106 for(end = p+len; p < end; p += 64){107 a = s->state[0];108 b = s->state[1];109 c = s->state[2];110 d = s->state[3];112 decode(x, p, 64);114 for(i = 0; i < 48; i++){115 t = tab + i;116 switch(i>>4){117 case 0:118 a += (b & c) | (~b & d);119 break;120 case 1:121 a += ((b & c) | (b & d) | (c & d)) + 0x5A827999;122 break;123 case 2:124 a += (b ^ c ^ d) + 0x6ED9EBA1;125 break;126 }127 a += x[t->x];128 a = (a << t->rot) | (a >> (32 - t->rot));130 /* rotate variables */131 tmp = d;132 d = c;133 c = b;134 b = a;135 a = tmp;136 }138 s->state[0] += a;139 s->state[1] += b;140 s->state[2] += c;141 s->state[3] += d;143 s->len += 64;144 }145 }147 MD4state*148 md4(uchar *p, ulong len, uchar *digest, MD4state *s)149 {150 u32int x[16];151 uchar buf[128];152 int i;153 uchar *e;155 if(s == nil){156 s = malloc(sizeof(*s));157 if(s == nil)158 return nil;159 memset(s, 0, sizeof(*s));160 s->malloced = 1;161 }163 if(s->seeded == 0){164 /* seed the state, these constants would look nicer big-endian */165 s->state[0] = 0x67452301;166 s->state[1] = 0xefcdab89;167 s->state[2] = 0x98badcfe;168 s->state[3] = 0x10325476;169 s->seeded = 1;170 }172 /* fill out the partial 64 byte block from previous calls */173 if(s->blen){174 i = 64 - s->blen;175 if(len < i)176 i = len;177 memmove(s->buf + s->blen, p, i);178 len -= i;179 s->blen += i;180 p += i;181 if(s->blen == 64){182 md4block(s->buf, s->blen, s);183 s->blen = 0;184 }185 }187 /* do 64 byte blocks */188 i = len & ~0x3f;189 if(i){190 md4block(p, i, s);191 len -= i;192 p += i;193 }195 /* save the left overs if not last call */196 if(digest == 0){197 if(len){198 memmove(s->buf, p, len);199 s->blen += len;200 }201 return s;202 }204 /*205 * this is the last time through, pad what's left with 0x80,206 * 0's, and the input count to create a multiple of 64 bytes207 */208 if(s->blen){209 p = s->buf;210 len = s->blen;211 } else {212 memmove(buf, p, len);213 p = buf;214 }215 s->len += len;216 e = p + len;217 if(len < 56)218 i = 56 - len;219 else220 i = 120 - len;221 memset(e, 0, i);222 *e = 0x80;223 len += i;225 /* append the count */226 x[0] = s->len<<3;227 x[1] = s->len>>29;228 encode(p+len, x, 8);230 /* digest the last part */231 md4block(p, len+8, s);233 /* return result and free state */234 encode(digest, s->state, MD4dlen);235 if(s->malloced == 1)236 free(s);237 return nil;238 }240 /*241 * encodes input (u32int) into output (uchar). Assumes len is242 * a multiple of 4.243 */244 static void245 encode(uchar *output, u32int *input, ulong len)246 {247 u32int x;248 uchar *e;250 for(e = output + len; output < e;) {251 x = *input++;252 *output++ = x;253 *output++ = x >> 8;254 *output++ = x >> 16;255 *output++ = x >> 24;256 }257 }259 /*260 * decodes input (uchar) into output (u32int). Assumes len is261 * a multiple of 4.262 */263 static void264 decode(u32int *output, uchar *input, ulong len)265 {266 uchar *e;268 for(e = input+len; input < e; input += 4)269 *output++ = input[0] | (input[1] << 8) |270 (input[2] << 16) | (input[3] << 24);271 }