Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_md5.c
Go to the documentation of this file.
1 
2 /*
3  * An internal implementation, based on Alexander Peslyak's
4  * public domain implementation:
5  * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
6  * It is not expected to be optimal and is used only
7  * if no MD5 implementation was found in system.
8  */
9 
10 
11 #include <ngx_config.h>
12 #include <ngx_core.h>
13 #include <ngx_md5.h>
14 
15 
16 #if !(NGX_HAVE_MD5)
17 
18 static const u_char *ngx_md5_body(ngx_md5_t *ctx, const u_char *data,
19  size_t size);
20 
21 
22 void
23 ngx_md5_init(ngx_md5_t *ctx)
24 {
25  ctx->a = 0x67452301;
26  ctx->b = 0xefcdab89;
27  ctx->c = 0x98badcfe;
28  ctx->d = 0x10325476;
29 
30  ctx->bytes = 0;
31 }
32 
33 
34 void
35 ngx_md5_update(ngx_md5_t *ctx, const void *data, size_t size)
36 {
37  size_t used, free;
38 
39  used = (size_t) (ctx->bytes & 0x3f);
40  ctx->bytes += size;
41 
42  if (used) {
43  free = 64 - used;
44 
45  if (size < free) {
46  ngx_memcpy(&ctx->buffer[used], data, size);
47  return;
48  }
49 
50  ngx_memcpy(&ctx->buffer[used], data, free);
51  data = (u_char *) data + free;
52  size -= free;
53  (void) ngx_md5_body(ctx, ctx->buffer, 64);
54  }
55 
56  if (size >= 64) {
57  data = ngx_md5_body(ctx, data, size & ~(size_t) 0x3f);
58  size &= 0x3f;
59  }
60 
61  ngx_memcpy(ctx->buffer, data, size);
62 }
63 
64 
65 void
66 ngx_md5_final(u_char result[16], ngx_md5_t *ctx)
67 {
68  size_t used, free;
69 
70  used = (size_t) (ctx->bytes & 0x3f);
71 
72  ctx->buffer[used++] = 0x80;
73 
74  free = 64 - used;
75 
76  if (free < 8) {
77  ngx_memzero(&ctx->buffer[used], free);
78  (void) ngx_md5_body(ctx, ctx->buffer, 64);
79  used = 0;
80  free = 64;
81  }
82 
83  ngx_memzero(&ctx->buffer[used], free - 8);
84 
85  ctx->bytes <<= 3;
86  ctx->buffer[56] = (u_char) ctx->bytes;
87  ctx->buffer[57] = (u_char) (ctx->bytes >> 8);
88  ctx->buffer[58] = (u_char) (ctx->bytes >> 16);
89  ctx->buffer[59] = (u_char) (ctx->bytes >> 24);
90  ctx->buffer[60] = (u_char) (ctx->bytes >> 32);
91  ctx->buffer[61] = (u_char) (ctx->bytes >> 40);
92  ctx->buffer[62] = (u_char) (ctx->bytes >> 48);
93  ctx->buffer[63] = (u_char) (ctx->bytes >> 56);
94 
95  (void) ngx_md5_body(ctx, ctx->buffer, 64);
96 
97  result[0] = (u_char) ctx->a;
98  result[1] = (u_char) (ctx->a >> 8);
99  result[2] = (u_char) (ctx->a >> 16);
100  result[3] = (u_char) (ctx->a >> 24);
101  result[4] = (u_char) ctx->b;
102  result[5] = (u_char) (ctx->b >> 8);
103  result[6] = (u_char) (ctx->b >> 16);
104  result[7] = (u_char) (ctx->b >> 24);
105  result[8] = (u_char) ctx->c;
106  result[9] = (u_char) (ctx->c >> 8);
107  result[10] = (u_char) (ctx->c >> 16);
108  result[11] = (u_char) (ctx->c >> 24);
109  result[12] = (u_char) ctx->d;
110  result[13] = (u_char) (ctx->d >> 8);
111  result[14] = (u_char) (ctx->d >> 16);
112  result[15] = (u_char) (ctx->d >> 24);
113 
114  ngx_memzero(ctx, sizeof(*ctx));
115 }
116 
117 
118 /*
119  * The basic MD5 functions.
120  *
121  * F and G are optimized compared to their RFC 1321 definitions for
122  * architectures that lack an AND-NOT instruction, just like in
123  * Colin Plumb's implementation.
124  */
125 
126 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
127 #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
128 #define H(x, y, z) ((x) ^ (y) ^ (z))
129 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
130 
131 /*
132  * The MD5 transformation for all four rounds.
133  */
134 
135 #define STEP(f, a, b, c, d, x, t, s) \
136  (a) += f((b), (c), (d)) + (x) + (t); \
137  (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
138  (a) += (b)
139 
140 /*
141  * SET() reads 4 input bytes in little-endian byte order and stores them
142  * in a properly aligned word in host byte order.
143  *
144  * The check for little-endian architectures that tolerate unaligned
145  * memory accesses is just an optimization. Nothing will break if it
146  * does not work.
147  */
148 
149 #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)
150 
151 #define SET(n) (*(uint32_t *) &p[n * 4])
152 #define GET(n) (*(uint32_t *) &p[n * 4])
153 
154 #else
155 
156 #define SET(n) \
157  (block[n] = \
158  (uint32_t) p[n * 4] | \
159  ((uint32_t) p[n * 4 + 1] << 8) | \
160  ((uint32_t) p[n * 4 + 2] << 16) | \
161  ((uint32_t) p[n * 4 + 3] << 24))
162 
163 #define GET(n) block[n]
164 
165 #endif
166 
167 
168 /*
169  * This processes one or more 64-byte data blocks, but does not update
170  * the bit counters. There are no alignment requirements.
171  */
172 
173 static const u_char *
174 ngx_md5_body(ngx_md5_t *ctx, const u_char *data, size_t size)
175 {
176  uint32_t a, b, c, d;
177  uint32_t saved_a, saved_b, saved_c, saved_d;
178  const u_char *p;
179 #if !(NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)
180  uint32_t block[16];
181 #endif
182 
183  p = data;
184 
185  a = ctx->a;
186  b = ctx->b;
187  c = ctx->c;
188  d = ctx->d;
189 
190  do {
191  saved_a = a;
192  saved_b = b;
193  saved_c = c;
194  saved_d = d;
195 
196  /* Round 1 */
197 
198  STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7);
199  STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12);
200  STEP(F, c, d, a, b, SET(2), 0x242070db, 17);
201  STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22);
202  STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7);
203  STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12);
204  STEP(F, c, d, a, b, SET(6), 0xa8304613, 17);
205  STEP(F, b, c, d, a, SET(7), 0xfd469501, 22);
206  STEP(F, a, b, c, d, SET(8), 0x698098d8, 7);
207  STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12);
208  STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17);
209  STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22);
210  STEP(F, a, b, c, d, SET(12), 0x6b901122, 7);
211  STEP(F, d, a, b, c, SET(13), 0xfd987193, 12);
212  STEP(F, c, d, a, b, SET(14), 0xa679438e, 17);
213  STEP(F, b, c, d, a, SET(15), 0x49b40821, 22);
214 
215  /* Round 2 */
216 
217  STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5);
218  STEP(G, d, a, b, c, GET(6), 0xc040b340, 9);
219  STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14);
220  STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20);
221  STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5);
222  STEP(G, d, a, b, c, GET(10), 0x02441453, 9);
223  STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14);
224  STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20);
225  STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5);
226  STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9);
227  STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14);
228  STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20);
229  STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5);
230  STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9);
231  STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14);
232  STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20);
233 
234  /* Round 3 */
235 
236  STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4);
237  STEP(H, d, a, b, c, GET(8), 0x8771f681, 11);
238  STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16);
239  STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23);
240  STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4);
241  STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11);
242  STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16);
243  STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23);
244  STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4);
245  STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11);
246  STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16);
247  STEP(H, b, c, d, a, GET(6), 0x04881d05, 23);
248  STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4);
249  STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11);
250  STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16);
251  STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23);
252 
253  /* Round 4 */
254 
255  STEP(I, a, b, c, d, GET(0), 0xf4292244, 6);
256  STEP(I, d, a, b, c, GET(7), 0x432aff97, 10);
257  STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15);
258  STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21);
259  STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6);
260  STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10);
261  STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15);
262  STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21);
263  STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6);
264  STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10);
265  STEP(I, c, d, a, b, GET(6), 0xa3014314, 15);
266  STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21);
267  STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6);
268  STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10);
269  STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15);
270  STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21);
271 
272  a += saved_a;
273  b += saved_b;
274  c += saved_c;
275  d += saved_d;
276 
277  p += 64;
278 
279  } while (size -= 64);
280 
281  ctx->a = a;
282  ctx->b = b;
283  ctx->c = c;
284  ctx->d = d;
285 
286  return p;
287 }
288 
289 #endif
Generated on Sun Nov 10 2013 09:49:06 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2