]> git.cryptolib.org Git - avr-crypto-lib.git/blob - md5.c
5c7bb9a6d67af119ae3938dc03baa1cd73ae09ae
[avr-crypto-lib.git] / 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 }