2 * This file has been modified for the cdrkit suite.
4 * The behaviour and appearence of the program code below can differ to a major
5 * extent from the version distributed by the original author(s).
7 * For details, see Changelog file distributed with the cdrkit package. If you
8 * received this file from another source then ask the distributing person for
9 * a log of modifications.
13 /* @(#)sha_func.c 1.3 01/10/27 Copyright 1998,1999 Heiko Eissfeldt */
14 /*____________________________________________________________________________
16 // CD Index - The Internet CD Index
18 // This program is free software; you can redistribute it and/or modify
19 // it under the terms of the GNU General Public License as published by
20 // the Free Software Foundation; either version 2 of the License, or
21 // (at your option) any later version.
23 // This program is distributed in the hope that it will be useful,
24 // but WITHOUT ANY WARRANTY; without even the implied warranty of
25 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 // GNU General Public License for more details.
28 // You should have received a copy of the GNU General Public License
29 // along with this program; if not, write to the Free Software
30 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 // $Id: sha_func.c,v 1.2 1999/06/04 14:10:07 marc Exp $
33 //____________________________________________________________________________
35 /* NIST Secure Hash Algorithm */
37 /* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */
38 /* from Peter C. Gutmann's implementation as found in */
39 /* Applied Cryptography by Bruce Schneier */
40 /* Further modifications to include the "UNRAVEL" stuff, below */
41 /* portability modifications Heiko Eissfeldt */
43 /* This code is in the public domain */
49 /* UNRAVEL should be fastest & biggest */
50 /* UNROLL_LOOPS should be just as big, but slightly slower */
51 /* both undefined should be smallest and slowest */
54 /* #define UNROLL_LOOPS */
56 /* SHA f()-functions */
58 #define f1(x,y,z) ((x & y) | (~x & z))
59 #define f2(x,y,z) (x ^ y ^ z)
60 #define f3(x,y,z) ((x & y) | (x & z) | (y & z))
61 #define f4(x,y,z) (x ^ y ^ z)
65 #define CONST1 ULONG_C(0x5a827999)
66 #define CONST2 ULONG_C(0x6ed9eba1)
67 #define CONST3 ULONG_C(0x8f1bbcdc)
68 #define CONST4 ULONG_C(0xca62c1d6)
70 /* truncate to 32 bits -- should be a null op on 32-bit machines */
72 #define T32(x) ((x) & ULONG_C(0xffffffff))
76 #define R32(x,n) T32(((x << n) | (x >> (32 - n))))
78 /* the generic case, for when the overall rotation is not unraveled */
81 T = T32(R32(A,5) + CONCAT(f,n(B,C,D)) + E + *WP++ + CONCAT(CONST,n)); \
82 E = D; D = C; C = R32(B,30); B = A; A = T
84 /* specific cases, for when the overall rotation is unraveled */
87 T = T32(R32(A,5) + CONCAT(f,n(B,C,D)) + E + *WP++ + CONCAT(CONST,n)); B = R32(B,30)
90 E = T32(R32(T,5) + CONCAT(f,n(A,B,C)) + D + *WP++ + CONCAT(CONST,n)); A = R32(A,30)
93 D = T32(R32(E,5) + CONCAT(f,n(T,A,B)) + C + *WP++ + CONCAT(CONST,n)); T = R32(T,30)
96 C = T32(R32(D,5) + CONCAT(f,n(E,T,A)) + B + *WP++ + CONCAT(CONST,n)); E = R32(E,30)
99 B = T32(R32(C,5) + CONCAT(f,n(D,E,T)) + A + *WP++ + CONCAT(CONST,n)); D = R32(D,30)
102 A = T32(R32(B,5) + CONCAT(f,n(C,D,E)) + T + *WP++ + CONCAT(CONST,n)); C = R32(C,30)
104 /* do SHA transformation */
106 static void sha_transform(SHA_INFO *sha_info);
108 static void sha_transform(SHA_INFO *sha_info)
112 ULONG T, A, B, C, D, E, W[80], *WP;
117 the following makes sure that at least one code block below is
118 traversed or an error is reported, without the necessity for nested
119 preprocessor if/else/endif blocks, which are a great pain in the
120 nether regions of the anatomy...
124 #if (SHA_BYTE_ORDER == 1234)
126 for (i = 0; i < 16; ++i) {
129 W[i] = ((T << 24) & ULONG_C(0xff000000)) | ((T << 8) & ULONG_C(0x00ff0000)) |
130 ((T >> 8) & ULONG_C(0x0000ff00)) | ((T >> 24) & ULONG_C(0x000000ff));
132 #endif /* SHA_BYTE_ORDER == 1234 */
134 #if (SHA_BYTE_ORDER == 4321)
136 for (i = 0; i < 16; ++i) {
141 #endif /* SHA_BYTE_ORDER == 4321 */
143 #if (SHA_BYTE_ORDER == 12345678)
145 for (i = 0; i < 16; i += 2) {
148 W[i] = ((T << 24) & ULONG_C(0xff000000)) | ((T << 8) & ULONG_C(0x00ff0000)) |
149 ((T >> 8) & ULONG_C(0x0000ff00)) | ((T >> 24) & ULONG_C(0x000000ff));
151 W[i+1] = ((T << 24) & ULONG_C(0xff000000)) | ((T << 8) & ULONG_C(0x00ff0000)) |
152 ((T >> 8) & ULONG_C(0x0000ff00)) | ((T >> 24) & ULONG_C(0x000000ff));
154 #endif /* SHA_BYTE_ORDER == 12345678 */
156 #if (SHA_BYTE_ORDER == 87654321)
158 for (i = 0; i < 16; i += 2) {
164 #endif /* SHA_BYTE_ORDER == 87654321 */
167 error Unknown byte order -- you need to add code here
168 #endif /* SWAP_DONE */
170 for (i = 16; i < 80; ++i) {
171 W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
172 #if (SHA_VERSION == 1)
174 #endif /* SHA_VERSION */
176 A = sha_info->digest[0];
177 B = sha_info->digest[1];
178 C = sha_info->digest[2];
179 D = sha_info->digest[3];
180 E = sha_info->digest[4];
183 FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);
184 FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);
185 FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);
186 FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);
187 FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);
188 FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);
189 FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);
190 FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);
191 sha_info->digest[0] = T32(sha_info->digest[0] + E);
192 sha_info->digest[1] = T32(sha_info->digest[1] + T);
193 sha_info->digest[2] = T32(sha_info->digest[2] + A);
194 sha_info->digest[3] = T32(sha_info->digest[3] + B);
195 sha_info->digest[4] = T32(sha_info->digest[4] + C);
198 FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
199 FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
200 FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
201 FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
202 FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
203 FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
204 FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
205 FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
206 #else /* !UNROLL_LOOPS */
207 for (i = 0; i < 20; ++i) { FG(1); }
208 for (i = 20; i < 40; ++i) { FG(2); }
209 for (i = 40; i < 60; ++i) { FG(3); }
210 for (i = 60; i < 80; ++i) { FG(4); }
211 #endif /* !UNROLL_LOOPS */
212 sha_info->digest[0] = T32(sha_info->digest[0] + A);
213 sha_info->digest[1] = T32(sha_info->digest[1] + B);
214 sha_info->digest[2] = T32(sha_info->digest[2] + C);
215 sha_info->digest[3] = T32(sha_info->digest[3] + D);
216 sha_info->digest[4] = T32(sha_info->digest[4] + E);
217 #endif /* !UNRAVEL */
220 /* initialize the SHA digest */
222 void sha_init(SHA_INFO *sha_info);
224 void sha_init(SHA_INFO *sha_info)
226 sha_info->digest[0] = ULONG_C(0x67452301);
227 sha_info->digest[1] = ULONG_C(0xefcdab89);
228 sha_info->digest[2] = ULONG_C(0x98badcfe);
229 sha_info->digest[3] = ULONG_C(0x10325476);
230 sha_info->digest[4] = ULONG_C(0xc3d2e1f0);
231 sha_info->count_lo = 0L;
232 sha_info->count_hi = 0L;
236 /* update the SHA digest */
238 void sha_update(SHA_INFO *sha_info, BYTE *buffer, int count);
240 void sha_update(SHA_INFO *sha_info, BYTE *buffer, int count)
245 clo = T32(sha_info->count_lo + ((ULONG) count << 3));
246 if (clo < sha_info->count_lo) {
247 ++sha_info->count_hi;
249 sha_info->count_lo = clo;
250 sha_info->count_hi += (ULONG) count >> 29;
251 if (sha_info->local) {
252 i = SHA_BLOCKSIZE - sha_info->local;
256 memcpy(((BYTE *) sha_info->data) + sha_info->local, buffer, i);
259 sha_info->local += i;
260 if (sha_info->local == SHA_BLOCKSIZE) {
261 sha_transform(sha_info);
266 while (count >= SHA_BLOCKSIZE) {
267 memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
268 buffer += SHA_BLOCKSIZE;
269 count -= SHA_BLOCKSIZE;
270 sha_transform(sha_info);
272 memcpy(sha_info->data, buffer, count);
273 sha_info->local = count;
276 /* finish computing the SHA digest */
278 void sha_final(unsigned char digest[20], SHA_INFO *sha_info);
280 void sha_final(unsigned char digest[20], SHA_INFO *sha_info)
283 ULONG lo_bit_count, hi_bit_count;
285 lo_bit_count = sha_info->count_lo;
286 hi_bit_count = sha_info->count_hi;
287 count = (int) ((lo_bit_count >> 3) & 0x3f);
288 ((BYTE *) sha_info->data)[count++] = 0x80;
289 if (count > SHA_BLOCKSIZE - 8) {
290 memset(((BYTE *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
291 sha_transform(sha_info);
292 memset((BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
294 memset(((BYTE *) sha_info->data) + count, 0,
295 SHA_BLOCKSIZE - 8 - count);
297 sha_info->data[56] = (unsigned char) ((hi_bit_count >> 24) & 0xff);
298 sha_info->data[57] = (unsigned char) ((hi_bit_count >> 16) & 0xff);
299 sha_info->data[58] = (unsigned char) ((hi_bit_count >> 8) & 0xff);
300 sha_info->data[59] = (unsigned char) ((hi_bit_count >> 0) & 0xff);
301 sha_info->data[60] = (unsigned char) ((lo_bit_count >> 24) & 0xff);
302 sha_info->data[61] = (unsigned char) ((lo_bit_count >> 16) & 0xff);
303 sha_info->data[62] = (unsigned char) ((lo_bit_count >> 8) & 0xff);
304 sha_info->data[63] = (unsigned char) ((lo_bit_count >> 0) & 0xff);
305 sha_transform(sha_info);
306 digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
307 digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
308 digest[ 2] = (unsigned char) ((sha_info->digest[0] >> 8) & 0xff);
309 digest[ 3] = (unsigned char) ((sha_info->digest[0] ) & 0xff);
310 digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
311 digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
312 digest[ 6] = (unsigned char) ((sha_info->digest[1] >> 8) & 0xff);
313 digest[ 7] = (unsigned char) ((sha_info->digest[1] ) & 0xff);
314 digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
315 digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
316 digest[10] = (unsigned char) ((sha_info->digest[2] >> 8) & 0xff);
317 digest[11] = (unsigned char) ((sha_info->digest[2] ) & 0xff);
318 digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
319 digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
320 digest[14] = (unsigned char) ((sha_info->digest[3] >> 8) & 0xff);
321 digest[15] = (unsigned char) ((sha_info->digest[3] ) & 0xff);
322 digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
323 digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
324 digest[18] = (unsigned char) ((sha_info->digest[4] >> 8) & 0xff);
325 digest[19] = (unsigned char) ((sha_info->digest[4] ) & 0xff);
330 /* compute the SHA digest of a FILE stream */
332 #define BLOCK_SIZE 8192
334 void sha_stream(unsigned char digest[20], SHA_INFO *sha_info, FILE *fin);
336 void sha_stream(unsigned char digest[20], SHA_INFO *sha_info, FILE *fin)
339 BYTE data[BLOCK_SIZE];
342 while ((i = fread(data, 1, BLOCK_SIZE, fin)) > 0) {
343 sha_update(sha_info, data, i);
345 sha_final(digest, sha_info);
348 /* print a SHA digest */
350 void sha_print(unsigned char digest[20]);
352 void sha_print(unsigned char digest[20])
356 for (j = 0; j < 5; ++j) {
357 for (i = 0; i < 4; ++i) {
358 printf("%02x", *digest++);
360 printf("%c", (j < 4) ? ' ' : '\n');
364 char *sha_version(void);
368 #if (SHA_VERSION == 1)
369 static char *version = "SHA-1";
371 static char *version = "SHA";
376 #endif /* SHA_FOR_C */