2 * SHA1 hash implementation and interface functions
3 * Copyright (c) 2003-2005, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
17 typedef struct SHA1Context SHA1_CTX;
19 void SHA1Transform(u32 state[5], const unsigned char buffer[64]);
22 #ifdef CONFIG_CRYPTO_INTERNAL
24 * sha1_vector - SHA-1 hash for data vector
25 * @num_elem: Number of elements in the data vector
26 * @addr: Pointers to the data areas
27 * @len: Lengths of the data blocks
28 * @mac: Buffer for the hash
29 * Returns: 0 on success, -1 of failure
31 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
40 for (i = 0; i < num_elem; i++)
41 SHA1Update(&ctx, addr[i], len[i]);
45 #endif /* CONFIG_CRYPTO_INTERNAL */
48 /* ===== start - public domain SHA1 implementation ===== */
52 By Steve Reid <sreid@sea-to-sky.net>
57 By James H. Brown <jbrown@burgoyne.com>
58 Still 100% Public Domain
60 Corrected a problem which generated improper hash values on 16 bit machines
61 Routine SHA1Update changed from
62 void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
65 void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
68 The 'len' parameter was declared an int which works fine on 32 bit machines.
69 However, on 16 bit machines an int is too small for the shifts being done
71 it. This caused the hash function to generate incorrect values if len was
72 greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
74 Since the file IO in main() reads 16K at a time, any file 8K or larger would
75 be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
78 I also changed the declaration of variables i & j in SHA1Update to
79 unsigned long from unsigned int for the same reason.
81 These changes should make no difference to any 32 bit implementations since
83 int and a long are the same size in those environments.
86 I also corrected a few compiler warnings generated by Borland C.
87 1. Added #include <process.h> for exit() prototype
88 2. Removed unused variable 'j' in SHA1Final
89 3. Changed exit(0) to return(0) at end of main.
91 ALL changes I made can be located by searching for comments containing 'JHB'
94 By Steve Reid <sreid@sea-to-sky.net>
95 Still 100% public domain
97 1- Removed #include <process.h> and used return() instead of exit()
98 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
99 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
103 By Saul Kravitz <Saul.Kravitz@celera.com>
105 Modified to run on Compaq Alpha hardware.
109 By Jouni Malinen <j@w1.fi>
110 Minor changes to match the coding style used in Dynamics.
112 Modified September 24, 2004
113 By Jouni Malinen <j@w1.fi>
114 Fixed alignment issue in SHA1Transform when SHA1HANDSOFF is defined.
119 Test Vectors (from FIPS PUB 180-1)
121 A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
122 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
123 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
124 A million repetitions of "a"
125 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
130 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
132 /* blk0() and blk() perform the initial expand. */
133 /* I got the idea of expanding during the round function from SSLeay */
134 #ifndef WORDS_BIGENDIAN
135 #define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
136 (rol(block->l[i], 8) & 0x00FF00FF))
138 #define blk0(i) block->l[i]
140 #define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
141 block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
143 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
144 #define R0(v,w,x,y,z,i) \
145 z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
147 #define R1(v,w,x,y,z,i) \
148 z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
150 #define R2(v,w,x,y,z,i) \
151 z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
152 #define R3(v,w,x,y,z,i) \
153 z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
155 #define R4(v,w,x,y,z,i) \
156 z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
160 #ifdef VERBOSE /* SAK */
161 void SHAPrintContext(SHA1_CTX *context, char *msg)
163 printf("%s (%d,%d) %x %x %x %x %x\n",
165 context->count[0], context->count[1],
174 /* Hash a single 512-bit block. This is the core of the algorithm. */
176 void SHA1Transform(u32 state[5], const unsigned char buffer[64])
185 CHAR64LONG16 workspace;
187 os_memcpy(block, buffer, 64);
189 block = (CHAR64LONG16 *) buffer;
191 /* Copy context->state[] to working vars */
197 /* 4 rounds of 20 operations each. Loop unrolled. */
198 R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
199 R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
200 R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
201 R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
202 R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
203 R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
204 R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
205 R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
206 R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
207 R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
208 R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
209 R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
210 R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
211 R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
212 R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
213 R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
214 R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
215 R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
216 R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
217 R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
218 /* Add the working vars back into context.state[] */
225 a = b = c = d = e = 0;
227 forced_memzero(block, 64);
232 /* SHA1Init - Initialize new context */
234 void SHA1Init(SHA1_CTX* context)
236 /* SHA1 initialization constants */
237 context->state[0] = 0x67452301;
238 context->state[1] = 0xEFCDAB89;
239 context->state[2] = 0x98BADCFE;
240 context->state[3] = 0x10325476;
241 context->state[4] = 0xC3D2E1F0;
242 context->count[0] = context->count[1] = 0;
246 /* Run your data through this. */
248 void SHA1Update(SHA1_CTX* context, const void *_data, u32 len)
251 const unsigned char *data = _data;
254 SHAPrintContext(context, "before");
256 j = (context->count[0] >> 3) & 63;
257 if ((context->count[0] += len << 3) < (len << 3))
259 context->count[1] += (len >> 29);
260 if ((j + len) > 63) {
261 os_memcpy(&context->buffer[j], data, (i = 64-j));
262 SHA1Transform(context->state, context->buffer);
263 for ( ; i + 63 < len; i += 64) {
264 SHA1Transform(context->state, &data[i]);
269 os_memcpy(&context->buffer[j], &data[i], len - i);
271 SHAPrintContext(context, "after ");
276 /* Add padding and return the message digest. */
278 void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
281 unsigned char finalcount[8];
283 for (i = 0; i < 8; i++) {
284 finalcount[i] = (unsigned char)
285 ((context->count[(i >= 4 ? 0 : 1)] >>
286 ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
288 SHA1Update(context, (unsigned char *) "\200", 1);
289 while ((context->count[0] & 504) != 448) {
290 SHA1Update(context, (unsigned char *) "\0", 1);
292 SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform()
294 for (i = 0; i < 20; i++) {
295 digest[i] = (unsigned char)
296 ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) &
300 os_memset(context->buffer, 0, 64);
301 os_memset(context->state, 0, 20);
302 os_memset(context->count, 0, 8);
303 forced_memzero(finalcount, sizeof(finalcount));
306 /* ===== end - public domain SHA1 implementation ===== */