| |
| /* --------------------------------- SHS.CC ------------------------------- */ |
| |
| /* |
| * NIST proposed Secure Hash Standard. |
| * |
| * Written 2 September 1992, Peter C. Gutmann. |
| * This implementation placed in the public domain. |
| * |
| * Comments to pgut1@cs.aukuni.ac.nz |
| */ |
| |
| // Force C++ compiler to use Java-style EH, so we don't have to link with |
| // libstdc++. |
| #pragma GCC java_exceptions |
| |
| #include <string.h> |
| #include "shs.h" |
| |
| /* The SHS f()-functions */ |
| |
| #define f1(x,y,z) ( ( x & y ) | ( ~x & z ) ) /* Rounds 0-19 */ |
| #define f2(x,y,z) ( x ^ y ^ z ) /* Rounds 20-39 */ |
| #define f3(x,y,z) ( ( x & y ) | ( x & z ) | ( y & z ) ) /* Rounds 40-59 */ |
| #define f4(x,y,z) ( x ^ y ^ z ) /* Rounds 60-79 */ |
| |
| /* The SHS Mysterious Constants */ |
| |
| #define K1 0x5A827999L /* Rounds 0-19 */ |
| #define K2 0x6ED9EBA1L /* Rounds 20-39 */ |
| #define K3 0x8F1BBCDCL /* Rounds 40-59 */ |
| #define K4 0xCA62C1D6L /* Rounds 60-79 */ |
| |
| /* SHS initial values */ |
| |
| #define h0init 0x67452301L |
| #define h1init 0xEFCDAB89L |
| #define h2init 0x98BADCFEL |
| #define h3init 0x10325476L |
| #define h4init 0xC3D2E1F0L |
| |
| /* 32-bit rotate - kludged with shifts */ |
| |
| #define S(n,X) ((X << n) | (X >> (32 - n))) |
| |
| /* The initial expanding function */ |
| |
| #define expand(count) W [count] = W [count - 3] ^ W [count - 8] ^ W [count - 14] ^ W [count - 16] |
| |
| /* The four SHS sub-rounds */ |
| |
| #define subRound1(count) \ |
| { \ |
| temp = S (5, A) + f1 (B, C, D) + E + W [count] + K1; \ |
| E = D; \ |
| D = C; \ |
| C = S (30, B); \ |
| B = A; \ |
| A = temp; \ |
| } |
| |
| #define subRound2(count) \ |
| { \ |
| temp = S (5, A) + f2 (B, C, D) + E + W [count] + K2; \ |
| E = D; \ |
| D = C; \ |
| C = S (30, B); \ |
| B = A; \ |
| A = temp; \ |
| } |
| |
| #define subRound3(count) \ |
| { \ |
| temp = S (5, A) + f3 (B, C, D) + E + W [count] + K3; \ |
| E = D; \ |
| D = C; \ |
| C = S (30, B); \ |
| B = A; \ |
| A = temp; \ |
| } |
| |
| #define subRound4(count) \ |
| { \ |
| temp = S (5, A) + f4 (B, C, D) + E + W [count] + K4; \ |
| E = D; \ |
| D = C; \ |
| C = S (30, B); \ |
| B = A; \ |
| A = temp; \ |
| } |
| |
| /* The two buffers of 5 32-bit words */ |
| |
| uint32_t h0, h1, h2, h3, h4; |
| uint32_t A, B, C, D, E; |
| |
| local void byteReverse OF((uint32_t *buffer, int byteCount)); |
| void shsTransform OF((SHS_INFO *shsInfo)); |
| |
| /* Initialize the SHS values */ |
| |
| void shsInit (SHS_INFO *shsInfo) |
| { |
| /* Set the h-vars to their initial values */ |
| shsInfo->digest [0] = h0init; |
| shsInfo->digest [1] = h1init; |
| shsInfo->digest [2] = h2init; |
| shsInfo->digest [3] = h3init; |
| shsInfo->digest [4] = h4init; |
| |
| /* Initialise bit count */ |
| shsInfo->countLo = shsInfo->countHi = 0L; |
| } |
| |
| /* |
| * Perform the SHS transformation. Note that this code, like MD5, seems to |
| * break some optimizing compilers - it may be necessary to split it into |
| * sections, eg based on the four subrounds |
| */ |
| |
| void shsTransform (SHS_INFO *shsInfo) |
| { |
| uint32_t W [80], temp; |
| int i; |
| |
| /* Step A. Copy the data buffer into the local work buffer */ |
| for (i = 0; i < 16; i++) |
| W [i] = shsInfo->data [i]; |
| |
| /* Step B. Expand the 16 words into 64 temporary data words */ |
| expand (16); expand (17); expand (18); expand (19); expand (20); |
| expand (21); expand (22); expand (23); expand (24); expand (25); |
| expand (26); expand (27); expand (28); expand (29); expand (30); |
| expand (31); expand (32); expand (33); expand (34); expand (35); |
| expand (36); expand (37); expand (38); expand (39); expand (40); |
| expand (41); expand (42); expand (43); expand (44); expand (45); |
| expand (46); expand (47); expand (48); expand (49); expand (50); |
| expand (51); expand (52); expand (53); expand (54); expand (55); |
| expand (56); expand (57); expand (58); expand (59); expand (60); |
| expand (61); expand (62); expand (63); expand (64); expand (65); |
| expand (66); expand (67); expand (68); expand (69); expand (70); |
| expand (71); expand (72); expand (73); expand (74); expand (75); |
| expand (76); expand (77); expand (78); expand (79); |
| |
| /* Step C. Set up first buffer */ |
| A = shsInfo->digest [0]; |
| B = shsInfo->digest [1]; |
| C = shsInfo->digest [2]; |
| D = shsInfo->digest [3]; |
| E = shsInfo->digest [4]; |
| |
| /* Step D. Serious mangling, divided into four sub-rounds */ |
| subRound1 (0); subRound1 (1); subRound1 (2); subRound1 (3); |
| subRound1 (4); subRound1 (5); subRound1 (6); subRound1 (7); |
| subRound1 (8); subRound1 (9); subRound1 (10); subRound1 (11); |
| subRound1 (12); subRound1 (13); subRound1 (14); subRound1 (15); |
| subRound1 (16); subRound1 (17); subRound1 (18); subRound1 (19); |
| |
| subRound2 (20); subRound2 (21); subRound2 (22); subRound2 (23); |
| subRound2 (24); subRound2 (25); subRound2 (26); subRound2 (27); |
| subRound2 (28); subRound2 (29); subRound2 (30); subRound2 (31); |
| subRound2 (32); subRound2 (33); subRound2 (34); subRound2 (35); |
| subRound2 (36); subRound2 (37); subRound2 (38); subRound2 (39); |
| |
| subRound3 (40); subRound3 (41); subRound3 (42); subRound3 (43); |
| subRound3 (44); subRound3 (45); subRound3 (46); subRound3 (47); |
| subRound3 (48); subRound3 (49); subRound3 (50); subRound3 (51); |
| subRound3 (52); subRound3 (53); subRound3 (54); subRound3 (55); |
| subRound3 (56); subRound3 (57); subRound3 (58); subRound3 (59); |
| |
| subRound4 (60); subRound4 (61); subRound4 (62); subRound4 (63); |
| subRound4 (64); subRound4 (65); subRound4 (66); subRound4 (67); |
| subRound4 (68); subRound4 (69); subRound4 (70); subRound4 (71); |
| subRound4 (72); subRound4 (73); subRound4 (74); subRound4 (75); |
| subRound4 (76); subRound4 (77); subRound4 (78); subRound4 (79); |
| |
| /* Step E. Build message digest */ |
| shsInfo->digest [0] += A; |
| shsInfo->digest [1] += B; |
| shsInfo->digest [2] += C; |
| shsInfo->digest [3] += D; |
| shsInfo->digest [4] += E; |
| } |
| |
| local void byteReverse (uint32_t *buffer, int byteCount) |
| { |
| uint32_t value; |
| int count; |
| |
| /* |
| * Find out what the byte order is on this machine. |
| * Big endian is for machines that place the most significant byte |
| * first (eg. Sun SPARC). Little endian is for machines that place |
| * the least significant byte first (eg. VAX). |
| * |
| * We figure out the byte order by stuffing a 2 byte string into a |
| * short and examining the left byte. '@' = 0x40 and 'P' = 0x50 |
| * If the left byte is the 'high' byte, then it is 'big endian'. |
| * If the left byte is the 'low' byte, then the machine is 'little |
| * endian'. |
| * |
| * -- Shawn A. Clifford (sac@eng.ufl.edu) |
| */ |
| |
| /* |
| * Several bugs fixed -- Pat Myrto (pat@rwing.uucp) |
| */ |
| |
| if ((*(unsigned short *) ("@P") >> 8) == '@') |
| return; |
| |
| byteCount /= sizeof (uint32_t); |
| for (count = 0; count < byteCount; count++) { |
| value = (buffer [count] << 16) | (buffer [count] >> 16); |
| buffer [count] = ((value & 0xFF00FF00L) >> 8) | ((value & 0x00FF00FFL) << 8); |
| } |
| } |
| |
| /* |
| * Update SHS for a block of data. This code assumes that the buffer size is |
| * a multiple of SHS_BLOCKSIZE bytes long, which makes the code a lot more |
| * efficient since it does away with the need to handle partial blocks |
| * between calls to shsUpdate() |
| */ |
| |
| void shsUpdate (SHS_INFO *shsInfo, uint8_t *buffer, int count) |
| { |
| /* Update bitcount */ |
| if ((shsInfo->countLo + ((uint32_t) count << 3)) < shsInfo->countLo) |
| shsInfo->countHi++; /* Carry from low to high bitCount */ |
| shsInfo->countLo += ((uint32_t) count << 3); |
| shsInfo->countHi += ((uint32_t) count >> 29); |
| |
| /* Process data in SHS_BLOCKSIZE chunks */ |
| while (count >= SHS_BLOCKSIZE) { |
| memcpy (shsInfo->data, buffer, SHS_BLOCKSIZE); |
| byteReverse (shsInfo->data, SHS_BLOCKSIZE); |
| shsTransform (shsInfo); |
| buffer += SHS_BLOCKSIZE; |
| count -= SHS_BLOCKSIZE; |
| } |
| |
| /* |
| * Handle any remaining bytes of data. |
| * This should only happen once on the final lot of data |
| */ |
| memcpy (shsInfo->data, buffer, count); |
| } |
| |
| void shsFinal (SHS_INFO *shsInfo) |
| { |
| int count; |
| uint32_t lowBitcount = shsInfo->countLo, highBitcount = shsInfo->countHi; |
| |
| /* Compute number of bytes mod 64 */ |
| count = (int) ((shsInfo->countLo >> 3) & 0x3F); |
| |
| /* |
| * Set the first char of padding to 0x80. |
| * This is safe since there is always at least one byte free |
| */ |
| ((uint8_t *) shsInfo->data) [count++] = 0x80; |
| |
| /* Pad out to 56 mod 64 */ |
| if (count > 56) { |
| /* Two lots of padding: Pad the first block to 64 bytes */ |
| memset ((uint8_t *) shsInfo->data + count, 0, 64 - count); |
| byteReverse (shsInfo->data, SHS_BLOCKSIZE); |
| shsTransform (shsInfo); |
| |
| /* Now fill the next block with 56 bytes */ |
| memset (shsInfo->data, 0, 56); |
| } else |
| /* Pad block to 56 bytes */ |
| memset ((uint8_t *) shsInfo->data + count, 0, 56 - count); |
| byteReverse (shsInfo->data, SHS_BLOCKSIZE); |
| |
| /* Append length in bits and transform */ |
| shsInfo->data [14] = highBitcount; |
| shsInfo->data [15] = lowBitcount; |
| |
| shsTransform (shsInfo); |
| byteReverse (shsInfo->data, SHS_DIGESTSIZE); |
| } |