md5.c

   1 /*
   2  * File:        md5.h
   3  * Author:      Daniel Otte
   4  * Date:        31.07.2006
   5  * License: GPL
   6  * Description: Implementation of the MD5 hash algorithm as described in RFC 1321
   7  *
   8  */
   9
  10  #include "md5.h"
  11  #include "md5_sbox.h"
  12  #include "uart.h"
  13  #include <stdint.h>
  14  #include <string.h>
  15
  16 void md5_init(md5_ctx_t *s){
  17         s->counter = 0;
  18         s->a[0] = 0x67452301;
  19         s->a[1] = 0xefcdab89;
  20         s->a[2] = 0x98badcfe;
  21         s->a[3] = 0x10325476;
  22 }
  23
  24 uint32_t md5_F(uint32_t x, uint32_t y, uint32_t z){
  25         return ((x&y)|((~x)&z));
  26 }
  27
  28 uint32_t md5_G(uint32_t x, uint32_t y, uint32_t z){
  29         return ((x&z)|((~z)&y));
  30 }
  31
  32 uint32_t md5_H(uint32_t x, uint32_t y, uint32_t z){
  33         return (x^y^z);
  34 }
  35
  36 uint32_t md5_I(uint32_t x, uint32_t y, uint32_t z){
  37         return (y ^ (x | (~z)));
  38 }
  39
  40 typedef uint32_t md5_func_t(uint32_t, uint32_t, uint32_t);
  41
  42 #define ROTL32(x,n) ((x)<<(n) | (x)>>(32-(n)))
  43
  44 void md5_core(uint32_t* a, uint8_t as, void* block, uint8_t k, uint8_t s, uint8_t i, uint8_t fi){
  45         uint32_t t;
  46         md5_func_t* funcs[]={md5_F, md5_G, md5_H, md5_I};
  47         char funcc[]={'*', '-', '+', '~'};
  48         as &= 0x3;
  49         /* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
  50         uart_putstr("\r\n DBG: md5_core [");
  51         uart_putc(funcc[fi]);
  52         uart_hexdump(&as, 1); uart_putc(' ');
  53         uart_hexdump(&k, 1); uart_putc(' ');
  54         uart_hexdump(&s, 1); uart_putc(' ');
  55         uart_hexdump(&i, 1); uart_putc(']');
  56         t = a[as] + funcs[fi](a[(as+1)&3], a[(as+2)&3], a[(as+3)&3]) + ((uint8_t*)block)[k] + md5_T[i] ;
  57         a[as]=a[(as+1)&3] + ROTL32(t, s);
  58 }
  59
  60 void md5_nextBlock(md5_ctx_t *state, void* block){
  61         uint32_t        a[4];
  62         uint8_t         m,n,i=0;
  63         /* this requires other mixed sboxes */
  64         uart_putstr("\r\n DBG: md5_nextBlock: block:\r\n");
  65         uart_hexdump(block, 16);        uart_putstr("\r\n");
  66         uart_hexdump(block+16, 16);     uart_putstr("\r\n");
  67         uart_hexdump(block+32, 16);     uart_putstr("\r\n");
  68         uart_hexdump(block+48, 16);     uart_putstr("\r\n");
  69
  70         a[0]=state->a[0];
  71         a[1]=state->a[1];
  72         a[2]=state->a[2];
  73         a[3]=state->a[3];
  74
  75         /* round 1 */
  76         uint8_t s1t[]={7,12,17,22};
  77         for(m=0;m<4;++m){
  78                 for(n=0;n<4;++n){
  79                         md5_core(a, 4-n, block, m*4+n, s1t[n],i++,0);
  80 /*                      t = a[(4-s)&3] + md5_F(a[(4-s-1)&3],a[(4-s-2)&3],a[(4-s-3)&3])
  81                                 + ((uint8_t*)block)[s+4*k] + md5_T[i++];
  82                         a[(4-s)&3] = a[(4-s-1)&3] + ROTL32(t, s*5+7);
  83 */              }
  84         }
  85         /* round 2 */
  86         uint8_t s2t[]={5,9,14,20};
  87         for(m=0;m<4;++m){
  88                 for(n=0;n<4;++n){
  89                         md5_core(a, 4-n, block, (1+m*4+n*5)&0xf, s2t[n],i++,1);
  90                 }
  91         }
  92 /*      for(k=0;k<4;++k){
  93                 for(s=0;s<4;++s){
  94                         t = a[(4-s)&3] + md5_G(a[(4-s-1)&3],a[(4-s-2)&3],a[(4-s-3)&3])
  95                                 + ((uint8_t*)block)[((1+s*5) +(k*4))&0xf] + md5_T[i++];
  96                         a[(4-s)&3] = a[(4-s-1)&3] + ROTL32(t, s2t[s]);
  97                 }
  98         }
  99 */
 100         /* round 3 */
 101         uint8_t s3t[]={4,11,16,23};
 102         for(m=0;m<4;++m){
 103                 for(n=0;n<4;++n){
 104                         md5_core(a, 4-n, block, (5-m*4+n*3)&0xf, s3t[n],i++,2);
 105                 }
 106         }
 107 /*      for(k=0;k<4;++k){
 108                 for(s=0;s<4;++s){
 109                         t = a[(4-s)&3] + md5_H(a[(4-s-1)&3],a[(4-s-2)&3],a[(4-s-3)&3])
 110                                 + ((uint8_t*)block)[((5+s*3)-(k*4))&0xf] + md5_T[i++];
 111                         a[(4-s)&3] = a[(4-s-1)&3] + ROTL32(t, s3t[s]);
 112                 }
 113         } */
 114         /* round 4 */
 115         uint8_t s4t[]={6,10,15,21};
 116         for(m=0;m<4;++m){
 117                 for(n=0;n<4;++n){
 118                         md5_core(a, 4-n, block, (0-m*4+n*7)&0xf, s4t[n],i++,3);
 119                 }
 120         }
 121 /*      for(k=0;k<4;++k){
 122                 for(s=0;s<4;++s){
 123                         t = a[(4-s)&3] + md5_I(a[(4-s-1)&3],a[(4-s-2)&3],a[(4-s-3)&3])
 124                                 + ((uint8_t*)block)[((s*7)-(k*4))&0xf] + md5_T[i++];
 125                         a[(4-s)&3] = a[(4-s-1)&3] + ROTL32(t, s4t[s]);
 126                 }
 127         } */
 128         state->a[0] += a[0];
 129         state->a[1] += a[1];
 130         state->a[2] += a[2];
 131         state->a[3] += a[3];
 132         state->counter++;
 133 }
 134
 135 void md5_lastBlock(md5_ctx_t *state, void* block, uint16_t length){
 136         uint16_t l;
 137         uint8_t b[64];
 138         while (length >= 512){
 139                 md5_nextBlock(state, block);
 140                 length -= 512;
 141                 block += 512/8;
 142         }
 143         memset(b, 0, 64);
 144         memcpy(b, block, length/8);
 145         /* insert padding one */
 146         l=length/8;
 147         if(length%8){
 148                 uint8_t t;
 149                 t = ((uint8_t*)block)[l];
 150                 t |= (0x80>>(length%8));
 151                 b[l]=t;
 152         }else{
 153                 b[l]=0x80;
 154         }
 155         /* insert length value */
 156         if(l+sizeof(uint64_t) > 512/8){
 157                 md5_nextBlock(state, b);
 158                 state->counter--;
 159                 memset(b, 0, 64);
 160         }
 161         *((uint64_t*)&b[64-sizeof(uint64_t)]) = (state->counter * 512) + length;
 162         md5_nextBlock(state, b);
 163 }