md5.c

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