2 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
19 * MD5 Message-Digest Algorithm (RFC 1321).
22 * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
25 * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
27 * This software was written by Alexander Peslyak in 2001. No copyright is
28 * claimed, and the software is hereby placed in the public domain.
29 * In case this attempt to disclaim copyright and place the software in the
30 * public domain is deemed null and void, then the software is
31 * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
32 * general public under the following terms:
34 * Redistribution and use in source and binary forms, with or without
35 * modification, are permitted.
37 * There's ABSOLUTELY NO WARRANTY, express or implied.
39 * (This is a heavily cut-down "BSD license".)
41 * This differs from Colin Plumb's older public domain implementation in that
42 * no exactly 32-bit integer data type is required (any 32-bit or wider
43 * unsigned integer data type will do), there's no compile-time endianness
44 * configuration, and the function prototypes match OpenSSL's. No code from
45 * Colin Plumb's implementation has been reused; this comment merely compares
46 * the properties of the two independent implementations.
48 * The primary goals of this implementation are portability and ease of use.
49 * It is meant to be fast, but not as fast as possible. Some known
50 * optimizations are not included to reduce source code size and avoid
51 * compile-time configuration.
55 * Copyright 2005 Colin Percival
56 * All rights reserved.
58 * Redistribution and use in source and binary forms, with or without
59 * modification, are permitted provided that the following conditions
61 * 1. Redistributions of source code must retain the above copyright
62 * notice, this list of conditions and the following disclaimer.
63 * 2. Redistributions in binary form must reproduce the above copyright
64 * notice, this list of conditions and the following disclaimer in the
65 * documentation and/or other materials provided with the distribution.
67 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
68 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
69 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
70 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
71 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
72 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
73 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
74 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
75 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
76 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
85 #include <sys/endian.h>
95 #define ARRAY_SIZE(_n) (sizeof(_n) / sizeof((_n)[0]))
99 be32enc(void *buf
, uint32_t u
)
103 p
[0] = ((uint8_t) ((u
>> 24) & 0xff));
104 p
[1] = ((uint8_t) ((u
>> 16) & 0xff));
105 p
[2] = ((uint8_t) ((u
>> 8) & 0xff));
106 p
[3] = ((uint8_t) (u
& 0xff));
110 be64enc(void *buf
, uint64_t u
)
114 be32enc(p
, ((uint32_t) (u
>> 32)));
115 be32enc(p
+ 4, ((uint32_t) (u
& 0xffffffffULL
)));
120 be16dec(const void *buf
)
122 const uint8_t *p
= buf
;
124 return (((uint16_t) p
[0]) << 8) | p
[1];
128 be32dec(const void *buf
)
130 const uint8_t *p
= buf
;
132 return (((uint32_t) be16dec(p
)) << 16) | be16dec(p
+ 2);
136 #define MD5_DIGEST_LENGTH 16
138 typedef struct MD5_CTX
{
141 unsigned char buffer
[64];
145 * The basic MD5 functions.
147 * F and G are optimized compared to their RFC 1321 definitions for
148 * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
151 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
152 #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
153 #define H(x, y, z) (((x) ^ (y)) ^ (z))
154 #define H2(x, y, z) ((x) ^ ((y) ^ (z)))
155 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
158 * The MD5 transformation for all four rounds.
160 #define STEP(f, a, b, c, d, x, t, s) \
161 (a) += f((b), (c), (d)) + (x) + (t); \
162 (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
166 * SET reads 4 input bytes in little-endian byte order and stores them
167 * in a properly aligned word in host byte order.
169 #if __BYTE_ORDER == __LITTLE_ENDIAN
171 (*(uint32_t *)&ptr[(n) * 4])
177 (uint32_t)ptr[(n) * 4] | \
178 ((uint32_t)ptr[(n) * 4 + 1] << 8) | \
179 ((uint32_t)ptr[(n) * 4 + 2] << 16) | \
180 ((uint32_t)ptr[(n) * 4 + 3] << 24))
186 * This processes one or more 64-byte data blocks, but does NOT update
187 * the bit counters. There are no alignment requirements.
189 static const void *MD5_body(MD5_CTX
*ctx
, const void *data
, unsigned long size
)
191 const unsigned char *ptr
;
193 uint32_t saved_a
, saved_b
, saved_c
, saved_d
;
194 #if __BYTE_ORDER != __LITTLE_ENDIAN
198 ptr
= (const unsigned char *)data
;
212 STEP(F
, a
, b
, c
, d
, SET(0), 0xd76aa478, 7)
213 STEP(F
, d
, a
, b
, c
, SET(1), 0xe8c7b756, 12)
214 STEP(F
, c
, d
, a
, b
, SET(2), 0x242070db, 17)
215 STEP(F
, b
, c
, d
, a
, SET(3), 0xc1bdceee, 22)
216 STEP(F
, a
, b
, c
, d
, SET(4), 0xf57c0faf, 7)
217 STEP(F
, d
, a
, b
, c
, SET(5), 0x4787c62a, 12)
218 STEP(F
, c
, d
, a
, b
, SET(6), 0xa8304613, 17)
219 STEP(F
, b
, c
, d
, a
, SET(7), 0xfd469501, 22)
220 STEP(F
, a
, b
, c
, d
, SET(8), 0x698098d8, 7)
221 STEP(F
, d
, a
, b
, c
, SET(9), 0x8b44f7af, 12)
222 STEP(F
, c
, d
, a
, b
, SET(10), 0xffff5bb1, 17)
223 STEP(F
, b
, c
, d
, a
, SET(11), 0x895cd7be, 22)
224 STEP(F
, a
, b
, c
, d
, SET(12), 0x6b901122, 7)
225 STEP(F
, d
, a
, b
, c
, SET(13), 0xfd987193, 12)
226 STEP(F
, c
, d
, a
, b
, SET(14), 0xa679438e, 17)
227 STEP(F
, b
, c
, d
, a
, SET(15), 0x49b40821, 22)
230 STEP(G
, a
, b
, c
, d
, GET(1), 0xf61e2562, 5)
231 STEP(G
, d
, a
, b
, c
, GET(6), 0xc040b340, 9)
232 STEP(G
, c
, d
, a
, b
, GET(11), 0x265e5a51, 14)
233 STEP(G
, b
, c
, d
, a
, GET(0), 0xe9b6c7aa, 20)
234 STEP(G
, a
, b
, c
, d
, GET(5), 0xd62f105d, 5)
235 STEP(G
, d
, a
, b
, c
, GET(10), 0x02441453, 9)
236 STEP(G
, c
, d
, a
, b
, GET(15), 0xd8a1e681, 14)
237 STEP(G
, b
, c
, d
, a
, GET(4), 0xe7d3fbc8, 20)
238 STEP(G
, a
, b
, c
, d
, GET(9), 0x21e1cde6, 5)
239 STEP(G
, d
, a
, b
, c
, GET(14), 0xc33707d6, 9)
240 STEP(G
, c
, d
, a
, b
, GET(3), 0xf4d50d87, 14)
241 STEP(G
, b
, c
, d
, a
, GET(8), 0x455a14ed, 20)
242 STEP(G
, a
, b
, c
, d
, GET(13), 0xa9e3e905, 5)
243 STEP(G
, d
, a
, b
, c
, GET(2), 0xfcefa3f8, 9)
244 STEP(G
, c
, d
, a
, b
, GET(7), 0x676f02d9, 14)
245 STEP(G
, b
, c
, d
, a
, GET(12), 0x8d2a4c8a, 20)
248 STEP(H
, a
, b
, c
, d
, GET(5), 0xfffa3942, 4)
249 STEP(H2
, d
, a
, b
, c
, GET(8), 0x8771f681, 11)
250 STEP(H
, c
, d
, a
, b
, GET(11), 0x6d9d6122, 16)
251 STEP(H2
, b
, c
, d
, a
, GET(14), 0xfde5380c, 23)
252 STEP(H
, a
, b
, c
, d
, GET(1), 0xa4beea44, 4)
253 STEP(H2
, d
, a
, b
, c
, GET(4), 0x4bdecfa9, 11)
254 STEP(H
, c
, d
, a
, b
, GET(7), 0xf6bb4b60, 16)
255 STEP(H2
, b
, c
, d
, a
, GET(10), 0xbebfbc70, 23)
256 STEP(H
, a
, b
, c
, d
, GET(13), 0x289b7ec6, 4)
257 STEP(H2
, d
, a
, b
, c
, GET(0), 0xeaa127fa, 11)
258 STEP(H
, c
, d
, a
, b
, GET(3), 0xd4ef3085, 16)
259 STEP(H2
, b
, c
, d
, a
, GET(6), 0x04881d05, 23)
260 STEP(H
, a
, b
, c
, d
, GET(9), 0xd9d4d039, 4)
261 STEP(H2
, d
, a
, b
, c
, GET(12), 0xe6db99e5, 11)
262 STEP(H
, c
, d
, a
, b
, GET(15), 0x1fa27cf8, 16)
263 STEP(H2
, b
, c
, d
, a
, GET(2), 0xc4ac5665, 23)
266 STEP(I
, a
, b
, c
, d
, GET(0), 0xf4292244, 6)
267 STEP(I
, d
, a
, b
, c
, GET(7), 0x432aff97, 10)
268 STEP(I
, c
, d
, a
, b
, GET(14), 0xab9423a7, 15)
269 STEP(I
, b
, c
, d
, a
, GET(5), 0xfc93a039, 21)
270 STEP(I
, a
, b
, c
, d
, GET(12), 0x655b59c3, 6)
271 STEP(I
, d
, a
, b
, c
, GET(3), 0x8f0ccc92, 10)
272 STEP(I
, c
, d
, a
, b
, GET(10), 0xffeff47d, 15)
273 STEP(I
, b
, c
, d
, a
, GET(1), 0x85845dd1, 21)
274 STEP(I
, a
, b
, c
, d
, GET(8), 0x6fa87e4f, 6)
275 STEP(I
, d
, a
, b
, c
, GET(15), 0xfe2ce6e0, 10)
276 STEP(I
, c
, d
, a
, b
, GET(6), 0xa3014314, 15)
277 STEP(I
, b
, c
, d
, a
, GET(13), 0x4e0811a1, 21)
278 STEP(I
, a
, b
, c
, d
, GET(4), 0xf7537e82, 6)
279 STEP(I
, d
, a
, b
, c
, GET(11), 0xbd3af235, 10)
280 STEP(I
, c
, d
, a
, b
, GET(2), 0x2ad7d2bb, 15)
281 STEP(I
, b
, c
, d
, a
, GET(9), 0xeb86d391, 21)
289 } while (size
-= 64);
299 void MD5_begin(MD5_CTX
*ctx
)
311 MD5_hash(const void *data
, size_t size
, MD5_CTX
*ctx
)
314 unsigned long used
, available
;
317 if ((ctx
->lo
= (saved_lo
+ size
) & 0x1fffffff) < saved_lo
)
319 ctx
->hi
+= size
>> 29;
321 used
= saved_lo
& 0x3f;
324 available
= 64 - used
;
326 if (size
< available
) {
327 memcpy(&ctx
->buffer
[used
], data
, size
);
331 memcpy(&ctx
->buffer
[used
], data
, available
);
332 data
= (const unsigned char *)data
+ available
;
334 MD5_body(ctx
, ctx
->buffer
, 64);
338 data
= MD5_body(ctx
, data
, size
& ~((size_t) 0x3f));
342 memcpy(ctx
->buffer
, data
, size
);
346 MD5_end(void *resbuf
, MD5_CTX
*ctx
)
348 unsigned char *result
= resbuf
;
349 unsigned long used
, available
;
351 used
= ctx
->lo
& 0x3f;
353 ctx
->buffer
[used
++] = 0x80;
355 available
= 64 - used
;
358 memset(&ctx
->buffer
[used
], 0, available
);
359 MD5_body(ctx
, ctx
->buffer
, 64);
364 memset(&ctx
->buffer
[used
], 0, available
- 8);
367 ctx
->buffer
[56] = ctx
->lo
;
368 ctx
->buffer
[57] = ctx
->lo
>> 8;
369 ctx
->buffer
[58] = ctx
->lo
>> 16;
370 ctx
->buffer
[59] = ctx
->lo
>> 24;
371 ctx
->buffer
[60] = ctx
->hi
;
372 ctx
->buffer
[61] = ctx
->hi
>> 8;
373 ctx
->buffer
[62] = ctx
->hi
>> 16;
374 ctx
->buffer
[63] = ctx
->hi
>> 24;
376 MD5_body(ctx
, ctx
->buffer
, 64);
379 result
[1] = ctx
->a
>> 8;
380 result
[2] = ctx
->a
>> 16;
381 result
[3] = ctx
->a
>> 24;
383 result
[5] = ctx
->b
>> 8;
384 result
[6] = ctx
->b
>> 16;
385 result
[7] = ctx
->b
>> 24;
387 result
[9] = ctx
->c
>> 8;
388 result
[10] = ctx
->c
>> 16;
389 result
[11] = ctx
->c
>> 24;
391 result
[13] = ctx
->d
>> 8;
392 result
[14] = ctx
->d
>> 16;
393 result
[15] = ctx
->d
>> 24;
395 memset(ctx
, 0, sizeof(*ctx
));
398 #define SHA256_BLOCK_LENGTH 64
399 #define SHA256_DIGEST_LENGTH 32
400 #define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
402 typedef struct SHA256Context
{
405 uint8_t buf
[SHA256_BLOCK_LENGTH
];
408 #if BYTE_ORDER == BIG_ENDIAN
410 /* Copy a vector of big-endian uint32_t into a vector of bytes */
411 #define be32enc_vect(dst, src, len) \
412 memcpy((void *)dst, (const void *)src, (size_t)len)
414 /* Copy a vector of bytes into a vector of big-endian uint32_t */
415 #define be32dec_vect(dst, src, len) \
416 memcpy((void *)dst, (const void *)src, (size_t)len)
418 #else /* BYTE_ORDER != BIG_ENDIAN */
421 * Encode a length len/4 vector of (uint32_t) into a length len vector of
422 * (unsigned char) in big-endian form. Assumes len is a multiple of 4.
425 be32enc_vect(unsigned char *dst
, const uint32_t *src
, size_t len
)
429 for (i
= 0; i
< len
/ 4; i
++)
430 be32enc(dst
+ i
* 4, src
[i
]);
434 * Decode a big-endian length len vector of (unsigned char) into a length
435 * len/4 vector of (uint32_t). Assumes len is a multiple of 4.
438 be32dec_vect(uint32_t *dst
, const unsigned char *src
, size_t len
)
442 for (i
= 0; i
< len
/ 4; i
++)
443 dst
[i
] = be32dec(src
+ i
* 4);
446 #endif /* BYTE_ORDER != BIG_ENDIAN */
449 /* Elementary functions used by SHA256 */
450 #define Ch(x, y, z) ((x & (y ^ z)) ^ z)
451 #define Maj(x, y, z) ((x & (y | z)) | (y & z))
452 #define ROTR(x, n) ((x >> n) | (x << (32 - n)))
455 * SHA256 block compression function. The 256-bit state is transformed via
456 * the 512-bit input block to produce a new state.
459 SHA256_Transform(uint32_t * state
, const unsigned char block
[64])
461 /* SHA256 round constants. */
462 static const uint32_t K
[64] = {
463 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
464 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
465 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
466 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
467 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
468 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
469 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
470 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
471 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
472 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
473 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
474 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
475 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
476 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
477 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
478 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
484 #define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
485 #define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
486 #define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3))
487 #define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10))
489 /* SHA256 round function */
490 #define RND(a, b, c, d, e, f, g, h, k) \
491 h += S1(e) + Ch(e, f, g) + k; \
493 h += S0(a) + Maj(a, b, c);
495 /* Adjusted round function for rotating state */
496 #define RNDr(S, W, i, ii) \
497 RND(S[(64 - i) % 8], S[(65 - i) % 8], \
498 S[(66 - i) % 8], S[(67 - i) % 8], \
499 S[(68 - i) % 8], S[(69 - i) % 8], \
500 S[(70 - i) % 8], S[(71 - i) % 8], \
501 W[i + ii] + K[i + ii])
503 /* Message schedule computation */
504 #define MSCH(W, ii, i) \
505 W[i + ii + 16] = s1(W[i + ii + 14]) + W[i + ii + 9] + s0(W[i + ii + 1]) + W[i + ii]
507 /* 1. Prepare the first part of the message schedule W. */
508 be32dec_vect(W
, block
, 64);
510 /* 2. Initialize working variables. */
511 memcpy(S
, state
, 32);
514 for (i
= 0; i
< 64; i
+= 16) {
560 /* 4. Mix local working variables into global state */
561 for (i
= 0; i
< 8; i
++)
565 static unsigned char PAD
[64] = {
566 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
567 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
568 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
569 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
572 /* Add padding and terminating bit-count. */
574 SHA256_Pad(SHA256_CTX
* ctx
)
578 /* Figure out how many bytes we have buffered. */
579 r
= (ctx
->count
>> 3) & 0x3f;
581 /* Pad to 56 mod 64, transforming if we finish a block en route. */
583 /* Pad to 56 mod 64. */
584 memcpy(&ctx
->buf
[r
], PAD
, 56 - r
);
586 /* Finish the current block and mix. */
587 memcpy(&ctx
->buf
[r
], PAD
, 64 - r
);
588 SHA256_Transform(ctx
->state
, ctx
->buf
);
590 /* The start of the final block is all zeroes. */
591 memset(&ctx
->buf
[0], 0, 56);
594 /* Add the terminating bit-count. */
595 be64enc(&ctx
->buf
[56], ctx
->count
);
597 /* Mix in the final block. */
598 SHA256_Transform(ctx
->state
, ctx
->buf
);
601 /* SHA-256 initialization. Begins a SHA-256 operation. */
603 SHA256_Init(SHA256_CTX
* ctx
)
606 /* Zero bits processed so far */
609 /* Magic initialization constants */
610 ctx
->state
[0] = 0x6A09E667;
611 ctx
->state
[1] = 0xBB67AE85;
612 ctx
->state
[2] = 0x3C6EF372;
613 ctx
->state
[3] = 0xA54FF53A;
614 ctx
->state
[4] = 0x510E527F;
615 ctx
->state
[5] = 0x9B05688C;
616 ctx
->state
[6] = 0x1F83D9AB;
617 ctx
->state
[7] = 0x5BE0CD19;
620 /* Add bytes into the hash */
622 SHA256_Update(SHA256_CTX
* ctx
, const void *in
, size_t len
)
626 const unsigned char *src
= in
;
628 /* Number of bytes left in the buffer from previous updates */
629 r
= (ctx
->count
>> 3) & 0x3f;
631 /* Convert the length into a number of bits */
634 /* Update number of bits */
635 ctx
->count
+= bitlen
;
637 /* Handle the case where we don't need to perform any transforms */
639 memcpy(&ctx
->buf
[r
], src
, len
);
643 /* Finish the current block */
644 memcpy(&ctx
->buf
[r
], src
, 64 - r
);
645 SHA256_Transform(ctx
->state
, ctx
->buf
);
649 /* Perform complete blocks */
651 SHA256_Transform(ctx
->state
, src
);
656 /* Copy left over data into buffer */
657 memcpy(ctx
->buf
, src
, len
);
661 * SHA-256 finalization. Pads the input data, exports the hash value,
662 * and clears the context state.
665 SHA256_Final(unsigned char digest
[static SHA256_DIGEST_LENGTH
], SHA256_CTX
*ctx
)
671 be32enc_vect(digest
, ctx
->state
, SHA256_DIGEST_LENGTH
);
673 /* Clear the context state */
674 memset(ctx
, 0, sizeof(*ctx
));
677 static void *hash_buf(FILE *f
, int *len
)
679 static char buf
[1024];
681 *len
= fread(buf
, 1, sizeof(buf
), f
);
683 return *len
> 0 ? buf
: NULL
;
686 static char *hash_string(unsigned char *buf
, int len
)
688 static char str
[SHA256_DIGEST_LENGTH
* 2 + 1];
691 if (len
* 2 + 1 > sizeof(str
))
694 for (i
= 0; i
< len
; i
++)
695 sprintf(&str
[i
* 2], "%02x", buf
[i
]);
700 static const char *md5_hash(FILE *f
)
703 unsigned char val
[MD5_DIGEST_LENGTH
];
708 while ((buf
= hash_buf(f
, &len
)) != NULL
)
709 MD5_hash(buf
, len
, &ctx
);
712 return hash_string(val
, MD5_DIGEST_LENGTH
);
715 static const char *sha256_hash(FILE *f
)
718 unsigned char val
[SHA256_DIGEST_LENGTH
];
723 while ((buf
= hash_buf(f
, &len
)) != NULL
)
724 SHA256_Update(&ctx
, buf
, len
);
725 SHA256_Final(val
, &ctx
);
727 return hash_string(val
, SHA256_DIGEST_LENGTH
);
733 const char *(*func
)(FILE *f
);
737 struct hash_type types
[] = {
738 { "md5", md5_hash
, MD5_DIGEST_LENGTH
},
739 { "sha256", sha256_hash
, SHA256_DIGEST_LENGTH
},
743 static int usage(const char *progname
)
747 fprintf(stderr
, "Usage: %s <hash type> [options] [<file>...]\n"
749 " -n Print filename(s)\n"
750 " -N Suppress trailing newline\n"
752 "Supported hash types:", progname
);
754 for (i
= 0; i
< ARRAY_SIZE(types
); i
++)
755 fprintf(stderr
, "%s %s", i
? "," : "", types
[i
].name
);
757 fprintf(stderr
, "\n");
761 static struct hash_type
*get_hash_type(const char *name
)
765 for (i
= 0; i
< ARRAY_SIZE(types
); i
++) {
766 struct hash_type
*t
= &types
[i
];
768 if (!strcmp(t
->name
, name
))
775 static int hash_file(struct hash_type
*t
, const char *filename
, bool add_filename
,
780 if (!filename
|| !strcmp(filename
, "-")) {
781 str
= t
->func(stdin
);
783 struct stat path_stat
;
784 stat(filename
, &path_stat
);
785 if (S_ISDIR(path_stat
.st_mode
)) {
786 fprintf(stderr
, "Failed to open '%s': Is a directory\n", filename
);
790 FILE *f
= fopen(filename
, "r");
793 fprintf(stderr
, "Failed to open '%s'\n", filename
);
801 fprintf(stderr
, "Failed to generate hash\n");
806 printf("%s %s%s", str
, filename
? filename
: "-",
807 no_newline
? "" : "\n");
809 printf("%s%s", str
, no_newline
? "" : "\n");
814 int main(int argc
, char **argv
)
817 const char *progname
= argv
[0];
819 bool add_filename
= false, no_newline
= false;
821 while ((ch
= getopt(argc
, argv
, "nN")) != -1) {
830 return usage(progname
);
838 return usage(progname
);
840 t
= get_hash_type(argv
[0]);
842 return usage(progname
);
845 return hash_file(t
, NULL
, add_filename
, no_newline
);
847 for (i
= 0; i
< argc
- 1; i
++) {
848 int ret
= hash_file(t
, argv
[1 + i
], add_filename
, no_newline
);