pacemaker  2.0.2-debe490
Scalable High-Availability cluster resource manager
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
md5.c
Go to the documentation of this file.
1 /* Functions to compute MD5 message digest of files or memory blocks.
2  according to the definition of MD5 in RFC 1321 from April 1992.
3  Copyright (C) 1995-1997, 1999-2001, 2005-2006, 2008-2019 Free Software
4  Foundation, Inc.
5  This file is part of the GNU C Library.
6 
7  This program is free software; you can redistribute it and/or modify it
8  under the terms of the GNU Lesser General Public License as published by the
9  Free Software Foundation; either version 2.1, or (at your option) any
10  later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU Lesser General Public License for more details.
16 
17  You should have received a copy of the GNU Lesser General Public License
18  along with this program; if not, see <https://www.gnu.org/licenses/>. */
19 
20 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. */
21 
22 #include <config.h>
23 
24 #if HAVE_OPENSSL_MD5
25 # define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
26 #endif
27 #include "md5.h"
28 
29 #include <stdalign.h>
30 #include <stdint.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <sys/types.h>
34 
35 #if USE_UNLOCKED_IO
36 # include "unlocked-io.h"
37 #endif
38 
39 #ifdef _LIBC
40 # include <endian.h>
41 # if __BYTE_ORDER == __BIG_ENDIAN
42 # define WORDS_BIGENDIAN 1
43 # endif
44 /* We need to keep the namespace clean so define the MD5 function
45  protected using leading __ . */
46 # define md5_init_ctx __md5_init_ctx
47 # define md5_process_block __md5_process_block
48 # define md5_process_bytes __md5_process_bytes
49 # define md5_finish_ctx __md5_finish_ctx
50 # define md5_read_ctx __md5_read_ctx
51 # define md5_stream __md5_stream
52 # define md5_buffer __md5_buffer
53 #endif
54 
55 #include <byteswap.h>
56 #ifdef WORDS_BIGENDIAN
57 # define SWAP(n) bswap_32 (n)
58 #else
59 # define SWAP(n) (n)
60 #endif
61 
62 #define BLOCKSIZE 32768
63 #if BLOCKSIZE % 64 != 0
64 # error "invalid BLOCKSIZE"
65 #endif
66 
67 #if ! HAVE_OPENSSL_MD5
68 /* This array contains the bytes used to pad the buffer to the next
69  64-byte boundary. (RFC 1321, 3.1: Step 1) */
70 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
71 
72 
73 /* Initialize structure containing state of computation.
74  (RFC 1321, 3.3: Step 3) */
75 void
76 md5_init_ctx (struct md5_ctx *ctx)
77 {
78  ctx->A = 0x67452301;
79  ctx->B = 0xefcdab89;
80  ctx->C = 0x98badcfe;
81  ctx->D = 0x10325476;
82 
83  ctx->total[0] = ctx->total[1] = 0;
84  ctx->buflen = 0;
85 }
86 
87 /* Copy the 4 byte value from v into the memory location pointed to by *cp,
88  If your architecture allows unaligned access this is equivalent to
89  * (uint32_t *) cp = v */
90 static void
91 set_uint32 (char *cp, uint32_t v)
92 {
93  memcpy (cp, &v, sizeof v);
94 }
95 
96 /* Put result from CTX in first 16 bytes following RESBUF. The result
97  must be in little endian byte order. */
98 void *
99 md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
100 {
101  char *r = resbuf;
102  set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A));
103  set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B));
104  set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C));
105  set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D));
106 
107  return resbuf;
108 }
109 
110 /* Process the remaining bytes in the internal buffer and the usual
111  prolog according to the standard and write the result to RESBUF. */
112 void *
113 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
114 {
115  /* Take yet unprocessed bytes into account. */
116  uint32_t bytes = ctx->buflen;
117  size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
118 
119  /* Now count remaining bytes. */
120  ctx->total[0] += bytes;
121  if (ctx->total[0] < bytes)
122  ++ctx->total[1];
123 
124  /* Put the 64-bit file length in *bits* at the end of the buffer. */
125  ctx->buffer[size - 2] = SWAP (ctx->total[0] << 3);
126  ctx->buffer[size - 1] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
127 
128  memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
129 
130  /* Process last bytes. */
131  md5_process_block (ctx->buffer, size * 4, ctx);
132 
133  return md5_read_ctx (ctx, resbuf);
134 }
135 #endif
136 
137 #if defined _LIBC || defined GL_COMPILE_CRYPTO_STREAM
138 
139 #include "af_alg.h"
140 
141 /* Compute MD5 message digest for bytes read from STREAM. The
142  resulting message digest number will be written into the 16 bytes
143  beginning at RESBLOCK. */
144 int
145 md5_stream (FILE *stream, void *resblock)
146 {
147  switch (afalg_stream (stream, "md5", resblock, MD5_DIGEST_SIZE))
148  {
149  case 0: return 0;
150  case -EIO: return 1;
151  }
152 
153  char *buffer = malloc (BLOCKSIZE + 72);
154  if (!buffer)
155  return 1;
156 
157  struct md5_ctx ctx;
158  md5_init_ctx (&ctx);
159  size_t sum;
160 
161  /* Iterate over full file contents. */
162  while (1)
163  {
164  /* We read the file in blocks of BLOCKSIZE bytes. One call of the
165  computation function processes the whole buffer so that with the
166  next round of the loop another block can be read. */
167  size_t n;
168  sum = 0;
169 
170  /* Read block. Take care for partial reads. */
171  while (1)
172  {
173  /* Either process a partial fread() from this loop,
174  or the fread() in afalg_stream may have gotten EOF.
175  We need to avoid a subsequent fread() as EOF may
176  not be sticky. For details of such systems, see:
177  https://sourceware.org/bugzilla/show_bug.cgi?id=1190 */
178  if (feof (stream))
179  goto process_partial_block;
180 
181  n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
182 
183  sum += n;
184 
185  if (sum == BLOCKSIZE)
186  break;
187 
188  if (n == 0)
189  {
190  /* Check for the error flag IFF N == 0, so that we don't
191  exit the loop after a partial read due to e.g., EAGAIN
192  or EWOULDBLOCK. */
193  if (ferror (stream))
194  {
195  free (buffer);
196  return 1;
197  }
198  goto process_partial_block;
199  }
200  }
201 
202  /* Process buffer with BLOCKSIZE bytes. Note that
203  BLOCKSIZE % 64 == 0
204  */
205  md5_process_block (buffer, BLOCKSIZE, &ctx);
206  }
207 
208 process_partial_block:
209 
210  /* Process any remaining bytes. */
211  if (sum > 0)
212  md5_process_bytes (buffer, sum, &ctx);
213 
214  /* Construct result in desired memory. */
215  md5_finish_ctx (&ctx, resblock);
216  free (buffer);
217  return 0;
218 }
219 #endif
220 
221 #if ! HAVE_OPENSSL_MD5
222 /* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
223  result is always in little endian byte order, so that a byte-wise
224  output yields to the wanted ASCII representation of the message
225  digest. */
226 void *
227 md5_buffer (const char *buffer, size_t len, void *resblock)
228 {
229  struct md5_ctx ctx;
230 
231  /* Initialize the computation context. */
232  md5_init_ctx (&ctx);
233 
234  /* Process whole buffer but last len % 64 bytes. */
235  md5_process_bytes (buffer, len, &ctx);
236 
237  /* Put result in desired memory area. */
238  return md5_finish_ctx (&ctx, resblock);
239 }
240 
241 
242 void
243 md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
244 {
245  /* When we already have some bits in our internal buffer concatenate
246  both inputs first. */
247  if (ctx->buflen != 0)
248  {
249  size_t left_over = ctx->buflen;
250  size_t add = 128 - left_over > len ? len : 128 - left_over;
251 
252  memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
253  ctx->buflen += add;
254 
255  if (ctx->buflen > 64)
256  {
257  md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
258 
259  ctx->buflen &= 63;
260  /* The regions in the following copy operation cannot overlap,
261  because ctx->buflen < 64 ≤ (left_over + add) & ~63. */
262  memcpy (ctx->buffer,
263  &((char *) ctx->buffer)[(left_over + add) & ~63],
264  ctx->buflen);
265  }
266 
267  buffer = (const char *) buffer + add;
268  len -= add;
269  }
270 
271  /* Process available complete blocks. */
272  if (len >= 64)
273  {
274 #if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
275 # define UNALIGNED_P(p) ((uintptr_t) (p) % alignof (uint32_t) != 0)
276  if (UNALIGNED_P (buffer))
277  while (len > 64)
278  {
279  md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
280  buffer = (const char *) buffer + 64;
281  len -= 64;
282  }
283  else
284 #endif
285  {
286  md5_process_block (buffer, len & ~63, ctx);
287  buffer = (const char *) buffer + (len & ~63);
288  len &= 63;
289  }
290  }
291 
292  /* Move remaining bytes in internal buffer. */
293  if (len > 0)
294  {
295  size_t left_over = ctx->buflen;
296 
297  memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
298  left_over += len;
299  if (left_over >= 64)
300  {
301  md5_process_block (ctx->buffer, 64, ctx);
302  left_over -= 64;
303  /* The regions in the following copy operation cannot overlap,
304  because left_over ≤ 64. */
305  memcpy (ctx->buffer, &ctx->buffer[16], left_over);
306  }
307  ctx->buflen = left_over;
308  }
309 }
310 
311 
312 /* These are the four functions used in the four steps of the MD5 algorithm
313  and defined in the RFC 1321. The first function is a little bit optimized
314  (as found in Colin Plumbs public domain implementation). */
315 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
316 #define FF(b, c, d) (d ^ (b & (c ^ d)))
317 #define FG(b, c, d) FF (d, b, c)
318 #define FH(b, c, d) (b ^ c ^ d)
319 #define FI(b, c, d) (c ^ (b | ~d))
320 
321 /* Process LEN bytes of BUFFER, accumulating context into CTX.
322  It is assumed that LEN % 64 == 0. */
323 
324 void
325 md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
326 {
327  uint32_t correct_words[16];
328  const uint32_t *words = buffer;
329  size_t nwords = len / sizeof (uint32_t);
330  const uint32_t *endp = words + nwords;
331  uint32_t A = ctx->A;
332  uint32_t B = ctx->B;
333  uint32_t C = ctx->C;
334  uint32_t D = ctx->D;
335  uint32_t lolen = len;
336 
337  /* First increment the byte count. RFC 1321 specifies the possible
338  length of the file up to 2^64 bits. Here we only compute the
339  number of bytes. Do a double word increment. */
340  ctx->total[0] += lolen;
341  ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
342 
343  /* Process all bytes in the buffer with 64 bytes in each round of
344  the loop. */
345  while (words < endp)
346  {
347  uint32_t *cwp = correct_words;
348  uint32_t A_save = A;
349  uint32_t B_save = B;
350  uint32_t C_save = C;
351  uint32_t D_save = D;
352 
353  /* First round: using the given function, the context and a constant
354  the next context is computed. Because the algorithms processing
355  unit is a 32-bit word and it is determined to work on words in
356  little endian byte order we perhaps have to change the byte order
357  before the computation. To reduce the work for the next steps
358  we store the swapped words in the array CORRECT_WORDS. */
359 
360 #define OP(a, b, c, d, s, T) \
361  do \
362  { \
363  a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
364  ++words; \
365  CYCLIC (a, s); \
366  a += b; \
367  } \
368  while (0)
369 
370  /* It is unfortunate that C does not provide an operator for
371  cyclic rotation. Hope the C compiler is smart enough. */
372 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
373 
374  /* Before we start, one word to the strange constants.
375  They are defined in RFC 1321 as
376 
377  T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
378 
379  Here is an equivalent invocation using Perl:
380 
381  perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
382  */
383 
384  /* Round 1. */
385  OP (A, B, C, D, 7, 0xd76aa478);
386  OP (D, A, B, C, 12, 0xe8c7b756);
387  OP (C, D, A, B, 17, 0x242070db);
388  OP (B, C, D, A, 22, 0xc1bdceee);
389  OP (A, B, C, D, 7, 0xf57c0faf);
390  OP (D, A, B, C, 12, 0x4787c62a);
391  OP (C, D, A, B, 17, 0xa8304613);
392  OP (B, C, D, A, 22, 0xfd469501);
393  OP (A, B, C, D, 7, 0x698098d8);
394  OP (D, A, B, C, 12, 0x8b44f7af);
395  OP (C, D, A, B, 17, 0xffff5bb1);
396  OP (B, C, D, A, 22, 0x895cd7be);
397  OP (A, B, C, D, 7, 0x6b901122);
398  OP (D, A, B, C, 12, 0xfd987193);
399  OP (C, D, A, B, 17, 0xa679438e);
400  OP (B, C, D, A, 22, 0x49b40821);
401 
402  /* For the second to fourth round we have the possibly swapped words
403  in CORRECT_WORDS. Redefine the macro to take an additional first
404  argument specifying the function to use. */
405 #undef OP
406 #define OP(f, a, b, c, d, k, s, T) \
407  do \
408  { \
409  a += f (b, c, d) + correct_words[k] + T; \
410  CYCLIC (a, s); \
411  a += b; \
412  } \
413  while (0)
414 
415  /* Round 2. */
416  OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
417  OP (FG, D, A, B, C, 6, 9, 0xc040b340);
418  OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
419  OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
420  OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
421  OP (FG, D, A, B, C, 10, 9, 0x02441453);
422  OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
423  OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
424  OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
425  OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
426  OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
427  OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
428  OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
429  OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
430  OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
431  OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
432 
433  /* Round 3. */
434  OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
435  OP (FH, D, A, B, C, 8, 11, 0x8771f681);
436  OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
437  OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
438  OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
439  OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
440  OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
441  OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
442  OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
443  OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
444  OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
445  OP (FH, B, C, D, A, 6, 23, 0x04881d05);
446  OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
447  OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
448  OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
449  OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
450 
451  /* Round 4. */
452  OP (FI, A, B, C, D, 0, 6, 0xf4292244);
453  OP (FI, D, A, B, C, 7, 10, 0x432aff97);
454  OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
455  OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
456  OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
457  OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
458  OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
459  OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
460  OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
461  OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
462  OP (FI, C, D, A, B, 6, 15, 0xa3014314);
463  OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
464  OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
465  OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
466  OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
467  OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
468 
469  /* Add the starting values of the context. */
470  A += A_save;
471  B += B_save;
472  C += C_save;
473  D += D_save;
474  }
475 
476  /* Put checksum in context given as argument. */
477  ctx->A = A;
478  ctx->B = B;
479  ctx->C = C;
480  ctx->D = D;
481 }
482 #endif
483 
484 /*
485  * Hey Emacs!
486  * Local Variables:
487  * coding: utf-8
488  * End:
489  */
void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
Definition: md5.c:325
uint32_t D
Definition: md5.h:74
#define FG(b, c, d)
Definition: md5.c:317
void md5_init_ctx(struct md5_ctx *ctx)
Definition: md5.c:76
uint32_t A
Definition: md5.h:71
#define UNALIGNED_P(p)
#define SWAP(n)
Definition: md5.c:59
uint32_t size
Definition: internal.h:86
#define FI(b, c, d)
Definition: md5.c:319
#define OP(a, b, c, d, s, T)
#define FH(b, c, d)
Definition: md5.c:318
uint32_t buflen
Definition: md5.h:77
#define BLOCKSIZE
Definition: md5.c:62
void * md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
Definition: md5.c:113
uint32_t buffer[32]
Definition: md5.h:78
uint32_t total[2]
Definition: md5.h:76
uint32_t B
Definition: md5.h:72
void * md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
Definition: md5.c:99
#define MD5_DIGEST_SIZE
Definition: md5.h:30
void * md5_buffer(const char *buffer, size_t len, void *resblock)
Definition: md5.c:227
void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
Definition: md5.c:243
uint32_t C
Definition: md5.h:73
Definition: md5.h:69