2
* SHA1 hash implementation and interface functions
3
* Copyright (c) 2003-2005, Jouni Malinen <j@w1.fi>
5
* This program is free software; you can redistribute it and/or modify
6
* it under the terms of the GNU General Public License version 2 as
7
* published by the Free Software Foundation.
9
* Alternatively, this software may be distributed under the terms of BSD
12
* See README and COPYING for more details.
23
typedef struct SHA1Context SHA1_CTX;
25
void SHA1Transform(u32 state[5], const unsigned char buffer[64]);
29
* sha1_vector - SHA-1 hash for data vector
30
* @num_elem: Number of elements in the data vector
31
* @addr: Pointers to the data areas
32
* @len: Lengths of the data blocks
33
* @mac: Buffer for the hash
34
* Returns: 0 on success, -1 of failure
36
int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
42
for (i = 0; i < num_elem; i++)
43
SHA1Update(&ctx, addr[i], len[i]);
49
/* ===== start - public domain SHA1 implementation ===== */
53
By Steve Reid <sreid@sea-to-sky.net>
58
By James H. Brown <jbrown@burgoyne.com>
59
Still 100% Public Domain
61
Corrected a problem which generated improper hash values on 16 bit machines
62
Routine SHA1Update changed from
63
void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
66
void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
69
The 'len' parameter was declared an int which works fine on 32 bit machines.
70
However, on 16 bit machines an int is too small for the shifts being done
72
it. This caused the hash function to generate incorrect values if len was
73
greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
75
Since the file IO in main() reads 16K at a time, any file 8K or larger would
76
be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
79
I also changed the declaration of variables i & j in SHA1Update to
80
unsigned long from unsigned int for the same reason.
82
These changes should make no difference to any 32 bit implementations since
84
int and a long are the same size in those environments.
87
I also corrected a few compiler warnings generated by Borland C.
88
1. Added #include <process.h> for exit() prototype
89
2. Removed unused variable 'j' in SHA1Final
90
3. Changed exit(0) to return(0) at end of main.
92
ALL changes I made can be located by searching for comments containing 'JHB'
95
By Steve Reid <sreid@sea-to-sky.net>
96
Still 100% public domain
98
1- Removed #include <process.h> and used return() instead of exit()
99
2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
100
3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
104
By Saul Kravitz <Saul.Kravitz@celera.com>
106
Modified to run on Compaq Alpha hardware.
110
By Jouni Malinen <j@w1.fi>
111
Minor changes to match the coding style used in Dynamics.
113
Modified September 24, 2004
114
By Jouni Malinen <j@w1.fi>
115
Fixed alignment issue in SHA1Transform when SHA1HANDSOFF is defined.
120
Test Vectors (from FIPS PUB 180-1)
122
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
123
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
124
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
125
A million repetitions of "a"
126
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
131
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
133
/* blk0() and blk() perform the initial expand. */
134
/* I got the idea of expanding during the round function from SSLeay */
135
#ifndef WORDS_BIGENDIAN
136
#define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
137
(rol(block->l[i], 8) & 0x00FF00FF))
139
#define blk0(i) block->l[i]
141
#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
142
block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
144
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
145
#define R0(v,w,x,y,z,i) \
146
z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
148
#define R1(v,w,x,y,z,i) \
149
z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
151
#define R2(v,w,x,y,z,i) \
152
z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
153
#define R3(v,w,x,y,z,i) \
154
z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
156
#define R4(v,w,x,y,z,i) \
157
z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
161
#ifdef VERBOSE /* SAK */
162
void SHAPrintContext(SHA1_CTX *context, char *msg)
164
printf("%s (%d,%d) %x %x %x %x %x\n",
166
context->count[0], context->count[1],
175
/* Hash a single 512-bit block. This is the core of the algorithm. */
177
void SHA1Transform(u32 state[5], const unsigned char buffer[64])
186
CHAR64LONG16 workspace;
188
os_memcpy(block, buffer, 64);
190
block = (CHAR64LONG16 *) buffer;
192
/* Copy context->state[] to working vars */
198
/* 4 rounds of 20 operations each. Loop unrolled. */
199
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);
200
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);
201
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);
202
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);
203
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);
204
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);
205
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);
206
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);
207
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);
208
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);
209
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);
210
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);
211
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);
212
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);
213
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);
214
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);
215
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);
216
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);
217
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);
218
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);
219
/* Add the working vars back into context.state[] */
226
a = b = c = d = e = 0;
228
os_memset(block, 0, 64);
233
/* SHA1Init - Initialize new context */
235
void SHA1Init(SHA1_CTX* context)
237
/* SHA1 initialization constants */
238
context->state[0] = 0x67452301;
239
context->state[1] = 0xEFCDAB89;
240
context->state[2] = 0x98BADCFE;
241
context->state[3] = 0x10325476;
242
context->state[4] = 0xC3D2E1F0;
243
context->count[0] = context->count[1] = 0;
247
/* Run your data through this. */
249
void SHA1Update(SHA1_CTX* context, const void *_data, u32 len)
252
const unsigned char *data = _data;
255
SHAPrintContext(context, "before");
257
j = (context->count[0] >> 3) & 63;
258
if ((context->count[0] += len << 3) < (len << 3))
260
context->count[1] += (len >> 29);
261
if ((j + len) > 63) {
262
os_memcpy(&context->buffer[j], data, (i = 64-j));
263
SHA1Transform(context->state, context->buffer);
264
for ( ; i + 63 < len; i += 64) {
265
SHA1Transform(context->state, &data[i]);
270
os_memcpy(&context->buffer[j], &data[i], len - i);
272
SHAPrintContext(context, "after ");
277
/* Add padding and return the message digest. */
279
void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
282
unsigned char finalcount[8];
284
for (i = 0; i < 8; i++) {
285
finalcount[i] = (unsigned char)
286
((context->count[(i >= 4 ? 0 : 1)] >>
287
((3-(i & 3)) * 8) ) & 255); /* Endian independent */
289
SHA1Update(context, (unsigned char *) "\200", 1);
290
while ((context->count[0] & 504) != 448) {
291
SHA1Update(context, (unsigned char *) "\0", 1);
293
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform()
295
for (i = 0; i < 20; i++) {
296
digest[i] = (unsigned char)
297
((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) &
302
os_memset(context->buffer, 0, 64);
303
os_memset(context->state, 0, 20);
304
os_memset(context->count, 0, 8);
305
os_memset(finalcount, 0, 8);
308
/* ===== end - public domain SHA1 implementation ===== */
added
removed
src/crypto/sha1-internal.c
