ce188d4d |
1 | /********************************************************************* |
2 | * Filename: sha1.c |
3 | * Author: Brad Conte (brad AT bradconte.com) |
4 | * Copyright: |
5 | * Disclaimer: This code is presented "as is" without any guarantees. |
6 | * Details: Implementation of the SHA1 hashing algorithm. |
7 | Algorithm specification can be found here: |
8 | * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf |
9 | This implementation uses little endian byte order. |
10 | *********************************************************************/ |
11 | |
12 | /*************************** HEADER FILES ***************************/ |
13 | #include <stdlib.h> |
14 | #include <string.h> |
15 | #include "sha1.h" |
16 | |
17 | /****************************** MACROS ******************************/ |
18 | #define ROTLEFT(a, b) ((a << b) | (a >> (32 - b))) |
19 | |
20 | /*********************** FUNCTION DEFINITIONS ***********************/ |
21 | void sha1_transform(SHA1_CTX *ctx, const BYTE data[]) |
22 | { |
23 | WORD a, b, c, d, e, i, j, t, m[80]; |
24 | |
25 | for (i = 0, j = 0; i < 16; ++i, j += 4) |
26 | m[i] = (data[j] << 24) + (data[j + 1] << 16) + (data[j + 2] << 8) + (data[j + 3]); |
27 | for ( ; i < 80; ++i) { |
28 | m[i] = (m[i - 3] ^ m[i - 8] ^ m[i - 14] ^ m[i - 16]); |
29 | m[i] = (m[i] << 1) | (m[i] >> 31); |
30 | } |
31 | |
32 | a = ctx->state[0]; |
33 | b = ctx->state[1]; |
34 | c = ctx->state[2]; |
35 | d = ctx->state[3]; |
36 | e = ctx->state[4]; |
37 | |
38 | for (i = 0; i < 20; ++i) { |
39 | t = ROTLEFT(a, 5) + ((b & c) ^ (~b & d)) + e + ctx->k[0] + m[i]; |
40 | e = d; |
41 | d = c; |
42 | c = ROTLEFT(b, 30); |
43 | b = a; |
44 | a = t; |
45 | } |
46 | for ( ; i < 40; ++i) { |
47 | t = ROTLEFT(a, 5) + (b ^ c ^ d) + e + ctx->k[1] + m[i]; |
48 | e = d; |
49 | d = c; |
50 | c = ROTLEFT(b, 30); |
51 | b = a; |
52 | a = t; |
53 | } |
54 | for ( ; i < 60; ++i) { |
55 | t = ROTLEFT(a, 5) + ((b & c) ^ (b & d) ^ (c & d)) + e + ctx->k[2] + m[i]; |
56 | e = d; |
57 | d = c; |
58 | c = ROTLEFT(b, 30); |
59 | b = a; |
60 | a = t; |
61 | } |
62 | for ( ; i < 80; ++i) { |
63 | t = ROTLEFT(a, 5) + (b ^ c ^ d) + e + ctx->k[3] + m[i]; |
64 | e = d; |
65 | d = c; |
66 | c = ROTLEFT(b, 30); |
67 | b = a; |
68 | a = t; |
69 | } |
70 | |
71 | ctx->state[0] += a; |
72 | ctx->state[1] += b; |
73 | ctx->state[2] += c; |
74 | ctx->state[3] += d; |
75 | ctx->state[4] += e; |
76 | } |
77 | |
78 | void sha1_init(SHA1_CTX *ctx) |
79 | { |
80 | ctx->datalen = 0; |
81 | ctx->bitlen = 0; |
82 | ctx->state[0] = 0x67452301; |
83 | ctx->state[1] = 0xEFCDAB89; |
84 | ctx->state[2] = 0x98BADCFE; |
85 | ctx->state[3] = 0x10325476; |
86 | ctx->state[4] = 0xc3d2e1f0; |
87 | ctx->k[0] = 0x5a827999; |
88 | ctx->k[1] = 0x6ed9eba1; |
89 | ctx->k[2] = 0x8f1bbcdc; |
90 | ctx->k[3] = 0xca62c1d6; |
91 | } |
92 | |
93 | void sha1_update(SHA1_CTX *ctx, const BYTE data[], size_t len) |
94 | { |
95 | size_t i; |
96 | |
97 | for (i = 0; i < len; ++i) { |
98 | ctx->data[ctx->datalen] = data[i]; |
99 | ctx->datalen++; |
100 | if (ctx->datalen == 64) { |
101 | sha1_transform(ctx, ctx->data); |
102 | ctx->bitlen += 512; |
103 | ctx->datalen = 0; |
104 | } |
105 | } |
106 | } |
107 | |
108 | void sha1_final(SHA1_CTX *ctx, BYTE hash[]) |
109 | { |
110 | WORD i; |
111 | |
112 | i = ctx->datalen; |
113 | |
114 | // Pad whatever data is left in the buffer. |
115 | if (ctx->datalen < 56) { |
116 | ctx->data[i++] = 0x80; |
117 | while (i < 56) |
118 | ctx->data[i++] = 0x00; |
119 | } |
120 | else { |
121 | ctx->data[i++] = 0x80; |
122 | while (i < 64) |
123 | ctx->data[i++] = 0x00; |
124 | sha1_transform(ctx, ctx->data); |
125 | memset(ctx->data, 0, 56); |
126 | } |
127 | |
128 | // Append to the padding the total message's length in bits and transform. |
129 | ctx->bitlen += ctx->datalen * 8; |
130 | ctx->data[63] = ctx->bitlen; |
131 | ctx->data[62] = ctx->bitlen >> 8; |
132 | ctx->data[61] = ctx->bitlen >> 16; |
133 | ctx->data[60] = ctx->bitlen >> 24; |
134 | ctx->data[59] = ctx->bitlen >> 32; |
135 | ctx->data[58] = ctx->bitlen >> 40; |
136 | ctx->data[57] = ctx->bitlen >> 48; |
137 | ctx->data[56] = ctx->bitlen >> 56; |
138 | sha1_transform(ctx, ctx->data); |
139 | |
140 | // Since this implementation uses little endian byte ordering and MD uses big endian, |
141 | // reverse all the bytes when copying the final state to the output hash. |
142 | for (i = 0; i < 4; ++i) { |
143 | hash[i] = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff; |
144 | hash[i + 4] = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff; |
145 | hash[i + 8] = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff; |
146 | hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff; |
147 | hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff; |
148 | } |
149 | } |