2 * Based on shasum from http://www.netsw.org/crypto/hash/
3 * Majorly hacked up to use Dr Brian Gladman's sha1 code
5 * Copyright (C) 2003 Glenn L. McGrath
6 * Copyright (C) 2003 Erik Andersen
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
38 ---------------------------------------------------------------------------
39 Begin Dr. Gladman's sha1 code
40 ---------------------------------------------------------------------------
44 ---------------------------------------------------------------------------
45 Copyright (c) 2002, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
50 The free distribution and use of this software in both source and binary
51 form is allowed (with or without changes) provided that:
53 1. distributions of this source code include the above copyright
54 notice, this list of conditions and the following disclaimer;
56 2. distributions in binary form include the above copyright
57 notice, this list of conditions and the following disclaimer
58 in the documentation and/or other associated materials;
60 3. the copyright holder's name is not used to endorse products
61 built using this software without specific written permission.
63 ALTERNATIVELY, provided that this notice is retained in full, this product
64 may be distributed under the terms of the GNU General Public License (GPL),
65 in which case the provisions of the GPL apply INSTEAD OF those given above.
69 This software is provided 'as is' with no explicit or implied warranties
70 in respect of its properties, including, but not limited to, correctness
71 and/or fitness for purpose.
72 ---------------------------------------------------------------------------
73 Issue Date: 10/11/2002
75 This is a byte oriented version of SHA1 that operates on arrays of bytes
76 stored in memory. It runs at 22 cycles per byte on a Pentium P4 processor
79 # define SHA1_BLOCK_SIZE 64
80 # define SHA1_DIGEST_SIZE 20
81 # define SHA1_HASH_SIZE SHA1_DIGEST_SIZE
85 # define rotl32(x,n) (((x) << n) | ((x) >> (32 - n)))
87 # if __BYTE_ORDER == __BIG_ENDIAN
88 # define swap_b32(x) (x)
89 # elif defined(bswap_32)
90 # define swap_b32(x) bswap_32(x)
92 # define swap_b32(x) ((rotl32((x), 8) & 0x00ff00ff) | (rotl32((x), 24) & 0xff00ff00))
93 # endif /* __BYTE_ORDER */
95 # define SHA1_MASK (SHA1_BLOCK_SIZE - 1)
97 /* reverse byte order in 32-bit words */
98 # define ch(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
99 # define parity(x,y,z) ((x) ^ (y) ^ (z))
100 # define maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
102 /* A normal version as set out in the FIPS. This version uses */
103 /* partial loop unrolling and is optimised for the Pentium 4 */
105 t = a; a = rotl32(a,5) + f(b,c,d) + e + k + w[i]; \
106 e = d; d = c; c = rotl32(b, 30); b = t
108 /* type to hold the SHA1 context */
109 typedef struct sha1_ctx_s {
115 static void sha1_compile(sha1_ctx_t *ctx)
117 uint32_t w[80], i, a, b, c, d, e, t;
119 /* note that words are compiled from the buffer into 32-bit */
120 /* words in big-endian order so an order reversal is needed */
121 /* here on little endian machines */
122 for (i = 0; i < SHA1_BLOCK_SIZE / 4; ++i)
123 w[i] = swap_b32(ctx->wbuf[i]);
125 for (i = SHA1_BLOCK_SIZE / 4; i < 80; ++i)
126 w[i] = rotl32(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
134 for (i = 0; i < 20; ++i) {
138 for (i = 20; i < 40; ++i) {
139 rnd(parity, 0x6ed9eba1);
142 for (i = 40; i < 60; ++i) {
143 rnd(maj, 0x8f1bbcdc);
146 for (i = 60; i < 80; ++i) {
147 rnd(parity, 0xca62c1d6);
157 static void sha1_begin(sha1_ctx_t *ctx)
159 ctx->count[0] = ctx->count[1] = 0;
160 ctx->hash[0] = 0x67452301;
161 ctx->hash[1] = 0xefcdab89;
162 ctx->hash[2] = 0x98badcfe;
163 ctx->hash[3] = 0x10325476;
164 ctx->hash[4] = 0xc3d2e1f0;
167 /* SHA1 hash data in an array of bytes into hash buffer and call the */
168 /* hash_compile function as required. */
169 static void sha1_hash(const void *data, size_t len, void *ctx_v)
171 sha1_ctx_t *ctx = (sha1_ctx_t *) ctx_v;
172 uint32_t pos = (uint32_t) (ctx->count[0] & SHA1_MASK);
173 uint32_t freeb = SHA1_BLOCK_SIZE - pos;
174 const unsigned char *sp = data;
176 if ((ctx->count[0] += len) < len)
179 while (len >= freeb) { /* tranfer whole blocks while possible */
180 memcpy(((unsigned char *) ctx->wbuf) + pos, sp, freeb);
183 freeb = SHA1_BLOCK_SIZE;
188 memcpy(((unsigned char *) ctx->wbuf) + pos, sp, len);
191 /* SHA1 Final padding and digest calculation */
192 # if __BYTE_ORDER == __LITTLE_ENDIAN
193 static uint32_t mask[4] = { 0x00000000, 0x000000ff, 0x0000ffff, 0x00ffffff };
194 static uint32_t bits[4] = { 0x00000080, 0x00008000, 0x00800000, 0x80000000 };
196 static uint32_t mask[4] = { 0x00000000, 0xff000000, 0xffff0000, 0xffffff00 };
197 static uint32_t bits[4] = { 0x80000000, 0x00800000, 0x00008000, 0x00000080 };
198 # endif /* __BYTE_ORDER */
200 void sha1_end(unsigned char hval[], sha1_ctx_t *ctx)
202 uint32_t i, cnt = (uint32_t) (ctx->count[0] & SHA1_MASK);
204 /* mask out the rest of any partial 32-bit word and then set */
205 /* the next byte to 0x80. On big-endian machines any bytes in */
206 /* the buffer will be at the top end of 32 bit words, on little */
207 /* endian machines they will be at the bottom. Hence the AND */
208 /* and OR masks above are reversed for little endian systems */
209 ctx->wbuf[cnt >> 2] =
210 (ctx->wbuf[cnt >> 2] & mask[cnt & 3]) | bits[cnt & 3];
212 /* we need 9 or more empty positions, one for the padding byte */
213 /* (above) and eight for the length count. If there is not */
214 /* enough space pad and empty the buffer */
215 if (cnt > SHA1_BLOCK_SIZE - 9) {
220 } else /* compute a word index for the empty buffer positions */
221 cnt = (cnt >> 2) + 1;
223 while (cnt < 14) /* and zero pad all but last two positions */
224 ctx->wbuf[cnt++] = 0;
226 /* assemble the eight byte counter in the buffer in big-endian */
229 ctx->wbuf[14] = swap_b32((ctx->count[1] << 3) | (ctx->count[0] >> 29));
230 ctx->wbuf[15] = swap_b32(ctx->count[0] << 3);
234 /* extract the hash value as bytes in case the hash buffer is */
235 /* misaligned for 32-bit words */
237 for (i = 0; i < SHA1_DIGEST_SIZE; ++i)
238 hval[i] = (unsigned char) (ctx->hash[i >> 2] >> 8 * (~i & 3));
242 ---------------------------------------------------------------------------
243 End of Dr. Gladman's sha1 code
244 ---------------------------------------------------------------------------
246 #endif /* CONFIG_SHA1 */
254 * md5sum.c - Compute MD5 checksum of files or strings according to the
255 * definition of MD5 in RFC 1321 from April 1992.
257 * Copyright (C) 1995-1999 Free Software Foundation, Inc.
258 * Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
261 * June 29, 2001 Manuel Novoa III
263 * Added MD5SUM_SIZE_VS_SPEED configuration option.
265 * Current valid values, with data from my system for comparison, are:
266 * (using uClibc and running on linux-2.4.4.tar.bz2)
267 * user times (sec) text size (386)
268 * 0 (fastest) 1.1 6144
271 * 3 (smallest) 5.1 4912
274 # define MD5SUM_SIZE_VS_SPEED 2
276 /* Handle endian-ness */
277 # if __BYTE_ORDER == __LITTLE_ENDIAN
280 # define SWAP(n) ((n << 24) | ((n&65280)<<8) | ((n&16711680)>>8) | (n>>24))
283 # if MD5SUM_SIZE_VS_SPEED == 0
284 /* This array contains the bytes used to pad the buffer to the next
285 64-byte boundary. (RFC 1321, 3.1: Step 1) */
286 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
287 # endif /* MD5SUM_SIZE_VS_SPEED == 0 */
289 typedef u_int32_t md5_uint32;
291 /* Structure to save state of computation between the single steps. */
292 typedef struct md5_ctx_s {
303 /* Initialize structure containing state of computation.
304 * (RFC 1321, 3.3: Step 3)
306 static void md5_begin(md5_ctx_t *ctx)
313 ctx->total[0] = ctx->total[1] = 0;
317 /* These are the four functions used in the four steps of the MD5 algorithm
318 * and defined in the RFC 1321. The first function is a little bit optimized
319 * (as found in Colin Plumbs public domain implementation).
320 * #define FF(b, c, d) ((b & c) | (~b & d))
322 # define FF(b, c, d) (d ^ (b & (c ^ d)))
323 # define FG(b, c, d) FF (d, b, c)
324 # define FH(b, c, d) (b ^ c ^ d)
325 # define FI(b, c, d) (c ^ (b | ~d))
327 /* Starting with the result of former calls of this function (or the
328 * initialization function update the context for the next LEN bytes
329 * starting at BUFFER.
330 * It is necessary that LEN is a multiple of 64!!!
332 static void md5_hash_block(const void *buffer, size_t len, md5_ctx_t *ctx)
334 md5_uint32 correct_words[16];
335 const md5_uint32 *words = buffer;
336 size_t nwords = len / sizeof(md5_uint32);
337 const md5_uint32 *endp = words + nwords;
339 # if MD5SUM_SIZE_VS_SPEED > 0
340 static const md5_uint32 C_array[] = {
342 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
343 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
344 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
345 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
347 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
348 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
349 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
350 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
352 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
353 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
354 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
355 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
357 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
358 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
359 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
360 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
363 static const char P_array[] = {
364 # if MD5SUM_SIZE_VS_SPEED > 1
365 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
366 # endif /* MD5SUM_SIZE_VS_SPEED > 1 */
367 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
368 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
369 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */
372 # if MD5SUM_SIZE_VS_SPEED > 1
373 static const char S_array[] = {
379 # endif /* MD5SUM_SIZE_VS_SPEED > 1 */
382 md5_uint32 A = ctx->A;
383 md5_uint32 B = ctx->B;
384 md5_uint32 C = ctx->C;
385 md5_uint32 D = ctx->D;
387 /* First increment the byte count. RFC 1321 specifies the possible
388 length of the file up to 2^64 bits. Here we only compute the
389 number of bytes. Do a double word increment. */
390 ctx->total[0] += len;
391 if (ctx->total[0] < len)
394 /* Process all bytes in the buffer with 64 bytes in each round of
396 while (words < endp) {
397 md5_uint32 *cwp = correct_words;
398 md5_uint32 A_save = A;
399 md5_uint32 B_save = B;
400 md5_uint32 C_save = C;
401 md5_uint32 D_save = D;
403 # if MD5SUM_SIZE_VS_SPEED > 1
404 # define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
406 const md5_uint32 *pc;
412 for (i = 0; i < 16; i++) {
413 cwp[i] = SWAP(words[i]);
417 # if MD5SUM_SIZE_VS_SPEED > 2
422 for (i = 0; i < 64; i++) {
439 temp += cwp[(int) (*pp++)] + *pc++;
440 CYCLIC(temp, ps[i & 3]);
452 for (i = 0; i < 16; i++) {
453 temp = A + FF(B, C, D) + cwp[(int) (*pp++)] + *pc++;
454 CYCLIC(temp, ps[i & 3]);
463 for (i = 0; i < 16; i++) {
464 temp = A + FG(B, C, D) + cwp[(int) (*pp++)] + *pc++;
465 CYCLIC(temp, ps[i & 3]);
473 for (i = 0; i < 16; i++) {
474 temp = A + FH(B, C, D) + cwp[(int) (*pp++)] + *pc++;
475 CYCLIC(temp, ps[i & 3]);
483 for (i = 0; i < 16; i++) {
484 temp = A + FI(B, C, D) + cwp[(int) (*pp++)] + *pc++;
485 CYCLIC(temp, ps[i & 3]);
493 # endif /* MD5SUM_SIZE_VS_SPEED > 2 */
495 /* First round: using the given function, the context and a constant
496 the next context is computed. Because the algorithms processing
497 unit is a 32-bit word and it is determined to work on words in
498 little endian byte order we perhaps have to change the byte order
499 before the computation. To reduce the work for the next steps
500 we store the swapped words in the array CORRECT_WORDS. */
502 # define OP(a, b, c, d, s, T) \
505 a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
512 /* It is unfortunate that C does not provide an operator for
513 cyclic rotation. Hope the C compiler is smart enough. */
514 /* gcc 2.95.4 seems to be --aaronl */
515 # define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
517 /* Before we start, one word to the strange constants.
518 They are defined in RFC 1321 as
520 T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
523 # if MD5SUM_SIZE_VS_SPEED == 1
524 const md5_uint32 *pc;
527 # endif /* MD5SUM_SIZE_VS_SPEED */
530 # if MD5SUM_SIZE_VS_SPEED == 1
532 for (i = 0; i < 4; i++) {
533 OP(A, B, C, D, 7, *pc++);
534 OP(D, A, B, C, 12, *pc++);
535 OP(C, D, A, B, 17, *pc++);
536 OP(B, C, D, A, 22, *pc++);
539 OP(A, B, C, D, 7, 0xd76aa478);
540 OP(D, A, B, C, 12, 0xe8c7b756);
541 OP(C, D, A, B, 17, 0x242070db);
542 OP(B, C, D, A, 22, 0xc1bdceee);
543 OP(A, B, C, D, 7, 0xf57c0faf);
544 OP(D, A, B, C, 12, 0x4787c62a);
545 OP(C, D, A, B, 17, 0xa8304613);
546 OP(B, C, D, A, 22, 0xfd469501);
547 OP(A, B, C, D, 7, 0x698098d8);
548 OP(D, A, B, C, 12, 0x8b44f7af);
549 OP(C, D, A, B, 17, 0xffff5bb1);
550 OP(B, C, D, A, 22, 0x895cd7be);
551 OP(A, B, C, D, 7, 0x6b901122);
552 OP(D, A, B, C, 12, 0xfd987193);
553 OP(C, D, A, B, 17, 0xa679438e);
554 OP(B, C, D, A, 22, 0x49b40821);
555 # endif /* MD5SUM_SIZE_VS_SPEED == 1 */
557 /* For the second to fourth round we have the possibly swapped words
558 in CORRECT_WORDS. Redefine the macro to take an additional first
559 argument specifying the function to use. */
561 # define OP(f, a, b, c, d, k, s, T) \
564 a += f (b, c, d) + correct_words[k] + T; \
571 # if MD5SUM_SIZE_VS_SPEED == 1
573 for (i = 0; i < 4; i++) {
574 OP(FG, A, B, C, D, (int) (*pp++), 5, *pc++);
575 OP(FG, D, A, B, C, (int) (*pp++), 9, *pc++);
576 OP(FG, C, D, A, B, (int) (*pp++), 14, *pc++);
577 OP(FG, B, C, D, A, (int) (*pp++), 20, *pc++);
580 OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
581 OP(FG, D, A, B, C, 6, 9, 0xc040b340);
582 OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
583 OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
584 OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
585 OP(FG, D, A, B, C, 10, 9, 0x02441453);
586 OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
587 OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
588 OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
589 OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
590 OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
591 OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
592 OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
593 OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
594 OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
595 OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
596 # endif /* MD5SUM_SIZE_VS_SPEED == 1 */
599 # if MD5SUM_SIZE_VS_SPEED == 1
600 for (i = 0; i < 4; i++) {
601 OP(FH, A, B, C, D, (int) (*pp++), 4, *pc++);
602 OP(FH, D, A, B, C, (int) (*pp++), 11, *pc++);
603 OP(FH, C, D, A, B, (int) (*pp++), 16, *pc++);
604 OP(FH, B, C, D, A, (int) (*pp++), 23, *pc++);
607 OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
608 OP(FH, D, A, B, C, 8, 11, 0x8771f681);
609 OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
610 OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
611 OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
612 OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
613 OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
614 OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
615 OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
616 OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
617 OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
618 OP(FH, B, C, D, A, 6, 23, 0x04881d05);
619 OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
620 OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
621 OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
622 OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
623 # endif /* MD5SUM_SIZE_VS_SPEED == 1 */
626 # if MD5SUM_SIZE_VS_SPEED == 1
627 for (i = 0; i < 4; i++) {
628 OP(FI, A, B, C, D, (int) (*pp++), 6, *pc++);
629 OP(FI, D, A, B, C, (int) (*pp++), 10, *pc++);
630 OP(FI, C, D, A, B, (int) (*pp++), 15, *pc++);
631 OP(FI, B, C, D, A, (int) (*pp++), 21, *pc++);
634 OP(FI, A, B, C, D, 0, 6, 0xf4292244);
635 OP(FI, D, A, B, C, 7, 10, 0x432aff97);
636 OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
637 OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
638 OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
639 OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
640 OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
641 OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
642 OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
643 OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
644 OP(FI, C, D, A, B, 6, 15, 0xa3014314);
645 OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
646 OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
647 OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
648 OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
649 OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
650 # endif /* MD5SUM_SIZE_VS_SPEED == 1 */
651 # endif /* MD5SUM_SIZE_VS_SPEED > 1 */
653 /* Add the starting values of the context. */
660 /* Put checksum in context given as argument. */
667 /* Starting with the result of former calls of this function (or the
668 * initialization function update the context for the next LEN bytes
669 * starting at BUFFER.
670 * It is NOT required that LEN is a multiple of 64.
673 static void md5_hash_bytes(const void *buffer, size_t len, md5_ctx_t *ctx)
675 /* When we already have some bits in our internal buffer concatenate
676 both inputs first. */
677 if (ctx->buflen != 0) {
678 size_t left_over = ctx->buflen;
679 size_t add = 128 - left_over > len ? len : 128 - left_over;
681 memcpy(&ctx->buffer[left_over], buffer, add);
684 if (left_over + add > 64) {
685 md5_hash_block(ctx->buffer, (left_over + add) & ~63, ctx);
686 /* The regions in the following copy operation cannot overlap. */
687 memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
688 (left_over + add) & 63);
689 ctx->buflen = (left_over + add) & 63;
692 buffer = (const char *) buffer + add;
696 /* Process available complete blocks. */
698 md5_hash_block(buffer, len & ~63, ctx);
699 buffer = (const char *) buffer + (len & ~63);
703 /* Move remaining bytes in internal buffer. */
705 memcpy(ctx->buffer, buffer, len);
710 static void md5_hash(const void *buffer, size_t length, void *md5_ctx)
712 if (length % 64 == 0) {
713 md5_hash_block(buffer, length, md5_ctx);
715 md5_hash_bytes(buffer, length, md5_ctx);
719 /* Process the remaining bytes in the buffer and put result from CTX
720 * in first 16 bytes following RESBUF. The result is always in little
721 * endian byte order, so that a byte-wise output yields to the wanted
722 * ASCII representation of the message digest.
724 * IMPORTANT: On some systems it is required that RESBUF is correctly
725 * aligned for a 32 bits value.
727 static void *md5_end(void *resbuf, md5_ctx_t *ctx)
729 /* Take yet unprocessed bytes into account. */
730 md5_uint32 bytes = ctx->buflen;
733 /* Now count remaining bytes. */
734 ctx->total[0] += bytes;
735 if (ctx->total[0] < bytes)
738 pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
739 # if MD5SUM_SIZE_VS_SPEED > 0
740 memset(&ctx->buffer[bytes], 0, pad);
741 ctx->buffer[bytes] = 0x80;
743 memcpy(&ctx->buffer[bytes], fillbuf, pad);
744 # endif /* MD5SUM_SIZE_VS_SPEED > 0 */
746 /* Put the 64-bit file length in *bits* at the end of the buffer. */
747 *(md5_uint32 *) & ctx->buffer[bytes + pad] = SWAP(ctx->total[0] << 3);
748 *(md5_uint32 *) & ctx->buffer[bytes + pad + 4] =
749 SWAP(((ctx->total[1] << 3) | (ctx->total[0] >> 29)));
751 /* Process last bytes. */
752 md5_hash_block(ctx->buffer, bytes + pad + 8, ctx);
754 /* Put result from CTX in first 16 bytes following RESBUF. The result is
755 * always in little endian byte order, so that a byte-wise output yields
756 * to the wanted ASCII representation of the message digest.
758 * IMPORTANT: On some systems it is required that RESBUF is correctly
759 * aligned for a 32 bits value.
761 ((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
762 ((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
763 ((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
764 ((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
768 #endif /* CONFIG_MD5SUM */
773 extern int hash_fd(int src_fd, const size_t size, const uint8_t hash_algo,
776 int result = EXIT_SUCCESS;
777 // size_t hashed_count = 0;
778 size_t blocksize = 0;
779 size_t remaining = size;
780 unsigned char *buffer = NULL;
781 void (*hash_fn_ptr)(const void *, size_t, void *) = NULL;
784 #ifdef CONFIG_SHA1SUM
792 #ifdef CONFIG_SHA1SUM
793 if (hash_algo == HASH_SHA1) {
794 /* Ensure that BLOCKSIZE is a multiple of 64. */
796 buffer = xmalloc(blocksize);
797 hash_fn_ptr = sha1_hash;
802 if (hash_algo == HASH_MD5) {
804 buffer = xmalloc(blocksize + 72);
805 hash_fn_ptr = md5_hash;
810 /* Initialize the computation context. */
811 #ifdef CONFIG_SHA1SUM
812 if (hash_algo == HASH_SHA1) {
813 sha1_begin(&sha1_cx);
817 if (hash_algo == HASH_MD5) {
821 /* Iterate over full file contents. */
822 while ((remaining == (size_t) -1) || (remaining > 0)) {
826 if (remaining > blocksize) {
827 read_try = blocksize;
829 read_try = remaining;
831 read_got = bb_full_read(src_fd, buffer, read_try);
833 /* count == 0 means short read
834 * count == -1 means read error */
835 result = read_got - 1;
838 if (remaining != (size_t) -1) {
839 remaining -= read_got;
843 hash_fn_ptr(buffer, read_got, cx);
846 /* Finalize and write the hash into our buffer. */
847 #ifdef CONFIG_SHA1SUM
848 if (hash_algo == HASH_SHA1) {
849 sha1_end(hashval, &sha1_cx);
853 if (hash_algo == HASH_MD5) {
854 md5_end(hashval, &md5_cx);