1 /*
2 * md5.c
3 * Adapted for perf_index from ccmd5_ltc.c in corecrypto
4 *
5 * Created by Fabrice Gautier on 12/3/10.
6 * Copyright 2010,2011 Apple Inc. All rights reserved.
7 *
8 */
9
10 #include "md5.h"
11
12 #include <stdint.h>
13 #include <string.h>
14
15 #define CCMD5_BLOCK_SIZE 64
16
17 #define F(x, y, z) (z ^ (x & (y ^ z)))
18 #define G(x, y, z) (y ^ (z & (y ^ x)))
19 #define H(x, y, z) (x^y^z)
20 #define I(x, y, z) (y^(x|(~z)))
21
22 #define CC_ROLc(X, s) (((X) << (s)) | ((X) >> (32 - (s))))
23
24 #define FF(a, b, c, d, M, s, t) \
25 a = (a + F(b,c,d) + M + t); a = CC_ROLc(a, s) + b;
26
27 #define GG(a, b, c, d, M, s, t) \
28 a = (a + G(b,c,d) + M + t); a = CC_ROLc(a, s) + b;
29
30 #define HH(a, b, c, d, M, s, t) \
31 a = (a + H(b,c,d) + M + t); a = CC_ROLc(a, s) + b;
32
33 #define II(a, b, c, d, M, s, t) \
34 a = (a + I(b,c,d) + M + t); a = CC_ROLc(a, s) + b;
35
36 static void
md5_compress(uint32_t * state,unsigned long nblocks,const void * in)37 md5_compress(uint32_t *state, unsigned long nblocks, const void *in)
38 {
39 uint32_t i, W[16], a, b, c, d;
40 uint32_t *s = state;
41 const unsigned char *buf = in;
42
43 while (nblocks--) {
44 /* copy the state into 512-bits into W[0..15] */
45 for (i = 0; i < 16; i++) {
46 W[i] = ((uint32_t*)buf)[i];
47 }
48
49 /* copy state */
50 a = s[0];
51 b = s[1];
52 c = s[2];
53 d = s[3];
54
55 FF(a, b, c, d, W[0], 7, 0xd76aa478)
56 FF(d, a, b, c, W[1], 12, 0xe8c7b756)
57 FF(c, d, a, b, W[2], 17, 0x242070db)
58 FF(b, c, d, a, W[3], 22, 0xc1bdceee)
59 FF(a, b, c, d, W[4], 7, 0xf57c0faf)
60 FF(d, a, b, c, W[5], 12, 0x4787c62a)
61 FF(c, d, a, b, W[6], 17, 0xa8304613)
62 FF(b, c, d, a, W[7], 22, 0xfd469501)
63 FF(a, b, c, d, W[8], 7, 0x698098d8)
64 FF(d, a, b, c, W[9], 12, 0x8b44f7af)
65 FF(c, d, a, b, W[10], 17, 0xffff5bb1)
66 FF(b, c, d, a, W[11], 22, 0x895cd7be)
67 FF(a, b, c, d, W[12], 7, 0x6b901122)
68 FF(d, a, b, c, W[13], 12, 0xfd987193)
69 FF(c, d, a, b, W[14], 17, 0xa679438e)
70 FF(b, c, d, a, W[15], 22, 0x49b40821)
71 GG(a, b, c, d, W[1], 5, 0xf61e2562)
72 GG(d, a, b, c, W[6], 9, 0xc040b340)
73 GG(c, d, a, b, W[11], 14, 0x265e5a51)
74 GG(b, c, d, a, W[0], 20, 0xe9b6c7aa)
75 GG(a, b, c, d, W[5], 5, 0xd62f105d)
76 GG(d, a, b, c, W[10], 9, 0x02441453)
77 GG(c, d, a, b, W[15], 14, 0xd8a1e681)
78 GG(b, c, d, a, W[4], 20, 0xe7d3fbc8)
79 GG(a, b, c, d, W[9], 5, 0x21e1cde6)
80 GG(d, a, b, c, W[14], 9, 0xc33707d6)
81 GG(c, d, a, b, W[3], 14, 0xf4d50d87)
82 GG(b, c, d, a, W[8], 20, 0x455a14ed)
83 GG(a, b, c, d, W[13], 5, 0xa9e3e905)
84 GG(d, a, b, c, W[2], 9, 0xfcefa3f8)
85 GG(c, d, a, b, W[7], 14, 0x676f02d9)
86 GG(b, c, d, a, W[12], 20, 0x8d2a4c8a)
87 HH(a, b, c, d, W[5], 4, 0xfffa3942)
88 HH(d, a, b, c, W[8], 11, 0x8771f681)
89 HH(c, d, a, b, W[11], 16, 0x6d9d6122)
90 HH(b, c, d, a, W[14], 23, 0xfde5380c)
91 HH(a, b, c, d, W[1], 4, 0xa4beea44)
92 HH(d, a, b, c, W[4], 11, 0x4bdecfa9)
93 HH(c, d, a, b, W[7], 16, 0xf6bb4b60)
94 HH(b, c, d, a, W[10], 23, 0xbebfbc70)
95 HH(a, b, c, d, W[13], 4, 0x289b7ec6)
96 HH(d, a, b, c, W[0], 11, 0xeaa127fa)
97 HH(c, d, a, b, W[3], 16, 0xd4ef3085)
98 HH(b, c, d, a, W[6], 23, 0x04881d05)
99 HH(a, b, c, d, W[9], 4, 0xd9d4d039)
100 HH(d, a, b, c, W[12], 11, 0xe6db99e5)
101 HH(c, d, a, b, W[15], 16, 0x1fa27cf8)
102 HH(b, c, d, a, W[2], 23, 0xc4ac5665)
103 II(a, b, c, d, W[0], 6, 0xf4292244)
104 II(d, a, b, c, W[7], 10, 0x432aff97)
105 II(c, d, a, b, W[14], 15, 0xab9423a7)
106 II(b, c, d, a, W[5], 21, 0xfc93a039)
107 II(a, b, c, d, W[12], 6, 0x655b59c3)
108 II(d, a, b, c, W[3], 10, 0x8f0ccc92)
109 II(c, d, a, b, W[10], 15, 0xffeff47d)
110 II(b, c, d, a, W[1], 21, 0x85845dd1)
111 II(a, b, c, d, W[8], 6, 0x6fa87e4f)
112 II(d, a, b, c, W[15], 10, 0xfe2ce6e0)
113 II(c, d, a, b, W[6], 15, 0xa3014314)
114 II(b, c, d, a, W[13], 21, 0x4e0811a1)
115 II(a, b, c, d, W[4], 6, 0xf7537e82)
116 II(d, a, b, c, W[11], 10, 0xbd3af235)
117 II(c, d, a, b, W[2], 15, 0x2ad7d2bb)
118 II(b, c, d, a, W[9], 21, 0xeb86d391)
119
120 /* store state */
121 s[0] += a;
122 s[1] += b;
123 s[2] += c;
124 s[3] += d;
125
126 buf += CCMD5_BLOCK_SIZE;
127 }
128 }
129
130 void
md5_hash(uint8_t * message,uint64_t len,uint32_t * hash)131 md5_hash(uint8_t *message, uint64_t len, uint32_t *hash)
132 {
133 hash[0] = 0x67452301;
134 hash[1] = 0xEFCDAB89;
135 hash[2] = 0x98BADCFE;
136 hash[3] = 0x10325476;
137
138 md5_compress(hash, len / 64, message);
139
140 uint32_t blockbuff[16];
141 uint8_t *byteptr = (uint8_t*)blockbuff;
142
143 int left = len % 64;
144 memcpy(byteptr, message + len - left, left);
145
146 byteptr[left] = 0x80;
147 left++;
148 if (64 - left >= 8) {
149 bzero(byteptr + left, 56 - left);
150 } else {
151 memset(byteptr + left, 0, 64 - left);
152 md5_compress(hash, 1, blockbuff);
153 bzero(blockbuff, 56);
154 }
155 blockbuff[14] = (uint32_t)(len << 3);
156 blockbuff[15] = (uint32_t)(len >> 29);
157 md5_compress(hash, 1, blockbuff);
158 }
159