eb7fe6dbf
Denys Vlasenko
2010-10-18
Subject
libbb: move md5 and shaN into a common source file. no code changes
Binary
No binary (build failed)
Architecture & Compiler Flags
—
Build Log
(log yok)
Commit Diff GitHub →
libbb/Kbuild.src+0 -1
| @@ -60,7 +60,6 @@ lib-y += login.o | |
| lib-y += make_directory.o | |
| lib-y += makedev.o | |
| lib-y += match_fstype.o | |
| - | lib-y += hash_md5.o |
| # Alternative (disabled) implementation | |
| #lib-y += hash_md5prime.o | |
| lib-y += hash_sha.o | |
libbb/hash_md5.c+0 -440
| @@ -1,440 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Compute MD5 checksum of strings according to the |
| - | * definition of MD5 in RFC 1321 from April 1992. |
| - | * |
| - | * Written by Ulrich Drepper <[email protected]>, 1995. |
| - | * |
| - | * Copyright (C) 1995-1999 Free Software Foundation, Inc. |
| - | * Copyright (C) 2001 Manuel Novoa III |
| - | * Copyright (C) 2003 Glenn L. McGrath |
| - | * Copyright (C) 2003 Erik Andersen |
| - | * |
| - | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
| - | */ |
| - | |
| - | #include "libbb.h" |
| - | |
| - | /* 0: fastest, 3: smallest */ |
| - | #if CONFIG_MD5_SIZE_VS_SPEED < 0 |
| - | # define MD5_SIZE_VS_SPEED 0 |
| - | #elif CONFIG_MD5_SIZE_VS_SPEED > 3 |
| - | # define MD5_SIZE_VS_SPEED 3 |
| - | #else |
| - | # define MD5_SIZE_VS_SPEED CONFIG_MD5_SIZE_VS_SPEED |
| - | #endif |
| - | |
| - | /* Initialize structure containing state of computation. |
| - | * (RFC 1321, 3.3: Step 3) |
| - | */ |
| - | void FAST_FUNC md5_begin(md5_ctx_t *ctx) |
| - | { |
| - | ctx->A = 0x67452301; |
| - | ctx->B = 0xefcdab89; |
| - | ctx->C = 0x98badcfe; |
| - | ctx->D = 0x10325476; |
| - | ctx->total64 = 0; |
| - | } |
| - | |
| - | /* These are the four functions used in the four steps of the MD5 algorithm |
| - | * and defined in the RFC 1321. The first function is a little bit optimized |
| - | * (as found in Colin Plumbs public domain implementation). |
| - | * #define FF(b, c, d) ((b & c) | (~b & d)) |
| - | */ |
| - | #define FF(b, c, d) (d ^ (b & (c ^ d))) |
| - | #define FG(b, c, d) FF(d, b, c) |
| - | #define FH(b, c, d) (b ^ c ^ d) |
| - | #define FI(b, c, d) (c ^ (b | ~d)) |
| - | |
| - | #define rotl32(w, s) (((w) << (s)) | ((w) >> (32 - (s)))) |
| - | |
| - | /* Hash a single block, 64 bytes long and 4-byte aligned */ |
| - | static void md5_process_block64(md5_ctx_t *ctx) |
| - | { |
| - | #if MD5_SIZE_VS_SPEED > 0 |
| - | /* Before we start, one word to the strange constants. |
| - | They are defined in RFC 1321 as |
| - | T[i] = (int)(4294967296.0 * fabs(sin(i))), i=1..64 |
| - | */ |
| - | static const uint32_t C_array[] = { |
| - | /* round 1 */ |
| - | 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, |
| - | 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, |
| - | 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, |
| - | 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, |
| - | /* round 2 */ |
| - | 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, |
| - | 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, |
| - | 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, |
| - | 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, |
| - | /* round 3 */ |
| - | 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, |
| - | 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, |
| - | 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05, |
| - | 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, |
| - | /* round 4 */ |
| - | 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, |
| - | 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, |
| - | 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, |
| - | 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 |
| - | }; |
| - | static const char P_array[] ALIGN1 = { |
| - | # if MD5_SIZE_VS_SPEED > 1 |
| - | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */ |
| - | # endif |
| - | 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */ |
| - | 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */ |
| - | 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */ |
| - | }; |
| - | #endif |
| - | uint32_t *words = (void*) ctx->wbuffer; |
| - | uint32_t A = ctx->A; |
| - | uint32_t B = ctx->B; |
| - | uint32_t C = ctx->C; |
| - | uint32_t D = ctx->D; |
| - | |
| - | #if MD5_SIZE_VS_SPEED >= 2 /* 2 or 3 */ |
| - | |
| - | static const char S_array[] ALIGN1 = { |
| - | 7, 12, 17, 22, |
| - | 5, 9, 14, 20, |
| - | 4, 11, 16, 23, |
| - | 6, 10, 15, 21 |
| - | }; |
| - | const uint32_t *pc; |
| - | const char *pp; |
| - | const char *ps; |
| - | int i; |
| - | uint32_t temp; |
| - | |
| - | # if BB_BIG_ENDIAN |
| - | for (i = 0; i < 16; i++) |
| - | words[i] = SWAP_LE32(words[i]); |
| - | # endif |
| - | |
| - | # if MD5_SIZE_VS_SPEED == 3 |
| - | pc = C_array; |
| - | pp = P_array; |
| - | ps = S_array - 4; |
| - | |
| - | for (i = 0; i < 64; i++) { |
| - | if ((i & 0x0f) == 0) |
| - | ps += 4; |
| - | temp = A; |
| - | switch (i >> 4) { |
| - | case 0: |
| - | temp += FF(B, C, D); |
| - | break; |
| - | case 1: |
| - | temp += FG(B, C, D); |
| - | break; |
| - | case 2: |
| - | temp += FH(B, C, D); |
| - | break; |
| - | case 3: |
| - | temp += FI(B, C, D); |
| - | } |
| - | temp += words[(int) (*pp++)] + *pc++; |
| - | temp = rotl32(temp, ps[i & 3]); |
| - | temp += B; |
| - | A = D; |
| - | D = C; |
| - | C = B; |
| - | B = temp; |
| - | } |
| - | # else /* MD5_SIZE_VS_SPEED == 2 */ |
| - | pc = C_array; |
| - | pp = P_array; |
| - | ps = S_array; |
| - | |
| - | for (i = 0; i < 16; i++) { |
| - | temp = A + FF(B, C, D) + words[(int) (*pp++)] + *pc++; |
| - | temp = rotl32(temp, ps[i & 3]); |
| - | temp += B; |
| - | A = D; |
| - | D = C; |
| - | C = B; |
| - | B = temp; |
| - | } |
| - | ps += 4; |
| - | for (i = 0; i < 16; i++) { |
| - | temp = A + FG(B, C, D) + words[(int) (*pp++)] + *pc++; |
| - | temp = rotl32(temp, ps[i & 3]); |
| - | temp += B; |
| - | A = D; |
| - | D = C; |
| - | C = B; |
| - | B = temp; |
| - | } |
| - | ps += 4; |
| - | for (i = 0; i < 16; i++) { |
| - | temp = A + FH(B, C, D) + words[(int) (*pp++)] + *pc++; |
| - | temp = rotl32(temp, ps[i & 3]); |
| - | temp += B; |
| - | A = D; |
| - | D = C; |
| - | C = B; |
| - | B = temp; |
| - | } |
| - | ps += 4; |
| - | for (i = 0; i < 16; i++) { |
| - | temp = A + FI(B, C, D) + words[(int) (*pp++)] + *pc++; |
| - | temp = rotl32(temp, ps[i & 3]); |
| - | temp += B; |
| - | A = D; |
| - | D = C; |
| - | C = B; |
| - | B = temp; |
| - | } |
| - | # endif |
| - | /* Add checksum to the starting values */ |
| - | ctx->A += A; |
| - | ctx->B += B; |
| - | ctx->C += C; |
| - | ctx->D += D; |
| - | |
| - | #else /* MD5_SIZE_VS_SPEED == 0 or 1 */ |
| - | |
| - | uint32_t A_save = A; |
| - | uint32_t B_save = B; |
| - | uint32_t C_save = C; |
| - | uint32_t D_save = D; |
| - | # if MD5_SIZE_VS_SPEED == 1 |
| - | const uint32_t *pc; |
| - | const char *pp; |
| - | int i; |
| - | # endif |
| - | |
| - | /* First round: using the given function, the context and a constant |
| - | the next context is computed. Because the algorithm's processing |
| - | unit is a 32-bit word and it is determined to work on words in |
| - | little endian byte order we perhaps have to change the byte order |
| - | before the computation. To reduce the work for the next steps |
| - | we save swapped words in WORDS array. */ |
| - | # undef OP |
| - | # define OP(a, b, c, d, s, T) \ |
| - | do { \ |
| - | a += FF(b, c, d) + (*words IF_BIG_ENDIAN(= SWAP_LE32(*words))) + T; \ |
| - | words++; \ |
| - | a = rotl32(a, s); \ |
| - | a += b; \ |
| - | } while (0) |
| - | |
| - | /* Round 1 */ |
| - | # if MD5_SIZE_VS_SPEED == 1 |
| - | pc = C_array; |
| - | for (i = 0; i < 4; i++) { |
| - | OP(A, B, C, D, 7, *pc++); |
| - | OP(D, A, B, C, 12, *pc++); |
| - | OP(C, D, A, B, 17, *pc++); |
| - | OP(B, C, D, A, 22, *pc++); |
| - | } |
| - | # else |
| - | OP(A, B, C, D, 7, 0xd76aa478); |
| - | OP(D, A, B, C, 12, 0xe8c7b756); |
| - | OP(C, D, A, B, 17, 0x242070db); |
| - | OP(B, C, D, A, 22, 0xc1bdceee); |
| - | OP(A, B, C, D, 7, 0xf57c0faf); |
| - | OP(D, A, B, C, 12, 0x4787c62a); |
| - | OP(C, D, A, B, 17, 0xa8304613); |
| - | OP(B, C, D, A, 22, 0xfd469501); |
| - | OP(A, B, C, D, 7, 0x698098d8); |
| - | OP(D, A, B, C, 12, 0x8b44f7af); |
| - | OP(C, D, A, B, 17, 0xffff5bb1); |
| - | OP(B, C, D, A, 22, 0x895cd7be); |
| - | OP(A, B, C, D, 7, 0x6b901122); |
| - | OP(D, A, B, C, 12, 0xfd987193); |
| - | OP(C, D, A, B, 17, 0xa679438e); |
| - | OP(B, C, D, A, 22, 0x49b40821); |
| - | # endif |
| - | words -= 16; |
| - | |
| - | /* For the second to fourth round we have the possibly swapped words |
| - | in WORDS. Redefine the macro to take an additional first |
| - | argument specifying the function to use. */ |
| - | # undef OP |
| - | # define OP(f, a, b, c, d, k, s, T) \ |
| - | do { \ |
| - | a += f(b, c, d) + words[k] + T; \ |
| - | a = rotl32(a, s); \ |
| - | a += b; \ |
| - | } while (0) |
| - | |
| - | /* Round 2 */ |
| - | # if MD5_SIZE_VS_SPEED == 1 |
| - | pp = P_array; |
| - | for (i = 0; i < 4; i++) { |
| - | OP(FG, A, B, C, D, (int) (*pp++), 5, *pc++); |
| - | OP(FG, D, A, B, C, (int) (*pp++), 9, *pc++); |
| - | OP(FG, C, D, A, B, (int) (*pp++), 14, *pc++); |
| - | OP(FG, B, C, D, A, (int) (*pp++), 20, *pc++); |
| - | } |
| - | # else |
| - | OP(FG, A, B, C, D, 1, 5, 0xf61e2562); |
| - | OP(FG, D, A, B, C, 6, 9, 0xc040b340); |
| - | OP(FG, C, D, A, B, 11, 14, 0x265e5a51); |
| - | OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa); |
| - | OP(FG, A, B, C, D, 5, 5, 0xd62f105d); |
| - | OP(FG, D, A, B, C, 10, 9, 0x02441453); |
| - | OP(FG, C, D, A, B, 15, 14, 0xd8a1e681); |
| - | OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8); |
| - | OP(FG, A, B, C, D, 9, 5, 0x21e1cde6); |
| - | OP(FG, D, A, B, C, 14, 9, 0xc33707d6); |
| - | OP(FG, C, D, A, B, 3, 14, 0xf4d50d87); |
| - | OP(FG, B, C, D, A, 8, 20, 0x455a14ed); |
| - | OP(FG, A, B, C, D, 13, 5, 0xa9e3e905); |
| - | OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8); |
| - | OP(FG, C, D, A, B, 7, 14, 0x676f02d9); |
| - | OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a); |
| - | # endif |
| - | |
| - | /* Round 3 */ |
| - | # if MD5_SIZE_VS_SPEED == 1 |
| - | for (i = 0; i < 4; i++) { |
| - | OP(FH, A, B, C, D, (int) (*pp++), 4, *pc++); |
| - | OP(FH, D, A, B, C, (int) (*pp++), 11, *pc++); |
| - | OP(FH, C, D, A, B, (int) (*pp++), 16, *pc++); |
| - | OP(FH, B, C, D, A, (int) (*pp++), 23, *pc++); |
| - | } |
| - | # else |
| - | OP(FH, A, B, C, D, 5, 4, 0xfffa3942); |
| - | OP(FH, D, A, B, C, 8, 11, 0x8771f681); |
| - | OP(FH, C, D, A, B, 11, 16, 0x6d9d6122); |
| - | OP(FH, B, C, D, A, 14, 23, 0xfde5380c); |
| - | OP(FH, A, B, C, D, 1, 4, 0xa4beea44); |
| - | OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9); |
| - | OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60); |
| - | OP(FH, B, C, D, A, 10, 23, 0xbebfbc70); |
| - | OP(FH, A, B, C, D, 13, 4, 0x289b7ec6); |
| - | OP(FH, D, A, B, C, 0, 11, 0xeaa127fa); |
| - | OP(FH, C, D, A, B, 3, 16, 0xd4ef3085); |
| - | OP(FH, B, C, D, A, 6, 23, 0x04881d05); |
| - | OP(FH, A, B, C, D, 9, 4, 0xd9d4d039); |
| - | OP(FH, D, A, B, C, 12, 11, 0xe6db99e5); |
| - | OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8); |
| - | OP(FH, B, C, D, A, 2, 23, 0xc4ac5665); |
| - | # endif |
| - | |
| - | /* Round 4 */ |
| - | # if MD5_SIZE_VS_SPEED == 1 |
| - | for (i = 0; i < 4; i++) { |
| - | OP(FI, A, B, C, D, (int) (*pp++), 6, *pc++); |
| - | OP(FI, D, A, B, C, (int) (*pp++), 10, *pc++); |
| - | OP(FI, C, D, A, B, (int) (*pp++), 15, *pc++); |
| - | OP(FI, B, C, D, A, (int) (*pp++), 21, *pc++); |
| - | } |
| - | # else |
| - | OP(FI, A, B, C, D, 0, 6, 0xf4292244); |
| - | OP(FI, D, A, B, C, 7, 10, 0x432aff97); |
| - | OP(FI, C, D, A, B, 14, 15, 0xab9423a7); |
| - | OP(FI, B, C, D, A, 5, 21, 0xfc93a039); |
| - | OP(FI, A, B, C, D, 12, 6, 0x655b59c3); |
| - | OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92); |
| - | OP(FI, C, D, A, B, 10, 15, 0xffeff47d); |
| - | OP(FI, B, C, D, A, 1, 21, 0x85845dd1); |
| - | OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f); |
| - | OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0); |
| - | OP(FI, C, D, A, B, 6, 15, 0xa3014314); |
| - | OP(FI, B, C, D, A, 13, 21, 0x4e0811a1); |
| - | OP(FI, A, B, C, D, 4, 6, 0xf7537e82); |
| - | OP(FI, D, A, B, C, 11, 10, 0xbd3af235); |
| - | OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb); |
| - | OP(FI, B, C, D, A, 9, 21, 0xeb86d391); |
| - | # endif |
| - | /* Add checksum to the starting values */ |
| - | ctx->A = A_save + A; |
| - | ctx->B = B_save + B; |
| - | ctx->C = C_save + C; |
| - | ctx->D = D_save + D; |
| - | #endif |
| - | } |
| - | |
| - | /* Feed data through a temporary buffer to call md5_hash_aligned_block() |
| - | * with chunks of data that are 4-byte aligned and a multiple of 64 bytes. |
| - | * This function's internal buffer remembers previous data until it has 64 |
| - | * bytes worth to pass on. Call md5_end() to flush this buffer. */ |
| - | void FAST_FUNC md5_hash(md5_ctx_t *ctx, const void *buffer, size_t len) |
| - | { |
| - | unsigned bufpos = ctx->total64 & 63; |
| - | unsigned remaining; |
| - | |
| - | /* RFC 1321 specifies the possible length of the file up to 2^64 bits. |
| - | * Here we only track the number of bytes. */ |
| - | ctx->total64 += len; |
| - | #if 0 |
| - | remaining = 64 - bufpos; |
| - | |
| - | /* Hash whole blocks */ |
| - | while (len >= remaining) { |
| - | memcpy(ctx->wbuffer + bufpos, buffer, remaining); |
| - | buffer = (const char *)buffer + remaining; |
| - | len -= remaining; |
| - | remaining = 64; |
| - | bufpos = 0; |
| - | md5_process_block64(ctx); |
| - | } |
| - | |
| - | /* Save last, partial blosk */ |
| - | memcpy(ctx->wbuffer + bufpos, buffer, len); |
| - | #else |
| - | /* Tiny bit smaller code */ |
| - | while (1) { |
| - | remaining = 64 - bufpos; |
| - | if (remaining > len) |
| - | remaining = len; |
| - | /* Copy data into aligned buffer */ |
| - | memcpy(ctx->wbuffer + bufpos, buffer, remaining); |
| - | len -= remaining; |
| - | buffer = (const char *)buffer + remaining; |
| - | bufpos += remaining; |
| - | /* clever way to do "if (bufpos != 64) break; ... ; bufpos = 0;" */ |
| - | bufpos -= 64; |
| - | if (bufpos != 0) |
| - | break; |
| - | /* Buffer is filled up, process it */ |
| - | md5_process_block64(ctx); |
| - | /*bufpos = 0; - already is */ |
| - | } |
| - | #endif |
| - | } |
| - | |
| - | /* Process the remaining bytes in the buffer and put result from CTX |
| - | * in first 16 bytes following RESBUF. The result is always in little |
| - | * endian byte order, so that a byte-wise output yields to the wanted |
| - | * ASCII representation of the message digest. |
| - | */ |
| - | void FAST_FUNC md5_end(md5_ctx_t *ctx, void *resbuf) |
| - | { |
| - | unsigned bufpos = ctx->total64 & 63; |
| - | /* Pad the buffer to the next 64-byte boundary with 0x80,0,0,0... */ |
| - | ctx->wbuffer[bufpos++] = 0x80; |
| - | |
| - | /* This loop iterates either once or twice, no more, no less */ |
| - | while (1) { |
| - | unsigned remaining = 64 - bufpos; |
| - | memset(ctx->wbuffer + bufpos, 0, remaining); |
| - | /* Do we have enough space for the length count? */ |
| - | if (remaining >= 8) { |
| - | /* Store the 64-bit counter of bits in the buffer in LE format */ |
| - | uint64_t t = ctx->total64 << 3; |
| - | t = SWAP_LE64(t); |
| - | /* wbuffer is suitably aligned for this */ |
| - | *(uint64_t *) (&ctx->wbuffer[64 - 8]) = t; |
| - | } |
| - | md5_process_block64(ctx); |
| - | if (remaining >= 8) |
| - | break; |
| - | bufpos = 0; |
| - | } |
| - | |
| - | /* The MD5 result is in little endian byte order. |
| - | * We (ab)use the fact that A-D are consecutive in memory. |
| - | */ |
| - | #if BB_BIG_ENDIAN |
| - | ctx->A = SWAP_LE32(ctx->A); |
| - | ctx->B = SWAP_LE32(ctx->B); |
| - | ctx->C = SWAP_LE32(ctx->C); |
| - | ctx->D = SWAP_LE32(ctx->D); |
| - | #endif |
| - | memcpy(resbuf, &ctx->A, sizeof(ctx->A) * 4); |
| - | } |
libbb/hash_sha.c+451 -9
| @@ -53,12 +53,6 @@ static ALWAYS_INLINE uint64_t rotr64(uint64_t x, unsigned n) | |
| } | |
| - | /* Some arch headers have conflicting defines */ |
| - | #undef ch |
| - | #undef parity |
| - | #undef maj |
| - | #undef rnd |
| - | |
| static void FAST_FUNC sha1_process_block64(sha1_ctx_t *ctx) | |
| { | |
| unsigned t; | |
| @@ -78,12 +72,14 @@ static void FAST_FUNC sha1_process_block64(sha1_ctx_t *ctx) | |
| d = ctx->hash[3]; | |
| e = ctx->hash[4]; | |
| - | /* Reverse byte order in 32-bit words */ |
| + | #undef ch |
| + | #undef parity |
| + | #undef maj |
| + | #undef rnd |
| #define ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z)))) | |
| #define parity(x,y,z) ((x) ^ (y) ^ (z)) | |
| #define maj(x,y,z) (((x) & (y)) | ((z) & ((x) | (y)))) | |
| - | /* A normal version as set out in the FIPS. This version uses */ |
| - | /* partial loop unrolling and is optimised for the Pentium 4 */ |
| + | /* A normal version as set out in the FIPS. */ |
| #define rnd(f,k) \ | |
| do { \ | |
| uint32_t T = a; \ | |
| @@ -518,3 +514,449 @@ void FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf) | |
| } | |
| memcpy(resbuf, ctx->hash, sizeof(ctx->hash)); | |
| } | |
| + | |
| + | |
| + | /* |
| + | * Compute MD5 checksum of strings according to the |
| + | * definition of MD5 in RFC 1321 from April 1992. |
| + | * |
| + | * Written by Ulrich Drepper <[email protected]>, 1995. |
| + | * |
| + | * Copyright (C) 1995-1999 Free Software Foundation, Inc. |
| + | * Copyright (C) 2001 Manuel Novoa III |
| + | * Copyright (C) 2003 Glenn L. McGrath |
| + | * Copyright (C) 2003 Erik Andersen |
| + | * |
| + | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
| + | */ |
| + | |
| + | /* 0: fastest, 3: smallest */ |
| + | #if CONFIG_MD5_SIZE_VS_SPEED < 0 |
| + | # define MD5_SIZE_VS_SPEED 0 |
| + | #elif CONFIG_MD5_SIZE_VS_SPEED > 3 |
| + | # define MD5_SIZE_VS_SPEED 3 |
| + | #else |
| + | # define MD5_SIZE_VS_SPEED CONFIG_MD5_SIZE_VS_SPEED |
| + | #endif |
| + | |
| + | /* Initialize structure containing state of computation. |
| + | * (RFC 1321, 3.3: Step 3) |
| + | */ |
| + | void FAST_FUNC md5_begin(md5_ctx_t *ctx) |
| + | { |
| + | ctx->A = 0x67452301; |
| + | ctx->B = 0xefcdab89; |
| + | ctx->C = 0x98badcfe; |
| + | ctx->D = 0x10325476; |
| + | ctx->total64 = 0; |
| + | } |
| + | |
| + | /* These are the four functions used in the four steps of the MD5 algorithm |
| + | * and defined in the RFC 1321. The first function is a little bit optimized |
| + | * (as found in Colin Plumbs public domain implementation). |
| + | * #define FF(b, c, d) ((b & c) | (~b & d)) |
| + | */ |
| + | #undef FF |
| + | #undef FG |
| + | #undef FH |
| + | #undef FI |
| + | #define FF(b, c, d) (d ^ (b & (c ^ d))) |
| + | #define FG(b, c, d) FF(d, b, c) |
| + | #define FH(b, c, d) (b ^ c ^ d) |
| + | #define FI(b, c, d) (c ^ (b | ~d)) |
| + | |
| + | /* Hash a single block, 64 bytes long and 4-byte aligned */ |
| + | static void md5_process_block64(md5_ctx_t *ctx) |
| + | { |
| + | #if MD5_SIZE_VS_SPEED > 0 |
| + | /* Before we start, one word to the strange constants. |
| + | They are defined in RFC 1321 as |
| + | T[i] = (int)(4294967296.0 * fabs(sin(i))), i=1..64 |
| + | */ |
| + | static const uint32_t C_array[] = { |
| + | /* round 1 */ |
| + | 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, |
| + | 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, |
| + | 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, |
| + | 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, |
| + | /* round 2 */ |
| + | 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, |
| + | 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, |
| + | 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, |
| + | 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, |
| + | /* round 3 */ |
| + | 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, |
| + | 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, |
| + | 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05, |
| + | 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, |
| + | /* round 4 */ |
| + | 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, |
| + | 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, |
| + | 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, |
| + | 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 |
| + | }; |
| + | static const char P_array[] ALIGN1 = { |
| + | # if MD5_SIZE_VS_SPEED > 1 |
| + | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */ |
| + | # endif |
| + | 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */ |
| + | 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */ |
| + | 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */ |
| + | }; |
| + | #endif |
| + | uint32_t *words = (void*) ctx->wbuffer; |
| + | uint32_t A = ctx->A; |
| + | uint32_t B = ctx->B; |
| + | uint32_t C = ctx->C; |
| + | uint32_t D = ctx->D; |
| + | |
| + | #if MD5_SIZE_VS_SPEED >= 2 /* 2 or 3 */ |
| + | |
| + | static const char S_array[] ALIGN1 = { |
| + | 7, 12, 17, 22, |
| + | 5, 9, 14, 20, |
| + | 4, 11, 16, 23, |
| + | 6, 10, 15, 21 |
| + | }; |
| + | const uint32_t *pc; |
| + | const char *pp; |
| + | const char *ps; |
| + | int i; |
| + | uint32_t temp; |
| + | |
| + | # if BB_BIG_ENDIAN |
| + | for (i = 0; i < 16; i++) |
| + | words[i] = SWAP_LE32(words[i]); |
| + | # endif |
| + | |
| + | # if MD5_SIZE_VS_SPEED == 3 |
| + | pc = C_array; |
| + | pp = P_array; |
| + | ps = S_array - 4; |
| + | |
| + | for (i = 0; i < 64; i++) { |
| + | if ((i & 0x0f) == 0) |
| + | ps += 4; |
| + | temp = A; |
| + | switch (i >> 4) { |
| + | case 0: |
| + | temp += FF(B, C, D); |
| + | break; |
| + | case 1: |
| + | temp += FG(B, C, D); |
| + | break; |
| + | case 2: |
| + | temp += FH(B, C, D); |
| + | break; |
| + | case 3: |
| + | temp += FI(B, C, D); |
| + | } |
| + | temp += words[(int) (*pp++)] + *pc++; |
| + | temp = rotl32(temp, ps[i & 3]); |
| + | temp += B; |
| + | A = D; |
| + | D = C; |
| + | C = B; |
| + | B = temp; |
| + | } |
| + | # else /* MD5_SIZE_VS_SPEED == 2 */ |
| + | pc = C_array; |
| + | pp = P_array; |
| + | ps = S_array; |
| + | |
| + | for (i = 0; i < 16; i++) { |
| + | temp = A + FF(B, C, D) + words[(int) (*pp++)] + *pc++; |
| + | temp = rotl32(temp, ps[i & 3]); |
| + | temp += B; |
| + | A = D; |
| + | D = C; |
| + | C = B; |
| + | B = temp; |
| + | } |
| + | ps += 4; |
| + | for (i = 0; i < 16; i++) { |
| + | temp = A + FG(B, C, D) + words[(int) (*pp++)] + *pc++; |
| + | temp = rotl32(temp, ps[i & 3]); |
| + | temp += B; |
| + | A = D; |
| + | D = C; |
| + | C = B; |
| + | B = temp; |
| + | } |
| + | ps += 4; |
| + | for (i = 0; i < 16; i++) { |
| + | temp = A + FH(B, C, D) + words[(int) (*pp++)] + *pc++; |
| + | temp = rotl32(temp, ps[i & 3]); |
| + | temp += B; |
| + | A = D; |
| + | D = C; |
| + | C = B; |
| + | B = temp; |
| + | } |
| + | ps += 4; |
| + | for (i = 0; i < 16; i++) { |
| + | temp = A + FI(B, C, D) + words[(int) (*pp++)] + *pc++; |
| + | temp = rotl32(temp, ps[i & 3]); |
| + | temp += B; |
| + | A = D; |
| + | D = C; |
| + | C = B; |
| + | B = temp; |
| + | } |
| + | # endif |
| + | /* Add checksum to the starting values */ |
| + | ctx->A += A; |
| + | ctx->B += B; |
| + | ctx->C += C; |
| + | ctx->D += D; |
| + | |
| + | #else /* MD5_SIZE_VS_SPEED == 0 or 1 */ |
| + | |
| + | uint32_t A_save = A; |
| + | uint32_t B_save = B; |
| + | uint32_t C_save = C; |
| + | uint32_t D_save = D; |
| + | # if MD5_SIZE_VS_SPEED == 1 |
| + | const uint32_t *pc; |
| + | const char *pp; |
| + | int i; |
| + | # endif |
| + | |
| + | /* First round: using the given function, the context and a constant |
| + | the next context is computed. Because the algorithm's processing |
| + | unit is a 32-bit word and it is determined to work on words in |
| + | little endian byte order we perhaps have to change the byte order |
| + | before the computation. To reduce the work for the next steps |
| + | we save swapped words in WORDS array. */ |
| + | # undef OP |
| + | # define OP(a, b, c, d, s, T) \ |
| + | do { \ |
| + | a += FF(b, c, d) + (*words IF_BIG_ENDIAN(= SWAP_LE32(*words))) + T; \ |
| + | words++; \ |
| + | a = rotl32(a, s); \ |
| + | a += b; \ |
| + | } while (0) |
| + | |
| + | /* Round 1 */ |
| + | # if MD5_SIZE_VS_SPEED == 1 |
| + | pc = C_array; |
| + | for (i = 0; i < 4; i++) { |
| + | OP(A, B, C, D, 7, *pc++); |
| + | OP(D, A, B, C, 12, *pc++); |
| + | OP(C, D, A, B, 17, *pc++); |
| + | OP(B, C, D, A, 22, *pc++); |
| + | } |
| + | # else |
| + | OP(A, B, C, D, 7, 0xd76aa478); |
| + | OP(D, A, B, C, 12, 0xe8c7b756); |
| + | OP(C, D, A, B, 17, 0x242070db); |
| + | OP(B, C, D, A, 22, 0xc1bdceee); |
| + | OP(A, B, C, D, 7, 0xf57c0faf); |
| + | OP(D, A, B, C, 12, 0x4787c62a); |
| + | OP(C, D, A, B, 17, 0xa8304613); |
| + | OP(B, C, D, A, 22, 0xfd469501); |
| + | OP(A, B, C, D, 7, 0x698098d8); |
| + | OP(D, A, B, C, 12, 0x8b44f7af); |
| + | OP(C, D, A, B, 17, 0xffff5bb1); |
| + | OP(B, C, D, A, 22, 0x895cd7be); |
| + | OP(A, B, C, D, 7, 0x6b901122); |
| + | OP(D, A, B, C, 12, 0xfd987193); |
| + | OP(C, D, A, B, 17, 0xa679438e); |
| + | OP(B, C, D, A, 22, 0x49b40821); |
| + | # endif |
| + | words -= 16; |
| + | |
| + | /* For the second to fourth round we have the possibly swapped words |
| + | in WORDS. Redefine the macro to take an additional first |
| + | argument specifying the function to use. */ |
| + | # undef OP |
| + | # define OP(f, a, b, c, d, k, s, T) \ |
| + | do { \ |
| + | a += f(b, c, d) + words[k] + T; \ |
| + | a = rotl32(a, s); \ |
| + | a += b; \ |
| + | } while (0) |
| + | |
| + | /* Round 2 */ |
| + | # if MD5_SIZE_VS_SPEED == 1 |
| + | pp = P_array; |
| + | for (i = 0; i < 4; i++) { |
| + | OP(FG, A, B, C, D, (int) (*pp++), 5, *pc++); |
| + | OP(FG, D, A, B, C, (int) (*pp++), 9, *pc++); |
| + | OP(FG, C, D, A, B, (int) (*pp++), 14, *pc++); |
| + | OP(FG, B, C, D, A, (int) (*pp++), 20, *pc++); |
| + | } |
| + | # else |
| + | OP(FG, A, B, C, D, 1, 5, 0xf61e2562); |
| + | OP(FG, D, A, B, C, 6, 9, 0xc040b340); |
| + | OP(FG, C, D, A, B, 11, 14, 0x265e5a51); |
| + | OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa); |
| + | OP(FG, A, B, C, D, 5, 5, 0xd62f105d); |
| + | OP(FG, D, A, B, C, 10, 9, 0x02441453); |
| + | OP(FG, C, D, A, B, 15, 14, 0xd8a1e681); |
| + | OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8); |
| + | OP(FG, A, B, C, D, 9, 5, 0x21e1cde6); |
| + | OP(FG, D, A, B, C, 14, 9, 0xc33707d6); |
| + | OP(FG, C, D, A, B, 3, 14, 0xf4d50d87); |
| + | OP(FG, B, C, D, A, 8, 20, 0x455a14ed); |
| + | OP(FG, A, B, C, D, 13, 5, 0xa9e3e905); |
| + | OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8); |
| + | OP(FG, C, D, A, B, 7, 14, 0x676f02d9); |
| + | OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a); |
| + | # endif |
| + | |
| + | /* Round 3 */ |
| + | # if MD5_SIZE_VS_SPEED == 1 |
| + | for (i = 0; i < 4; i++) { |
| + | OP(FH, A, B, C, D, (int) (*pp++), 4, *pc++); |
| + | OP(FH, D, A, B, C, (int) (*pp++), 11, *pc++); |
| + | OP(FH, C, D, A, B, (int) (*pp++), 16, *pc++); |
| + | OP(FH, B, C, D, A, (int) (*pp++), 23, *pc++); |
| + | } |
| + | # else |
| + | OP(FH, A, B, C, D, 5, 4, 0xfffa3942); |
| + | OP(FH, D, A, B, C, 8, 11, 0x8771f681); |
| + | OP(FH, C, D, A, B, 11, 16, 0x6d9d6122); |
| + | OP(FH, B, C, D, A, 14, 23, 0xfde5380c); |
| + | OP(FH, A, B, C, D, 1, 4, 0xa4beea44); |
| + | OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9); |
| + | OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60); |
| + | OP(FH, B, C, D, A, 10, 23, 0xbebfbc70); |
| + | OP(FH, A, B, C, D, 13, 4, 0x289b7ec6); |
| + | OP(FH, D, A, B, C, 0, 11, 0xeaa127fa); |
| + | OP(FH, C, D, A, B, 3, 16, 0xd4ef3085); |
| + | OP(FH, B, C, D, A, 6, 23, 0x04881d05); |
| + | OP(FH, A, B, C, D, 9, 4, 0xd9d4d039); |
| + | OP(FH, D, A, B, C, 12, 11, 0xe6db99e5); |
| + | OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8); |
| + | OP(FH, B, C, D, A, 2, 23, 0xc4ac5665); |
| + | # endif |
| + | |
| + | /* Round 4 */ |
| + | # if MD5_SIZE_VS_SPEED == 1 |
| + | for (i = 0; i < 4; i++) { |
| + | OP(FI, A, B, C, D, (int) (*pp++), 6, *pc++); |
| + | OP(FI, D, A, B, C, (int) (*pp++), 10, *pc++); |
| + | OP(FI, C, D, A, B, (int) (*pp++), 15, *pc++); |
| + | OP(FI, B, C, D, A, (int) (*pp++), 21, *pc++); |
| + | } |
| + | # else |
| + | OP(FI, A, B, C, D, 0, 6, 0xf4292244); |
| + | OP(FI, D, A, B, C, 7, 10, 0x432aff97); |
| + | OP(FI, C, D, A, B, 14, 15, 0xab9423a7); |
| + | OP(FI, B, C, D, A, 5, 21, 0xfc93a039); |
| + | OP(FI, A, B, C, D, 12, 6, 0x655b59c3); |
| + | OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92); |
| + | OP(FI, C, D, A, B, 10, 15, 0xffeff47d); |
| + | OP(FI, B, C, D, A, 1, 21, 0x85845dd1); |
| + | OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f); |
| + | OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0); |
| + | OP(FI, C, D, A, B, 6, 15, 0xa3014314); |
| + | OP(FI, B, C, D, A, 13, 21, 0x4e0811a1); |
| + | OP(FI, A, B, C, D, 4, 6, 0xf7537e82); |
| + | OP(FI, D, A, B, C, 11, 10, 0xbd3af235); |
| + | OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb); |
| + | OP(FI, B, C, D, A, 9, 21, 0xeb86d391); |
| + | # undef OP |
| + | # endif |
| + | /* Add checksum to the starting values */ |
| + | ctx->A = A_save + A; |
| + | ctx->B = B_save + B; |
| + | ctx->C = C_save + C; |
| + | ctx->D = D_save + D; |
| + | #endif |
| + | } |
| + | #undef FF |
| + | #undef FG |
| + | #undef FH |
| + | #undef FI |
| + | |
| + | /* Feed data through a temporary buffer to call md5_hash_aligned_block() |
| + | * with chunks of data that are 4-byte aligned and a multiple of 64 bytes. |
| + | * This function's internal buffer remembers previous data until it has 64 |
| + | * bytes worth to pass on. Call md5_end() to flush this buffer. */ |
| + | void FAST_FUNC md5_hash(md5_ctx_t *ctx, const void *buffer, size_t len) |
| + | { |
| + | unsigned bufpos = ctx->total64 & 63; |
| + | unsigned remaining; |
| + | |
| + | /* RFC 1321 specifies the possible length of the file up to 2^64 bits. |
| + | * Here we only track the number of bytes. */ |
| + | ctx->total64 += len; |
| + | #if 0 |
| + | remaining = 64 - bufpos; |
| + | |
| + | /* Hash whole blocks */ |
| + | while (len >= remaining) { |
| + | memcpy(ctx->wbuffer + bufpos, buffer, remaining); |
| + | buffer = (const char *)buffer + remaining; |
| + | len -= remaining; |
| + | remaining = 64; |
| + | bufpos = 0; |
| + | md5_process_block64(ctx); |
| + | } |
| + | |
| + | /* Save last, partial blosk */ |
| + | memcpy(ctx->wbuffer + bufpos, buffer, len); |
| + | #else |
| + | /* Tiny bit smaller code */ |
| + | while (1) { |
| + | remaining = 64 - bufpos; |
| + | if (remaining > len) |
| + | remaining = len; |
| + | /* Copy data into aligned buffer */ |
| + | memcpy(ctx->wbuffer + bufpos, buffer, remaining); |
| + | len -= remaining; |
| + | buffer = (const char *)buffer + remaining; |
| + | bufpos += remaining; |
| + | /* clever way to do "if (bufpos != 64) break; ... ; bufpos = 0;" */ |
| + | bufpos -= 64; |
| + | if (bufpos != 0) |
| + | break; |
| + | /* Buffer is filled up, process it */ |
| + | md5_process_block64(ctx); |
| + | /*bufpos = 0; - already is */ |
| + | } |
| + | #endif |
| + | } |
| + | |
| + | /* Process the remaining bytes in the buffer and put result from CTX |
| + | * in first 16 bytes following RESBUF. The result is always in little |
| + | * endian byte order, so that a byte-wise output yields to the wanted |
| + | * ASCII representation of the message digest. |
| + | */ |
| + | void FAST_FUNC md5_end(md5_ctx_t *ctx, void *resbuf) |
| + | { |
| + | unsigned bufpos = ctx->total64 & 63; |
| + | /* Pad the buffer to the next 64-byte boundary with 0x80,0,0,0... */ |
| + | ctx->wbuffer[bufpos++] = 0x80; |
| + | |
| + | /* This loop iterates either once or twice, no more, no less */ |
| + | while (1) { |
| + | unsigned remaining = 64 - bufpos; |
| + | memset(ctx->wbuffer + bufpos, 0, remaining); |
| + | /* Do we have enough space for the length count? */ |
| + | if (remaining >= 8) { |
| + | /* Store the 64-bit counter of bits in the buffer in LE format */ |
| + | uint64_t t = ctx->total64 << 3; |
| + | t = SWAP_LE64(t); |
| + | /* wbuffer is suitably aligned for this */ |
| + | *(uint64_t *) (&ctx->wbuffer[64 - 8]) = t; |
| + | } |
| + | md5_process_block64(ctx); |
| + | if (remaining >= 8) |
| + | break; |
| + | bufpos = 0; |
| + | } |
| + | |
| + | /* The MD5 result is in little endian byte order. |
| + | * We (ab)use the fact that A-D are consecutive in memory. |
| + | */ |
| + | #if BB_BIG_ENDIAN |
| + | ctx->A = SWAP_LE32(ctx->A); |
| + | ctx->B = SWAP_LE32(ctx->B); |
| + | ctx->C = SWAP_LE32(ctx->C); |
| + | ctx->D = SWAP_LE32(ctx->D); |
| + | #endif |
| + | memcpy(resbuf, &ctx->A, sizeof(ctx->A) * 4); |
| + | } |