Update copyright to LGPL on all files
[dyninst.git] / parseThat / src / sha1.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 /*
32 SHA-1 in C
33 By Steve Reid <sreid@sea-to-sky.net>
34 100% Public Domain
35
36 -----------------
37 Modified 7/98 
38 By James H. Brown <jbrown@burgoyne.com>
39 Still 100% Public Domain
40
41 Corrected a problem which generated improper hash values on 16 bit machines
42 Routine SHA1Update changed from
43         void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
44 len)
45 to
46         void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
47 long len)
48
49 The 'len' parameter was declared an int which works fine on 32 bit machines.
50 However, on 16 bit machines an int is too small for the shifts being done
51 against
52 it.  This caused the hash function to generate incorrect values if len was
53 greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
54
55 Since the file IO in main() reads 16K at a time, any file 8K or larger would
56 be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
57 "a"s).
58
59 I also changed the declaration of variables i & j in SHA1Update to 
60 unsigned long from unsigned int for the same reason.
61
62 These changes should make no difference to any 32 bit implementations since
63 an
64 int and a long are the same size in those environments.
65
66 --
67 I also corrected a few compiler warnings generated by Borland C.
68 1. Added #include <process.h> for exit() prototype
69 2. Removed unused variable 'j' in SHA1Final
70 3. Changed exit(0) to return(0) at end of main.
71
72 ALL changes I made can be located by searching for comments containing 'JHB'
73 -----------------
74 Modified 8/98
75 By Steve Reid <sreid@sea-to-sky.net>
76 Still 100% public domain
77
78 1- Removed #include <process.h> and used return() instead of exit()
79 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
80 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
81
82 -----------------
83 Modified 4/01
84 By Saul Kravitz <Saul.Kravitz@celera.com>
85 Still 100% PD
86 Modified to run on Compaq Alpha hardware.  
87
88
89 */
90
91 /*
92 Test Vectors (from FIPS PUB 180-1)
93 "abc"
94   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
95 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
96   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
97 A million repetitions of "a"
98   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
99 */
100
101 /* #define SHA1HANDSOFF  */
102
103 #include "sha1.h"
104 #include <stdio.h>
105 #include <string.h>
106
107 #if defined(HAVE_INTTYPES_H)
108 #include <inttypes.h>
109
110 #else
111 #if defined(HAVE_STDINT_H)
112 #include <stdint.h>
113
114 #else
115 typedef          long long int int64_t;
116 typedef unsigned long long int uint64_t;
117 typedef          int int32_t;
118 typedef unsigned int uint32_t;
119
120 #endif
121 #endif
122
123 /* #include <process.h> */      /* prototype for exit() - JHB */
124 /* Using return() instead of exit() - SWR */
125
126 typedef struct {
127     uint32_t state[5];
128     uint32_t count[2];
129     unsigned char buffer[64];
130 } SHA1_CTX;
131
132 void SHA1Transform(uint32_t state[5], unsigned char buffer[64]);
133 void SHA1Init(SHA1_CTX* context);
134 void SHA1Update(SHA1_CTX* context, unsigned char* data, uint32_t len);  /*JHB */
135 void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
136
137 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
138
139 /* blk0() and blk() perform the initial expand. */
140 /* I got the idea of expanding during the round function from SSLeay */
141 #if defined(WORDS_BIGENDIAN)
142 #define blk0(i) block->l[i]
143 #else
144 #define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
145     |(rol(block->l[i],8)&0x00FF00FF))
146 #endif
147 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
148     ^block->l[(i+2)&15]^block->l[i&15],1))
149
150 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
151 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
152 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
153 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
154 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
155 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
156
157
158 #ifdef VERBOSE  /* SAK */
159 void SHAPrintContext(SHA1_CTX *context, char *msg){
160   printf("%s (%d,%d) %x %x %x %x %x\n",
161          msg,
162          context->count[0], context->count[1], 
163          context->state[0],
164          context->state[1],
165          context->state[2],
166          context->state[3],
167          context->state[4]);
168 }
169 #endif
170
171 /* Hash a single 512-bit block. This is the core of the algorithm. */
172
173 void SHA1Transform(uint32_t state[5], unsigned char buffer[64])
174 {
175 uint32_t a, b, c, d, e;
176 typedef union {
177     unsigned char c[64];
178     uint32_t l[16];
179 } CHAR64LONG16;
180 CHAR64LONG16* block;
181 #ifdef SHA1HANDSOFF
182 static unsigned char workspace[64];
183     block = (CHAR64LONG16*)workspace;
184     memcpy(block, buffer, 64);
185 #else
186     block = (CHAR64LONG16*)buffer;
187 #endif
188     /* Copy context->state[] to working vars */
189     a = state[0];
190     b = state[1];
191     c = state[2];
192     d = state[3];
193     e = state[4];
194     /* 4 rounds of 20 operations each. Loop unrolled. */
195     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);
196     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);
197     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);
198     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);
199     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);
200     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);
201     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);
202     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);
203     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);
204     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);
205     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);
206     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);
207     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);
208     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);
209     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);
210     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);
211     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);
212     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);
213     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);
214     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);
215     /* Add the working vars back into context.state[] */
216     state[0] += a;
217     state[1] += b;
218     state[2] += c;
219     state[3] += d;
220     state[4] += e;
221     /* Wipe variables */
222     a = b = c = d = e = 0;
223 }
224
225
226 /* SHA1Init - Initialize new context */
227
228 void SHA1Init(SHA1_CTX* context)
229 {
230     /* SHA1 initialization constants */
231     context->state[0] = 0x67452301;
232     context->state[1] = 0xEFCDAB89;
233     context->state[2] = 0x98BADCFE;
234     context->state[3] = 0x10325476;
235     context->state[4] = 0xC3D2E1F0;
236     context->count[0] = context->count[1] = 0;
237 }
238
239
240 /* Run your data through this. */
241
242 void SHA1Update(SHA1_CTX* context, unsigned char* data, uint32_t len)   /*JHB */
243 {
244 uint32_t i, j;  /* JHB */
245
246 #ifdef VERBOSE
247     SHAPrintContext(context, "before");
248 #endif
249     j = (context->count[0] >> 3) & 63;
250     if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
251     context->count[1] += (len >> 29);
252     if ((j + len) > 63) {
253         memcpy(&context->buffer[j], data, (i = 64-j));
254         SHA1Transform(context->state, context->buffer);
255         for ( ; i + 63 < len; i += 64) {
256             SHA1Transform(context->state, &data[i]);
257         }
258         j = 0;
259     }
260     else i = 0;
261     memcpy(&context->buffer[j], &data[i], len - i);
262 #ifdef VERBOSE
263     SHAPrintContext(context, "after ");
264 #endif
265 }
266
267
268 /* Add padding and return the message digest. */
269
270 void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
271 {
272 uint32_t i;     /* JHB */
273 unsigned char finalcount[8];
274
275     for (i = 0; i < 8; i++) {
276         finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
277          >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
278     }
279     SHA1Update(context, (unsigned char *)"\200", 1);
280     while ((context->count[0] & 504) != 448) {
281         SHA1Update(context, (unsigned char *)"\0", 1);
282     }
283     SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
284     for (i = 0; i < 20; i++) {
285         digest[i] = (unsigned char)
286          ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
287     }
288     /* Wipe variables */
289     i = 0;      /* JHB */
290     memset(context->buffer, 0, 64);
291     memset(context->state, 0, 20);
292     memset(context->count, 0, 8);
293     memset(finalcount, 0, 8);   /* SWR */
294 #ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
295     SHA1Transform(context->state, context->buffer);
296 #endif
297 }
298   
299 /*************************************************************/
300
301 char *sha1_file(const char *filename, char *result_ptr)
302 {
303     static char result[SHA1_STRING_LEN] = {0};
304
305     SHA1_CTX ctx;
306     unsigned char buf[16384];
307
308     if (result_ptr == NULL)
309         result_ptr = result;
310
311     FILE *fd = fopen(filename, "r");
312     if (!fd) return NULL;
313
314     SHA1Init(&ctx);
315     while (!feof(fd)) {
316         unsigned long len = fread((char *)buf, sizeof(char), sizeof(buf), fd);
317         if (ferror(fd)) {
318             fclose(fd);
319             return NULL;
320         }
321         SHA1Update(&ctx, buf, len);
322     }
323     SHA1Final(buf, &ctx);
324
325     fclose(fd);
326
327     for (unsigned int i = 0; i < SHA1_DIGEST_LEN; ++i)
328         sprintf(&result_ptr[i*2], "%02x", buf[i]);
329
330     return result_ptr;
331 }