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