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-2023 Free Software Foundation, Inc.
4 This file is part of the GNU C Library.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
20 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. */
26 #if __BYTE_ORDER == __BIG_ENDIAN
27 # define WORDS_BIGENDIAN 1
30 #ifdef WORDS_BIGENDIAN
32 (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
38 /* This array contains the bytes used to pad the buffer to the next
39 64-byte boundary. (RFC 1321, 3.1: Step 1) */
40 static const unsigned char fillbuf
[64] = { 0x80, 0 /* , 0, 0, ... */ };
43 /* Initialize structure containing state of computation.
44 (RFC 1321, 3.3: Step 3) */
46 __md5_init_ctx (struct md5_ctx
*ctx
)
53 ctx
->total
[0] = ctx
->total
[1] = 0;
57 /* Put result from CTX in first 16 bytes following RESBUF. The result
58 must be in little endian byte order.
60 IMPORTANT: On some systems it is required that RESBUF is correctly
61 aligned for a 32 bits value. */
63 __md5_read_ctx (const struct md5_ctx
*ctx
, void *resbuf
)
65 ((md5_uint32
*) resbuf
)[0] = SWAP (ctx
->A
);
66 ((md5_uint32
*) resbuf
)[1] = SWAP (ctx
->B
);
67 ((md5_uint32
*) resbuf
)[2] = SWAP (ctx
->C
);
68 ((md5_uint32
*) resbuf
)[3] = SWAP (ctx
->D
);
73 /* Process the remaining bytes in the internal buffer and the usual
74 prolog according to the standard and write the result to RESBUF.
76 IMPORTANT: On some systems it is required that RESBUF is correctly
77 aligned for a 32 bits value. */
79 __md5_finish_ctx (struct md5_ctx
*ctx
, void *resbuf
)
81 /* Take yet unprocessed bytes into account. */
82 md5_uint32 bytes
= ctx
->buflen
;
85 /* Now count remaining bytes. */
86 ctx
->total
[0] += bytes
;
87 if (ctx
->total
[0] < bytes
)
90 pad
= bytes
>= 56 ? 64 + 56 - bytes
: 56 - bytes
;
91 memcpy (&ctx
->buffer
[bytes
], fillbuf
, pad
);
93 /* Put the 64-bit file length in *bits* at the end of the buffer. */
94 ctx
->buffer32
[(bytes
+ pad
) / 4] = SWAP (ctx
->total
[0] << 3);
95 ctx
->buffer32
[(bytes
+ pad
+ 4) / 4] = SWAP ((ctx
->total
[1] << 3)
96 | (ctx
->total
[0] >> 29));
98 /* Process last bytes. */
99 __md5_process_block (ctx
->buffer
, bytes
+ pad
+ 8, ctx
);
101 return __md5_read_ctx (ctx
, resbuf
);
104 /* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
105 result is always in little endian byte order, so that a byte-wise
106 output yields to the wanted ASCII representation of the message
109 __md5_buffer (const char *buffer
, size_t len
, void *resblock
)
113 /* Initialize the computation context. */
114 __md5_init_ctx (&ctx
);
116 /* Process whole buffer but last len % 64 bytes. */
117 __md5_process_bytes (buffer
, len
, &ctx
);
119 /* Put result in desired memory area. */
120 return __md5_finish_ctx (&ctx
, resblock
);
125 __md5_process_bytes (const void *buffer
, size_t len
, struct md5_ctx
*ctx
)
127 /* When we already have some bits in our internal buffer concatenate
128 both inputs first. */
129 if (ctx
->buflen
!= 0)
131 size_t left_over
= ctx
->buflen
;
132 size_t add
= 128 - left_over
> len
? len
: 128 - left_over
;
134 memcpy (&ctx
->buffer
[left_over
], buffer
, add
);
137 if (ctx
->buflen
> 64)
139 __md5_process_block (ctx
->buffer
, ctx
->buflen
& ~63, ctx
);
142 /* The regions in the following copy operation cannot overlap. */
143 memcpy (ctx
->buffer
, &ctx
->buffer
[(left_over
+ add
) & ~63],
147 buffer
= (const char *) buffer
+ add
;
151 /* Process available complete blocks. */
156 __md5_process_block (memcpy (ctx
->buffer
, buffer
, 64), 64, ctx
);
157 buffer
= (const char *) buffer
+ 64;
162 /* Move remaining bytes in internal buffer. */
165 size_t left_over
= ctx
->buflen
;
167 memcpy (&ctx
->buffer
[left_over
], buffer
, len
);
171 __md5_process_block (ctx
->buffer
, 64, ctx
);
173 memcpy (ctx
->buffer
, &ctx
->buffer
[64], left_over
);
175 ctx
->buflen
= left_over
;
179 #include <md5-block.c>