2 * Copyright (C) 2004, 2005, 2007 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000, 2001, 2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: sha1.c,v 1.18 2007/06/19 23:47:17 tbox Exp $ */
20 /* $NetBSD: sha1.c,v 1.5 2000/01/22 22:19:14 mycroft Exp $ */
21 /* $OpenBSD: sha1.c,v 1.9 1997/07/23 21:12:32 kstailey Exp $ */
25 * \author By Steve Reid <steve@edmweb.com>
28 * Test Vectors (from FIPS PUB 180-1)
30 * A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
31 * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
32 * 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
33 * A million repetitions of "a"
34 * 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
40 #include <isc/assertions.h>
42 #include <isc/string.h>
43 #include <isc/types.h>
46 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
50 * blk0() and blk() perform the initial expand.
51 * I got the idea of expanding during the round function from SSLeay
53 #if !defined(WORDS_BIGENDIAN)
55 (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) \
56 | (rol(block->l[i], 8) & 0x00FF00FF))
58 # define blk0(i) block->l[i]
61 (block->l[i & 15] = rol(block->l[(i + 13) & 15] \
62 ^ block->l[(i + 8) & 15] \
63 ^ block->l[(i + 2) & 15] \
64 ^ block->l[i & 15], 1))
69 * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
71 #define R0(v,w,x,y,z,i) \
72 z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
74 #define R1(v,w,x,y,z,i) \
75 z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
77 #define R2(v,w,x,y,z,i) \
78 z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
80 #define R3(v,w,x,y,z,i) \
81 z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
83 #define R4(v,w,x,y,z,i) \
84 z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
95 static void do_R01(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
,
96 isc_uint32_t
*d
, isc_uint32_t
*e
, CHAR64LONG16
*);
97 static void do_R2(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
,
98 isc_uint32_t
*d
, isc_uint32_t
*e
, CHAR64LONG16
*);
99 static void do_R3(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
,
100 isc_uint32_t
*d
, isc_uint32_t
*e
, CHAR64LONG16
*);
101 static void do_R4(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
,
102 isc_uint32_t
*d
, isc_uint32_t
*e
, CHAR64LONG16
*);
104 #define nR0(v,w,x,y,z,i) R0(*v,*w,*x,*y,*z,i)
105 #define nR1(v,w,x,y,z,i) R1(*v,*w,*x,*y,*z,i)
106 #define nR2(v,w,x,y,z,i) R2(*v,*w,*x,*y,*z,i)
107 #define nR3(v,w,x,y,z,i) R3(*v,*w,*x,*y,*z,i)
108 #define nR4(v,w,x,y,z,i) R4(*v,*w,*x,*y,*z,i)
111 do_R01(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
, isc_uint32_t
*d
,
112 isc_uint32_t
*e
, CHAR64LONG16
*block
)
114 nR0(a
,b
,c
,d
,e
, 0); nR0(e
,a
,b
,c
,d
, 1); nR0(d
,e
,a
,b
,c
, 2);
115 nR0(c
,d
,e
,a
,b
, 3); nR0(b
,c
,d
,e
,a
, 4); nR0(a
,b
,c
,d
,e
, 5);
116 nR0(e
,a
,b
,c
,d
, 6); nR0(d
,e
,a
,b
,c
, 7); nR0(c
,d
,e
,a
,b
, 8);
117 nR0(b
,c
,d
,e
,a
, 9); nR0(a
,b
,c
,d
,e
,10); nR0(e
,a
,b
,c
,d
,11);
118 nR0(d
,e
,a
,b
,c
,12); nR0(c
,d
,e
,a
,b
,13); nR0(b
,c
,d
,e
,a
,14);
119 nR0(a
,b
,c
,d
,e
,15); nR1(e
,a
,b
,c
,d
,16); nR1(d
,e
,a
,b
,c
,17);
120 nR1(c
,d
,e
,a
,b
,18); nR1(b
,c
,d
,e
,a
,19);
124 do_R2(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
, isc_uint32_t
*d
,
125 isc_uint32_t
*e
, CHAR64LONG16
*block
)
127 nR2(a
,b
,c
,d
,e
,20); nR2(e
,a
,b
,c
,d
,21); nR2(d
,e
,a
,b
,c
,22);
128 nR2(c
,d
,e
,a
,b
,23); nR2(b
,c
,d
,e
,a
,24); nR2(a
,b
,c
,d
,e
,25);
129 nR2(e
,a
,b
,c
,d
,26); nR2(d
,e
,a
,b
,c
,27); nR2(c
,d
,e
,a
,b
,28);
130 nR2(b
,c
,d
,e
,a
,29); nR2(a
,b
,c
,d
,e
,30); nR2(e
,a
,b
,c
,d
,31);
131 nR2(d
,e
,a
,b
,c
,32); nR2(c
,d
,e
,a
,b
,33); nR2(b
,c
,d
,e
,a
,34);
132 nR2(a
,b
,c
,d
,e
,35); nR2(e
,a
,b
,c
,d
,36); nR2(d
,e
,a
,b
,c
,37);
133 nR2(c
,d
,e
,a
,b
,38); nR2(b
,c
,d
,e
,a
,39);
137 do_R3(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
, isc_uint32_t
*d
,
138 isc_uint32_t
*e
, CHAR64LONG16
*block
)
140 nR3(a
,b
,c
,d
,e
,40); nR3(e
,a
,b
,c
,d
,41); nR3(d
,e
,a
,b
,c
,42);
141 nR3(c
,d
,e
,a
,b
,43); nR3(b
,c
,d
,e
,a
,44); nR3(a
,b
,c
,d
,e
,45);
142 nR3(e
,a
,b
,c
,d
,46); nR3(d
,e
,a
,b
,c
,47); nR3(c
,d
,e
,a
,b
,48);
143 nR3(b
,c
,d
,e
,a
,49); nR3(a
,b
,c
,d
,e
,50); nR3(e
,a
,b
,c
,d
,51);
144 nR3(d
,e
,a
,b
,c
,52); nR3(c
,d
,e
,a
,b
,53); nR3(b
,c
,d
,e
,a
,54);
145 nR3(a
,b
,c
,d
,e
,55); nR3(e
,a
,b
,c
,d
,56); nR3(d
,e
,a
,b
,c
,57);
146 nR3(c
,d
,e
,a
,b
,58); nR3(b
,c
,d
,e
,a
,59);
150 do_R4(isc_uint32_t
*a
, isc_uint32_t
*b
, isc_uint32_t
*c
, isc_uint32_t
*d
,
151 isc_uint32_t
*e
, CHAR64LONG16
*block
)
153 nR4(a
,b
,c
,d
,e
,60); nR4(e
,a
,b
,c
,d
,61); nR4(d
,e
,a
,b
,c
,62);
154 nR4(c
,d
,e
,a
,b
,63); nR4(b
,c
,d
,e
,a
,64); nR4(a
,b
,c
,d
,e
,65);
155 nR4(e
,a
,b
,c
,d
,66); nR4(d
,e
,a
,b
,c
,67); nR4(c
,d
,e
,a
,b
,68);
156 nR4(b
,c
,d
,e
,a
,69); nR4(a
,b
,c
,d
,e
,70); nR4(e
,a
,b
,c
,d
,71);
157 nR4(d
,e
,a
,b
,c
,72); nR4(c
,d
,e
,a
,b
,73); nR4(b
,c
,d
,e
,a
,74);
158 nR4(a
,b
,c
,d
,e
,75); nR4(e
,a
,b
,c
,d
,76); nR4(d
,e
,a
,b
,c
,77);
159 nR4(c
,d
,e
,a
,b
,78); nR4(b
,c
,d
,e
,a
,79);
164 * Hash a single 512-bit block. This is the core of the algorithm.
167 transform(isc_uint32_t state
[5], const unsigned char buffer
[64]) {
168 isc_uint32_t a
, b
, c
, d
, e
;
170 CHAR64LONG16 workspace
;
172 INSIST(buffer
!= NULL
);
173 INSIST(state
!= NULL
);
176 (void)memcpy(block
, buffer
, 64);
178 /* Copy context->state[] to working vars */
186 do_R01(&a
, &b
, &c
, &d
, &e
, block
);
187 do_R2(&a
, &b
, &c
, &d
, &e
, block
);
188 do_R3(&a
, &b
, &c
, &d
, &e
, block
);
189 do_R4(&a
, &b
, &c
, &d
, &e
, block
);
191 /* 4 rounds of 20 operations each. Loop unrolled. */
192 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);
193 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);
194 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);
195 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);
196 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);
197 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);
198 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);
199 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);
200 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);
201 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);
202 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);
203 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);
204 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);
205 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);
206 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);
207 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);
208 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);
209 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);
210 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);
211 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);
214 /* Add the working vars back into context.state[] */
222 a
= b
= c
= d
= e
= 0;
227 * isc_sha1_init - Initialize new context
230 isc_sha1_init(isc_sha1_t
*context
)
232 INSIST(context
!= NULL
);
234 /* SHA1 initialization constants */
235 context
->state
[0] = 0x67452301;
236 context
->state
[1] = 0xEFCDAB89;
237 context
->state
[2] = 0x98BADCFE;
238 context
->state
[3] = 0x10325476;
239 context
->state
[4] = 0xC3D2E1F0;
240 context
->count
[0] = 0;
241 context
->count
[1] = 0;
245 isc_sha1_invalidate(isc_sha1_t
*context
) {
246 memset(context
, 0, sizeof(isc_sha1_t
));
250 * Run your data through this.
253 isc_sha1_update(isc_sha1_t
*context
, const unsigned char *data
,
258 INSIST(context
!= 0);
261 j
= context
->count
[0];
262 if ((context
->count
[0] += len
<< 3) < j
)
263 context
->count
[1] += (len
>> 29) + 1;
265 if ((j
+ len
) > 63) {
266 (void)memcpy(&context
->buffer
[j
], data
, (i
= 64 - j
));
267 transform(context
->state
, context
->buffer
);
268 for (; i
+ 63 < len
; i
+= 64)
269 transform(context
->state
, &data
[i
]);
275 (void)memcpy(&context
->buffer
[j
], &data
[i
], len
- i
);
280 * Add padding and return the message digest.
283 static const unsigned char final_200
= 128;
284 static const unsigned char final_0
= 0;
287 isc_sha1_final(isc_sha1_t
*context
, unsigned char *digest
) {
289 unsigned char finalcount
[8];
292 INSIST(context
!= 0);
294 for (i
= 0; i
< 8; i
++) {
295 /* Endian independent */
296 finalcount
[i
] = (unsigned char)
297 ((context
->count
[(i
>= 4 ? 0 : 1)]
298 >> ((3 - (i
& 3)) * 8)) & 255);
301 isc_sha1_update(context
, &final_200
, 1);
302 while ((context
->count
[0] & 504) != 448)
303 isc_sha1_update(context
, &final_0
, 1);
304 /* The next Update should cause a transform() */
305 isc_sha1_update(context
, finalcount
, 8);
308 for (i
= 0; i
< 20; i
++)
309 digest
[i
] = (unsigned char)
310 ((context
->state
[i
>> 2]
311 >> ((3 - (i
& 3)) * 8)) & 255);
314 memset(context
, 0, sizeof(isc_sha1_t
));