Logo ROOT  
Reference Guide
md5.inl
Go to the documentation of this file.
1 /*
2  * This an amalgamation of md5.c and md5.h into a single file
3  * with all static declaration to reduce linker conflicts
4  * in Civetweb.
5  *
6  * The MD5_STATIC declaration was added to facilitate static
7  * inclusion.
8  * No Face Press, LLC
9  */
10 
11 /* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
12 /*
13  Independent implementation of MD5 (RFC 1321).
14 
15  This code implements the MD5 Algorithm defined in RFC 1321, whose
16  text is available at
17  http://www.ietf.org/rfc/rfc1321.txt
18  The code is derived from the text of the RFC, including the test suite
19  (section A.5) but excluding the rest of Appendix A. It does not include
20  any code or documentation that is identified in the RFC as being
21  copyrighted.
22 
23  The original and principal author of md5.h is L. Peter Deutsch
24  <ghost@aladdin.com>. Other authors are noted in the change history
25  that follows (in reverse chronological order):
26 
27  2002-04-13 lpd Removed support for non-ANSI compilers; removed
28  references to Ghostscript; clarified derivation from RFC 1321;
29  now handles byte order either statically or dynamically.
30  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
31  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
32  added conditionalization for C++ compilation from Martin
33  Purschke <purschke@bnl.gov>.
34  1999-05-03 lpd Original version.
35  */
36 
37 #if !defined(md5_INCLUDED)
38 #define md5_INCLUDED
39 
40 /*
41  * This package supports both compile-time and run-time determination of CPU
42  * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
43  * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
44  * defined as non-zero, the code will be compiled to run only on big-endian
45  * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
46  * run on either big- or little-endian CPUs, but will run slightly less
47  * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
48  */
49 
50 typedef unsigned char md5_byte_t; /* 8-bit byte */
51 typedef unsigned int md5_word_t; /* 32-bit word */
52 
53 /* Define the state of the MD5 Algorithm. */
54 typedef struct md5_state_s {
55  md5_word_t count[2]; /* message length in bits, lsw first */
56  md5_word_t abcd[4]; /* digest buffer */
57  md5_byte_t buf[64]; /* accumulate block */
58 } md5_state_t;
59 
60 #if defined(__cplusplus)
61 extern "C" {
62 #endif
63 
64 /* Initialize the algorithm. */
66 
67 /* Append a string to the message. */
68 MD5_STATIC void
69 md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes);
70 
71 /* Finish the message and return the digest. */
72 MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
73 
74 #if defined(__cplusplus)
75 } /* end extern "C" */
76 #endif
77 
78 #endif /* md5_INCLUDED */
79 
80 /*
81  Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved.
82 
83  This software is provided 'as-is', without any express or implied
84  warranty. In no event will the authors be held liable for any damages
85  arising from the use of this software.
86 
87  Permission is granted to anyone to use this software for any purpose,
88  including commercial applications, and to alter it and redistribute it
89  freely, subject to the following restrictions:
90 
91  1. The origin of this software must not be misrepresented; you must not
92  claim that you wrote the original software. If you use this software
93  in a product, an acknowledgment in the product documentation would be
94  appreciated but is not required.
95  2. Altered source versions must be plainly marked as such, and must not be
96  misrepresented as being the original software.
97  3. This notice may not be removed or altered from any source distribution.
98 
99  L. Peter Deutsch
100  ghost@aladdin.com
101 
102  */
103 /* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
104 /*
105  Independent implementation of MD5 (RFC 1321).
106 
107  This code implements the MD5 Algorithm defined in RFC 1321, whose
108  text is available at
109  http://www.ietf.org/rfc/rfc1321.txt
110  The code is derived from the text of the RFC, including the test suite
111  (section A.5) but excluding the rest of Appendix A. It does not include
112  any code or documentation that is identified in the RFC as being
113  copyrighted.
114 
115  The original and principal author of md5.c is L. Peter Deutsch
116  <ghost@aladdin.com>. Other authors are noted in the change history
117  that follows (in reverse chronological order):
118 
119  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
120  either statically or dynamically; added missing #include <string.h>
121  in library.
122  2002-03-11 lpd Corrected argument list for main(), and added int return
123  type, in test program and T value program.
124  2002-02-21 lpd Added missing #include <stdio.h> in test program.
125  2000-07-03 lpd Patched to eliminate warnings about "constant is
126  unsigned in ANSI C, signed in traditional"; made test program
127  self-checking.
128  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
129  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
130  1999-05-03 lpd Original version.
131  */
132 
133 #if !defined(MD5_STATIC)
134 #include <string.h>
135 #endif
136 
137 #undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
138 #if defined(ARCH_IS_BIG_ENDIAN)
139 #define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
140 #else
141 #define BYTE_ORDER (0)
142 #endif
143 
144 #define T_MASK ((md5_word_t)~0)
145 #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
146 #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
147 #define T3 (0x242070db)
148 #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
149 #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
150 #define T6 (0x4787c62a)
151 #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
152 #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
153 #define T9 (0x698098d8)
154 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
155 #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
156 #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
157 #define T13 (0x6b901122)
158 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
159 #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
160 #define T16 (0x49b40821)
161 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
162 #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
163 #define T19 (0x265e5a51)
164 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
165 #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
166 #define T22 (0x02441453)
167 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
168 #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
169 #define T25 (0x21e1cde6)
170 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
171 #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
172 #define T28 (0x455a14ed)
173 #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
174 #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
175 #define T31 (0x676f02d9)
176 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
177 #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
178 #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
179 #define T35 (0x6d9d6122)
180 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
181 #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
182 #define T38 (0x4bdecfa9)
183 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
184 #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
185 #define T41 (0x289b7ec6)
186 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
187 #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
188 #define T44 (0x04881d05)
189 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
190 #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
191 #define T47 (0x1fa27cf8)
192 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
193 #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
194 #define T50 (0x432aff97)
195 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
196 #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
197 #define T53 (0x655b59c3)
198 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
199 #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
200 #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
201 #define T57 (0x6fa87e4f)
202 #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
203 #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
204 #define T60 (0x4e0811a1)
205 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
206 #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
207 #define T63 (0x2ad7d2bb)
208 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
209 
210 static void
211 md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
212 {
213  md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2],
214  d = pms->abcd[3];
215  md5_word_t t;
216 #if BYTE_ORDER > 0
217  /* Define storage only for big-endian CPUs. */
218  md5_word_t X[16];
219 #else
220  /* Define storage for little-endian or both types of CPUs. */
221  md5_word_t xbuf[16];
222  const md5_word_t *X;
223 #endif
224 
225  {
226 #if BYTE_ORDER == 0
227  /*
228  * Determine dynamically whether this is a big-endian or
229  * little-endian machine, since we can use a more efficient
230  * algorithm on the latter.
231  */
232  static const int w = 1;
233 
234  if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
235 #endif
236 #if BYTE_ORDER <= 0 /* little-endian */
237  {
238  /*
239  * On little-endian machines, we can process properly aligned
240  * data without copying it.
241  */
242  if (!((data - (const md5_byte_t *)0) & 3)) {
243  /* data are properly aligned, a direct assignment is possible */
244  /* cast through a (void *) should avoid a compiler warning,
245  see
246  https://github.com/bel2125/civetweb/issues/94#issuecomment-98112861
247  */
248  X = (const md5_word_t *)(const void *)data;
249  } else {
250  /* not aligned */
251  memcpy(xbuf, data, 64);
252  X = xbuf;
253  }
254  }
255 #endif
256 #if BYTE_ORDER == 0
257  else /* dynamic big-endian */
258 #endif
259 #if BYTE_ORDER >= 0 /* big-endian */
260  {
261  /*
262  * On big-endian machines, we must arrange the bytes in the
263  * right order.
264  */
265  const md5_byte_t *xp = data;
266  int i;
267 
268 #if BYTE_ORDER == 0
269  X = xbuf; /* (dynamic only) */
270 #else
271 #define xbuf X /* (static only) */
272 #endif
273  for (i = 0; i < 16; ++i, xp += 4)
274  xbuf[i] = (md5_word_t)(xp[0]) + (md5_word_t)(xp[1] << 8)
275  + (md5_word_t)(xp[2] << 16)
276  + (md5_word_t)(xp[3] << 24);
277  }
278 #endif
279  }
280 
281 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
282 
283 /* Round 1. */
284 /* Let [abcd k s i] denote the operation
285  a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
286 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
287 #define SET(a, b, c, d, k, s, Ti) \
288  t = a + F(b, c, d) + X[k] + Ti; \
289  a = ROTATE_LEFT(t, s) + b
290 
291  /* Do the following 16 operations. */
292  SET(a, b, c, d, 0, 7, T1);
293  SET(d, a, b, c, 1, 12, T2);
294  SET(c, d, a, b, 2, 17, T3);
295  SET(b, c, d, a, 3, 22, T4);
296  SET(a, b, c, d, 4, 7, T5);
297  SET(d, a, b, c, 5, 12, T6);
298  SET(c, d, a, b, 6, 17, T7);
299  SET(b, c, d, a, 7, 22, T8);
300  SET(a, b, c, d, 8, 7, T9);
301  SET(d, a, b, c, 9, 12, T10);
302  SET(c, d, a, b, 10, 17, T11);
303  SET(b, c, d, a, 11, 22, T12);
304  SET(a, b, c, d, 12, 7, T13);
305  SET(d, a, b, c, 13, 12, T14);
306  SET(c, d, a, b, 14, 17, T15);
307  SET(b, c, d, a, 15, 22, T16);
308 #undef SET
309 
310 /* Round 2. */
311 /* Let [abcd k s i] denote the operation
312  a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
313 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
314 #define SET(a, b, c, d, k, s, Ti) \
315  t = a + G(b, c, d) + X[k] + Ti; \
316  a = ROTATE_LEFT(t, s) + b
317 
318  /* Do the following 16 operations. */
319  SET(a, b, c, d, 1, 5, T17);
320  SET(d, a, b, c, 6, 9, T18);
321  SET(c, d, a, b, 11, 14, T19);
322  SET(b, c, d, a, 0, 20, T20);
323  SET(a, b, c, d, 5, 5, T21);
324  SET(d, a, b, c, 10, 9, T22);
325  SET(c, d, a, b, 15, 14, T23);
326  SET(b, c, d, a, 4, 20, T24);
327  SET(a, b, c, d, 9, 5, T25);
328  SET(d, a, b, c, 14, 9, T26);
329  SET(c, d, a, b, 3, 14, T27);
330  SET(b, c, d, a, 8, 20, T28);
331  SET(a, b, c, d, 13, 5, T29);
332  SET(d, a, b, c, 2, 9, T30);
333  SET(c, d, a, b, 7, 14, T31);
334  SET(b, c, d, a, 12, 20, T32);
335 #undef SET
336 
337 /* Round 3. */
338 /* Let [abcd k s t] denote the operation
339  a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
340 #define H(x, y, z) ((x) ^ (y) ^ (z))
341 #define SET(a, b, c, d, k, s, Ti) \
342  t = a + H(b, c, d) + X[k] + Ti; \
343  a = ROTATE_LEFT(t, s) + b
344 
345  /* Do the following 16 operations. */
346  SET(a, b, c, d, 5, 4, T33);
347  SET(d, a, b, c, 8, 11, T34);
348  SET(c, d, a, b, 11, 16, T35);
349  SET(b, c, d, a, 14, 23, T36);
350  SET(a, b, c, d, 1, 4, T37);
351  SET(d, a, b, c, 4, 11, T38);
352  SET(c, d, a, b, 7, 16, T39);
353  SET(b, c, d, a, 10, 23, T40);
354  SET(a, b, c, d, 13, 4, T41);
355  SET(d, a, b, c, 0, 11, T42);
356  SET(c, d, a, b, 3, 16, T43);
357  SET(b, c, d, a, 6, 23, T44);
358  SET(a, b, c, d, 9, 4, T45);
359  SET(d, a, b, c, 12, 11, T46);
360  SET(c, d, a, b, 15, 16, T47);
361  SET(b, c, d, a, 2, 23, T48);
362 #undef SET
363 
364 /* Round 4. */
365 /* Let [abcd k s t] denote the operation
366  a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
367 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
368 #define SET(a, b, c, d, k, s, Ti) \
369  t = a + I(b, c, d) + X[k] + Ti; \
370  a = ROTATE_LEFT(t, s) + b
371 
372  /* Do the following 16 operations. */
373  SET(a, b, c, d, 0, 6, T49);
374  SET(d, a, b, c, 7, 10, T50);
375  SET(c, d, a, b, 14, 15, T51);
376  SET(b, c, d, a, 5, 21, T52);
377  SET(a, b, c, d, 12, 6, T53);
378  SET(d, a, b, c, 3, 10, T54);
379  SET(c, d, a, b, 10, 15, T55);
380  SET(b, c, d, a, 1, 21, T56);
381  SET(a, b, c, d, 8, 6, T57);
382  SET(d, a, b, c, 15, 10, T58);
383  SET(c, d, a, b, 6, 15, T59);
384  SET(b, c, d, a, 13, 21, T60);
385  SET(a, b, c, d, 4, 6, T61);
386  SET(d, a, b, c, 11, 10, T62);
387  SET(c, d, a, b, 2, 15, T63);
388  SET(b, c, d, a, 9, 21, T64);
389 #undef SET
390 
391  /* Then perform the following additions. (That is increment each
392  of the four registers by the value it had before this block
393  was started.) */
394  pms->abcd[0] += a;
395  pms->abcd[1] += b;
396  pms->abcd[2] += c;
397  pms->abcd[3] += d;
398 }
399 
400 MD5_STATIC void
402 {
403  pms->count[0] = pms->count[1] = 0;
404  pms->abcd[0] = 0x67452301;
405  pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
406  pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
407  pms->abcd[3] = 0x10325476;
408 }
409 
410 MD5_STATIC void
411 md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes)
412 {
413  const md5_byte_t *p = data;
414  size_t left = nbytes;
415  size_t offset = (pms->count[0] >> 3) & 63;
416  md5_word_t nbits = (md5_word_t)(nbytes << 3);
417 
418  if (nbytes <= 0)
419  return;
420 
421  /* Update the message length. */
422  pms->count[1] += (md5_word_t)(nbytes >> 29);
423  pms->count[0] += nbits;
424  if (pms->count[0] < nbits)
425  pms->count[1]++;
426 
427  /* Process an initial partial block. */
428  if (offset) {
429  size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
430 
431  memcpy(pms->buf + offset, p, copy);
432  if (offset + copy < 64)
433  return;
434  p += copy;
435  left -= copy;
436  md5_process(pms, pms->buf);
437  }
438 
439  /* Process full blocks. */
440  for (; left >= 64; p += 64, left -= 64)
441  md5_process(pms, p);
442 
443  /* Process a final partial block. */
444  if (left)
445  memcpy(pms->buf, p, left);
446 }
447 
448 MD5_STATIC void
450 {
451  static const md5_byte_t pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
453  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
454  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
455  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
456  md5_byte_t data[8];
457  int i;
458 
459  /* Save the length before padding. */
460  for (i = 0; i < 8; ++i)
461  data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
462  /* Pad to 56 bytes mod 64. */
463  md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
464  /* Append the length. */
465  md5_append(pms, data, 8);
466  for (i = 0; i < 16; ++i)
467  digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
468 }
469 
470 
471 /* End of md5.inl */
T25
#define T25
Definition: md5.inl:169
c
#define c(i)
Definition: RSha256.hxx:119
T9
#define T9
Definition: md5.inl:153
T46
#define T46
Definition: md5.inl:190
T24
#define T24
Definition: md5.inl:168
T7
#define T7
Definition: md5.inl:151
SET
#define SET(a, b, c, d, k, s, Ti)
T26
#define T26
Definition: md5.inl:170
T17
#define T17
Definition: md5.inl:161
T33
#define T33
Definition: md5.inl:177
md5_process
static void md5_process(md5_state_t *pms, const md5_byte_t *data)
Definition: md5.inl:211
T27
#define T27
Definition: md5.inl:171
T29
#define T29
Definition: md5.inl:173
T42
#define T42
Definition: md5.inl:186
T18
#define T18
Definition: md5.inl:162
T3
#define T3
Definition: md5.inl:147
T21
#define T21
Definition: md5.inl:165
T22
#define T22
Definition: md5.inl:166
T32
#define T32
Definition: md5.inl:176
T55
#define T55
Definition: md5.inl:199
T38
#define T38
Definition: md5.inl:182
T54
#define T54
Definition: md5.inl:198
T56
#define T56
Definition: md5.inl:200
T13
#define T13
Definition: md5.inl:157
T39
#define T39
Definition: md5.inl:183
T64
#define T64
Definition: md5.inl:208
b
#define b(i)
Definition: RSha256.hxx:118
T31
#define T31
Definition: md5.inl:175
T34
#define T34
Definition: md5.inl:178
T48
#define T48
Definition: md5.inl:192
T43
#define T43
Definition: md5.inl:187
T14
#define T14
Definition: md5.inl:158
T50
#define T50
Definition: md5.inl:194
md5_init
MD5_STATIC void md5_init(md5_state_t *pms)
Definition: md5.inl:401
T59
#define T59
Definition: md5.inl:203
T15
#define T15
Definition: md5.inl:159
T5
#define T5
Definition: md5.inl:149
T62
#define T62
Definition: md5.inl:206
T41
#define T41
Definition: md5.inl:185
md5_append
MD5_STATIC void md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes)
Definition: md5.inl:411
T53
#define T53
Definition: md5.inl:197
T35
#define T35
Definition: md5.inl:179
MD5_STATIC
#define MD5_STATIC
Definition: civetweb.c:1706
T63
#define T63
Definition: md5.inl:207
md5_state_t
struct md5_state_s md5_state_t
md5_byte_t
unsigned char md5_byte_t
Definition: md5.inl:50
a
auto * a
Definition: textangle.C:12
T4
#define T4
Definition: md5.inl:148
T8
#define T8
Definition: md5.inl:152
T47
#define T47
Definition: md5.inl:191
T61
#define T61
Definition: md5.inl:205
T23
#define T23
Definition: md5.inl:167
T2
#define T2
Definition: md5.inl:146
T11
#define T11
Definition: md5.inl:155
unsigned int
T49
#define T49
Definition: md5.inl:193
T51
#define T51
Definition: md5.inl:195
md5_finish
MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16])
Definition: md5.inl:449
T6
#define T6
Definition: md5.inl:150
T57
#define T57
Definition: md5.inl:201
T60
#define T60
Definition: md5.inl:204
md5_word_t
unsigned int md5_word_t
Definition: md5.inl:51
T36
#define T36
Definition: md5.inl:180
T1
#define T1
Definition: md5.inl:145
T44
#define T44
Definition: md5.inl:188
T16
#define T16
Definition: md5.inl:160
T37
#define T37
Definition: md5.inl:181
T20
#define T20
Definition: md5.inl:164
d
#define d(i)
Definition: RSha256.hxx:120
T30
#define T30
Definition: md5.inl:174
T_MASK
#define T_MASK
Definition: md5.inl:144
T19
#define T19
Definition: md5.inl:163
T10
#define T10
Definition: md5.inl:154
T58
#define T58
Definition: md5.inl:202
T12
#define T12
Definition: md5.inl:156
T45
#define T45
Definition: md5.inl:189
T40
#define T40
Definition: md5.inl:184
T28
#define T28
Definition: md5.inl:172
T52
#define T52
Definition: md5.inl:196