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
90 #define ARRAY_SIZE(_n) (sizeof(_n) / sizeof((_n)[0]))
93 be32enc(void *buf
, uint32_t u
)
97 p
[0] = ((uint8_t) ((u
>> 24) & 0xff));
98 p
[1] = ((uint8_t) ((u
>> 16) & 0xff));
99 p
[2] = ((uint8_t) ((u
>> 8) & 0xff));
100 p
[3] = ((uint8_t) (u
& 0xff));
104 be64enc(void *buf
, uint64_t u
)
108 be32enc(p
, ((uint32_t) (u
>> 32)));
109 be32enc(p
+ 4, ((uint32_t) (u
& 0xffffffffULL
)));
114 be16dec(const void *buf
)
116 const uint8_t *p
= buf
;
118 return (((uint16_t) p
[0]) << 8) | p
[1];
122 be32dec(const void *buf
)
124 const uint8_t *p
= buf
;
126 return (((uint32_t) be16dec(p
)) << 16) | be16dec(p
+ 2);
129 #define MD5_DIGEST_LENGTH 16
131 typedef struct MD5_CTX
{
134 unsigned char buffer
[64];
138 * The basic MD5 functions.
140 * F and G are optimized compared to their RFC 1321 definitions for
141 * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
144 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
145 #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
146 #define H(x, y, z) (((x) ^ (y)) ^ (z))
147 #define H2(x, y, z) ((x) ^ ((y) ^ (z)))
148 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
151 * The MD5 transformation for all four rounds.
153 #define STEP(f, a, b, c, d, x, t, s) \
154 (a) += f((b), (c), (d)) + (x) + (t); \
155 (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
159 * SET reads 4 input bytes in little-endian byte order and stores them
160 * in a properly aligned word in host byte order.
162 #if __BYTE_ORDER == __LITTLE_ENDIAN
164 (*(uint32_t *)&ptr[(n) * 4])
170 (uint32_t)ptr[(n) * 4] | \
171 ((uint32_t)ptr[(n) * 4 + 1] << 8) | \
172 ((uint32_t)ptr[(n) * 4 + 2] << 16) | \
173 ((uint32_t)ptr[(n) * 4 + 3] << 24))
179 * This processes one or more 64-byte data blocks, but does NOT update
180 * the bit counters. There are no alignment requirements.
182 static const void *MD5_body(MD5_CTX
*ctx
, const void *data
, unsigned long size
)
184 const unsigned char *ptr
;
186 uint32_t saved_a
, saved_b
, saved_c
, saved_d
;
187 #if __BYTE_ORDER != __LITTLE_ENDIAN
191 ptr
= (const unsigned char *)data
;
205 STEP(F
, a
, b
, c
, d
, SET(0), 0xd76aa478, 7)
206 STEP(F
, d
, a
, b
, c
, SET(1), 0xe8c7b756, 12)
207 STEP(F
, c
, d
, a
, b
, SET(2), 0x242070db, 17)
208 STEP(F
, b
, c
, d
, a
, SET(3), 0xc1bdceee, 22)
209 STEP(F
, a
, b
, c
, d
, SET(4), 0xf57c0faf, 7)
210 STEP(F
, d
, a
, b
, c
, SET(5), 0x4787c62a, 12)
211 STEP(F
, c
, d
, a
, b
, SET(6), 0xa8304613, 17)
212 STEP(F
, b
, c
, d
, a
, SET(7), 0xfd469501, 22)
213 STEP(F
, a
, b
, c
, d
, SET(8), 0x698098d8, 7)
214 STEP(F
, d
, a
, b
, c
, SET(9), 0x8b44f7af, 12)
215 STEP(F
, c
, d
, a
, b
, SET(10), 0xffff5bb1, 17)
216 STEP(F
, b
, c
, d
, a
, SET(11), 0x895cd7be, 22)
217 STEP(F
, a
, b
, c
, d
, SET(12), 0x6b901122, 7)
218 STEP(F
, d
, a
, b
, c
, SET(13), 0xfd987193, 12)
219 STEP(F
, c
, d
, a
, b
, SET(14), 0xa679438e, 17)
220 STEP(F
, b
, c
, d
, a
, SET(15), 0x49b40821, 22)
223 STEP(G
, a
, b
, c
, d
, GET(1), 0xf61e2562, 5)
224 STEP(G
, d
, a
, b
, c
, GET(6), 0xc040b340, 9)
225 STEP(G
, c
, d
, a
, b
, GET(11), 0x265e5a51, 14)
226 STEP(G
, b
, c
, d
, a
, GET(0), 0xe9b6c7aa, 20)
227 STEP(G
, a
, b
, c
, d
, GET(5), 0xd62f105d, 5)
228 STEP(G
, d
, a
, b
, c
, GET(10), 0x02441453, 9)
229 STEP(G
, c
, d
, a
, b
, GET(15), 0xd8a1e681, 14)
230 STEP(G
, b
, c
, d
, a
, GET(4), 0xe7d3fbc8, 20)
231 STEP(G
, a
, b
, c
, d
, GET(9), 0x21e1cde6, 5)
232 STEP(G
, d
, a
, b
, c
, GET(14), 0xc33707d6, 9)
233 STEP(G
, c
, d
, a
, b
, GET(3), 0xf4d50d87, 14)
234 STEP(G
, b
, c
, d
, a
, GET(8), 0x455a14ed, 20)
235 STEP(G
, a
, b
, c
, d
, GET(13), 0xa9e3e905, 5)
236 STEP(G
, d
, a
, b
, c
, GET(2), 0xfcefa3f8, 9)
237 STEP(G
, c
, d
, a
, b
, GET(7), 0x676f02d9, 14)
238 STEP(G
, b
, c
, d
, a
, GET(12), 0x8d2a4c8a, 20)
241 STEP(H
, a
, b
, c
, d
, GET(5), 0xfffa3942, 4)
242 STEP(H2
, d
, a
, b
, c
, GET(8), 0x8771f681, 11)
243 STEP(H
, c
, d
, a
, b
, GET(11), 0x6d9d6122, 16)
244 STEP(H2
, b
, c
, d
, a
, GET(14), 0xfde5380c, 23)
245 STEP(H
, a
, b
, c
, d
, GET(1), 0xa4beea44, 4)
246 STEP(H2
, d
, a
, b
, c
, GET(4), 0x4bdecfa9, 11)
247 STEP(H
, c
, d
, a
, b
, GET(7), 0xf6bb4b60, 16)
248 STEP(H2
, b
, c
, d
, a
, GET(10), 0xbebfbc70, 23)
249 STEP(H
, a
, b
, c
, d
, GET(13), 0x289b7ec6, 4)
250 STEP(H2
, d
, a
, b
, c
, GET(0), 0xeaa127fa, 11)
251 STEP(H
, c
, d
, a
, b
, GET(3), 0xd4ef3085, 16)
252 STEP(H2
, b
, c
, d
, a
, GET(6), 0x04881d05, 23)
253 STEP(H
, a
, b
, c
, d
, GET(9), 0xd9d4d039, 4)
254 STEP(H2
, d
, a
, b
, c
, GET(12), 0xe6db99e5, 11)
255 STEP(H
, c
, d
, a
, b
, GET(15), 0x1fa27cf8, 16)
256 STEP(H2
, b
, c
, d
, a
, GET(2), 0xc4ac5665, 23)
259 STEP(I
, a
, b
, c
, d
, GET(0), 0xf4292244, 6)
260 STEP(I
, d
, a
, b
, c
, GET(7), 0x432aff97, 10)
261 STEP(I
, c
, d
, a
, b
, GET(14), 0xab9423a7, 15)
262 STEP(I
, b
, c
, d
, a
, GET(5), 0xfc93a039, 21)
263 STEP(I
, a
, b
, c
, d
, GET(12), 0x655b59c3, 6)
264 STEP(I
, d
, a
, b
, c
, GET(3), 0x8f0ccc92, 10)
265 STEP(I
, c
, d
, a
, b
, GET(10), 0xffeff47d, 15)
266 STEP(I
, b
, c
, d
, a
, GET(1), 0x85845dd1, 21)
267 STEP(I
, a
, b
, c
, d
, GET(8), 0x6fa87e4f, 6)
268 STEP(I
, d
, a
, b
, c
, GET(15), 0xfe2ce6e0, 10)
269 STEP(I
, c
, d
, a
, b
, GET(6), 0xa3014314, 15)
270 STEP(I
, b
, c
, d
, a
, GET(13), 0x4e0811a1, 21)
271 STEP(I
, a
, b
, c
, d
, GET(4), 0xf7537e82, 6)
272 STEP(I
, d
, a
, b
, c
, GET(11), 0xbd3af235, 10)
273 STEP(I
, c
, d
, a
, b
, GET(2), 0x2ad7d2bb, 15)
274 STEP(I
, b
, c
, d
, a
, GET(9), 0xeb86d391, 21)
282 } while (size
-= 64);
292 void MD5_begin(MD5_CTX
*ctx
)
304 MD5_hash(const void *data
, size_t size
, MD5_CTX
*ctx
)
307 unsigned long used
, available
;
310 if ((ctx
->lo
= (saved_lo
+ size
) & 0x1fffffff) < saved_lo
)
312 ctx
->hi
+= size
>> 29;
314 used
= saved_lo
& 0x3f;
317 available
= 64 - used
;
319 if (size
< available
) {
320 memcpy(&ctx
->buffer
[used
], data
, size
);
324 memcpy(&ctx
->buffer
[used
], data
, available
);
325 data
= (const unsigned char *)data
+ available
;
327 MD5_body(ctx
, ctx
->buffer
, 64);
331 data
= MD5_body(ctx
, data
, size
& ~((size_t) 0x3f));
335 memcpy(ctx
->buffer
, data
, size
);
339 MD5_end(void *resbuf
, MD5_CTX
*ctx
)
341 unsigned char *result
= resbuf
;
342 unsigned long used
, available
;
344 used
= ctx
->lo
& 0x3f;
346 ctx
->buffer
[used
++] = 0x80;
348 available
= 64 - used
;
351 memset(&ctx
->buffer
[used
], 0, available
);
352 MD5_body(ctx
, ctx
->buffer
, 64);
357 memset(&ctx
->buffer
[used
], 0, available
- 8);
360 ctx
->buffer
[56] = ctx
->lo
;
361 ctx
->buffer
[57] = ctx
->lo
>> 8;
362 ctx
->buffer
[58] = ctx
->lo
>> 16;
363 ctx
->buffer
[59] = ctx
->lo
>> 24;
364 ctx
->buffer
[60] = ctx
->hi
;
365 ctx
->buffer
[61] = ctx
->hi
>> 8;
366 ctx
->buffer
[62] = ctx
->hi
>> 16;
367 ctx
->buffer
[63] = ctx
->hi
>> 24;
369 MD5_body(ctx
, ctx
->buffer
, 64);
372 result
[1] = ctx
->a
>> 8;
373 result
[2] = ctx
->a
>> 16;
374 result
[3] = ctx
->a
>> 24;
376 result
[5] = ctx
->b
>> 8;
377 result
[6] = ctx
->b
>> 16;
378 result
[7] = ctx
->b
>> 24;
380 result
[9] = ctx
->c
>> 8;
381 result
[10] = ctx
->c
>> 16;
382 result
[11] = ctx
->c
>> 24;
384 result
[13] = ctx
->d
>> 8;
385 result
[14] = ctx
->d
>> 16;
386 result
[15] = ctx
->d
>> 24;
388 memset(ctx
, 0, sizeof(*ctx
));
391 #define SHA256_BLOCK_LENGTH 64
392 #define SHA256_DIGEST_LENGTH 32
393 #define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
395 typedef struct SHA256Context
{
398 uint8_t buf
[SHA256_BLOCK_LENGTH
];
401 #if BYTE_ORDER == BIG_ENDIAN
403 /* Copy a vector of big-endian uint32_t into a vector of bytes */
404 #define be32enc_vect(dst, src, len) \
405 memcpy((void *)dst, (const void *)src, (size_t)len)
407 /* Copy a vector of bytes into a vector of big-endian uint32_t */
408 #define be32dec_vect(dst, src, len) \
409 memcpy((void *)dst, (const void *)src, (size_t)len)
411 #else /* BYTE_ORDER != BIG_ENDIAN */
414 * Encode a length len/4 vector of (uint32_t) into a length len vector of
415 * (unsigned char) in big-endian form. Assumes len is a multiple of 4.
418 be32enc_vect(unsigned char *dst
, const uint32_t *src
, size_t len
)
422 for (i
= 0; i
< len
/ 4; i
++)
423 be32enc(dst
+ i
* 4, src
[i
]);
427 * Decode a big-endian length len vector of (unsigned char) into a length
428 * len/4 vector of (uint32_t). Assumes len is a multiple of 4.
431 be32dec_vect(uint32_t *dst
, const unsigned char *src
, size_t len
)
435 for (i
= 0; i
< len
/ 4; i
++)
436 dst
[i
] = be32dec(src
+ i
* 4);
439 #endif /* BYTE_ORDER != BIG_ENDIAN */
442 /* Elementary functions used by SHA256 */
443 #define Ch(x, y, z) ((x & (y ^ z)) ^ z)
444 #define Maj(x, y, z) ((x & (y | z)) | (y & z))
445 #define ROTR(x, n) ((x >> n) | (x << (32 - n)))
448 * SHA256 block compression function. The 256-bit state is transformed via
449 * the 512-bit input block to produce a new state.
452 SHA256_Transform(uint32_t * state
, const unsigned char block
[64])
454 /* SHA256 round constants. */
455 static const uint32_t K
[64] = {
456 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
457 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
458 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
459 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
460 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
461 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
462 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
463 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
464 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
465 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
466 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
467 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
468 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
469 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
470 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
471 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
477 #define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
478 #define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
479 #define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3))
480 #define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10))
482 /* SHA256 round function */
483 #define RND(a, b, c, d, e, f, g, h, k) \
484 h += S1(e) + Ch(e, f, g) + k; \
486 h += S0(a) + Maj(a, b, c);
488 /* Adjusted round function for rotating state */
489 #define RNDr(S, W, i, ii) \
490 RND(S[(64 - i) % 8], S[(65 - i) % 8], \
491 S[(66 - i) % 8], S[(67 - i) % 8], \
492 S[(68 - i) % 8], S[(69 - i) % 8], \
493 S[(70 - i) % 8], S[(71 - i) % 8], \
494 W[i + ii] + K[i + ii])
496 /* Message schedule computation */
497 #define MSCH(W, ii, i) \
498 W[i + ii + 16] = s1(W[i + ii + 14]) + W[i + ii + 9] + s0(W[i + ii + 1]) + W[i + ii]
500 /* 1. Prepare the first part of the message schedule W. */
501 be32dec_vect(W
, block
, 64);
503 /* 2. Initialize working variables. */
504 memcpy(S
, state
, 32);
507 for (i
= 0; i
< 64; i
+= 16) {
553 /* 4. Mix local working variables into global state */
554 for (i
= 0; i
< 8; i
++)
558 static unsigned char PAD
[64] = {
559 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
560 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
561 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
562 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
565 /* Add padding and terminating bit-count. */
567 SHA256_Pad(SHA256_CTX
* ctx
)
571 /* Figure out how many bytes we have buffered. */
572 r
= (ctx
->count
>> 3) & 0x3f;
574 /* Pad to 56 mod 64, transforming if we finish a block en route. */
576 /* Pad to 56 mod 64. */
577 memcpy(&ctx
->buf
[r
], PAD
, 56 - r
);
579 /* Finish the current block and mix. */
580 memcpy(&ctx
->buf
[r
], PAD
, 64 - r
);
581 SHA256_Transform(ctx
->state
, ctx
->buf
);
583 /* The start of the final block is all zeroes. */
584 memset(&ctx
->buf
[0], 0, 56);
587 /* Add the terminating bit-count. */
588 be64enc(&ctx
->buf
[56], ctx
->count
);
590 /* Mix in the final block. */
591 SHA256_Transform(ctx
->state
, ctx
->buf
);
594 /* SHA-256 initialization. Begins a SHA-256 operation. */
596 SHA256_Init(SHA256_CTX
* ctx
)
599 /* Zero bits processed so far */
602 /* Magic initialization constants */
603 ctx
->state
[0] = 0x6A09E667;
604 ctx
->state
[1] = 0xBB67AE85;
605 ctx
->state
[2] = 0x3C6EF372;
606 ctx
->state
[3] = 0xA54FF53A;
607 ctx
->state
[4] = 0x510E527F;
608 ctx
->state
[5] = 0x9B05688C;
609 ctx
->state
[6] = 0x1F83D9AB;
610 ctx
->state
[7] = 0x5BE0CD19;
613 /* Add bytes into the hash */
615 SHA256_Update(SHA256_CTX
* ctx
, const void *in
, size_t len
)
619 const unsigned char *src
= in
;
621 /* Number of bytes left in the buffer from previous updates */
622 r
= (ctx
->count
>> 3) & 0x3f;
624 /* Convert the length into a number of bits */
627 /* Update number of bits */
628 ctx
->count
+= bitlen
;
630 /* Handle the case where we don't need to perform any transforms */
632 memcpy(&ctx
->buf
[r
], src
, len
);
636 /* Finish the current block */
637 memcpy(&ctx
->buf
[r
], src
, 64 - r
);
638 SHA256_Transform(ctx
->state
, ctx
->buf
);
642 /* Perform complete blocks */
644 SHA256_Transform(ctx
->state
, src
);
649 /* Copy left over data into buffer */
650 memcpy(ctx
->buf
, src
, len
);
654 * SHA-256 finalization. Pads the input data, exports the hash value,
655 * and clears the context state.
658 SHA256_Final(unsigned char digest
[static SHA256_DIGEST_LENGTH
], SHA256_CTX
*ctx
)
664 be32enc_vect(digest
, ctx
->state
, SHA256_DIGEST_LENGTH
);
666 /* Clear the context state */
667 memset(ctx
, 0, sizeof(*ctx
));
670 static void *hash_buf(FILE *f
, int *len
)
672 static char buf
[1024];
674 *len
= fread(buf
, 1, sizeof(buf
), f
);
676 return *len
> 0 ? buf
: NULL
;
679 static char *hash_string(unsigned char *buf
, int len
)
681 static char str
[SHA256_DIGEST_LENGTH
* 2 + 1];
684 if (len
* 2 + 1 > sizeof(str
))
687 for (i
= 0; i
< len
; i
++)
688 sprintf(&str
[i
* 2], "%02x", buf
[i
]);
693 static const char *md5_hash(FILE *f
)
696 unsigned char val
[MD5_DIGEST_LENGTH
];
701 while ((buf
= hash_buf(f
, &len
)) != NULL
)
702 MD5_hash(buf
, len
, &ctx
);
705 return hash_string(val
, MD5_DIGEST_LENGTH
);
708 static const char *sha256_hash(FILE *f
)
711 unsigned char val
[SHA256_DIGEST_LENGTH
];
716 while ((buf
= hash_buf(f
, &len
)) != NULL
)
717 SHA256_Update(&ctx
, buf
, len
);
718 SHA256_Final(val
, &ctx
);
720 return hash_string(val
, SHA256_DIGEST_LENGTH
);
726 const char *(*func
)(FILE *f
);
730 struct hash_type types
[] = {
731 { "md5", md5_hash
, MD5_DIGEST_LENGTH
},
732 { "sha256", sha256_hash
, SHA256_DIGEST_LENGTH
},
736 static int usage(const char *progname
)
740 fprintf(stderr
, "Usage: %s <hash type> [options] [<file>...]\n"
742 " -n Print filename(s)\n"
744 "Supported hash types:", progname
);
746 for (i
= 0; i
< ARRAY_SIZE(types
); i
++)
747 fprintf(stderr
, "%s %s", i
? "," : "", types
[i
].name
);
749 fprintf(stderr
, "\n");
753 static struct hash_type
*get_hash_type(const char *name
)
757 for (i
= 0; i
< ARRAY_SIZE(types
); i
++) {
758 struct hash_type
*t
= &types
[i
];
760 if (!strcmp(t
->name
, name
))
767 static int hash_file(struct hash_type
*t
, const char *filename
, bool add_filename
)
771 if (!filename
|| !strcmp(filename
, "-")) {
772 str
= t
->func(stdin
);
774 struct stat path_stat
;
775 stat(filename
, &path_stat
);
776 if (S_ISDIR(path_stat
.st_mode
)) {
777 fprintf(stderr
, "Failed to open '%s': Is a directory\n", filename
);
781 FILE *f
= fopen(filename
, "r");
784 fprintf(stderr
, "Failed to open '%s'\n", filename
);
792 fprintf(stderr
, "Failed to generate hash\n");
797 printf("%s %s\n", str
, filename
? filename
: "-");
804 int main(int argc
, char **argv
)
807 const char *progname
= argv
[0];
809 bool add_filename
= false;
811 while ((ch
= getopt(argc
, argv
, "n")) != -1) {
817 return usage(progname
);
825 return usage(progname
);
827 t
= get_hash_type(argv
[0]);
829 return usage(progname
);
832 return hash_file(t
, NULL
, add_filename
);
834 for (i
= 0; i
< argc
- 1; i
++) {
835 int ret
= hash_file(t
, argv
[1 + i
], add_filename
);