addrutil: Re-indent.
[wk-misc.git] / sha1sum.c
1 /* sha1sum.c - print SHA-1 Message-Digest Algorithm 
2  * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3  * Copyright (C) 2004, 2009 g10 Code GmbH
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; either version 3, or (at your option) any
8  * later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
17  */
18
19 /* 
20    To build this tool as md5sum    use -DBUILD_MD5SUM
21    To build this tool as sha256sum use -DBUILD_SHA256SUM
22
23    SHA-1 code taken from gnupg 1.3.92. 
24    MD-5 and SHA-256 code taken from libgcrypt 1.5.0.
25    
26    Note that this is a simple tool to be used for MS Windows.
27    However, it has been written with portability in mind and thus it
28    should work on any C-99 system and also on 32 bit C-89 systems.
29
30    2009-10-21 wk  Added -c option.  Switch to GPL-3.  Escape filenames.
31    2009-10-22 wk  Support MD5 and SHA256.
32    2010-04-16 wk  Add option -0.
33 */
34
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <assert.h>
39 #include <errno.h>
40 #ifdef _WIN32
41 # include <fcntl.h>
42 #endif
43
44 #define VERSION "1.2"
45 #if defined(BUILD_MD5SUM)
46 # define PGM "md5sum"
47 # define DIGEST_LENGTH 16
48 #elif defined(BUILD_SHA256SUM)
49 # define PGM "sha256sum"
50 # define DIGEST_LENGTH 32
51 #else /* default  */
52 # define PGM "sha1sum"
53 # define DIGEST_LENGTH 20
54 #endif
55
56
57 /* Offset where the name starts in the file.  */
58 #define NAME_OFFSET (DIGEST_LENGTH*2+2)
59
60
61 /* Figure out a 32 bit unsigned integer type.  */
62 #if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
63 # include <stdint.h>
64 typedef uint32_t u32;
65 #else  /* !ISO C-99 */
66 typedef unsigned int u32;
67 #endif /* !ISO C-99 */
68
69 /* Set to true if this is a big endian host.  Unfortunately there is
70    no portable macro to test for it.  Thus we do a runtime test. */
71 static int big_endian_host;
72
73
74 /*
75  * Rotate a 32 bit integer by n bytes
76  */
77 #if defined(__GNUC__) && defined(__i386__)
78 static inline u32
79 rol( u32 x, int n)
80 {
81         __asm__("roll %%cl,%0"
82                 :"=r" (x)
83                 :"0" (x),"c" (n));
84         return x;
85 }
86 #else
87 #define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
88 #endif
89
90 #ifdef BUILD_SHA256SUM
91 #if defined(__GNUC__) && defined(__i386__)
92 static inline u32
93 ror(u32 x, int n)
94 {
95         __asm__("rorl %%cl,%0"
96                 :"=r" (x)
97                 :"0" (x),"c" (n));
98         return x;
99 }
100 #else
101 #define ror(x,n) ( ((x) >> (n)) | ((x) << (32-(n))) )
102 #endif
103 #endif /*BUILD_SHA256SUM*/
104
105
106 typedef struct 
107 {
108 #if defined(BUILD_MD5SUM)
109   u32 A,B,C,D;
110 #elif defined(BUILD_SHA256SUM)
111   u32  h0,h1,h2,h3,h4,h5,h6,h7;
112 #else /*BUILD_SHA1SUM*/
113   u32  h0,h1,h2,h3,h4;
114 #endif
115   u32  nblocks;
116   unsigned char buf[64];
117   int  count;
118 } DIGEST_CONTEXT;
119
120
121
122 static void
123 digest_init (DIGEST_CONTEXT *hd)
124 {
125 #if defined(BUILD_MD5SUM)
126   hd->A = 0x67452301;
127   hd->B = 0xefcdab89;
128   hd->C = 0x98badcfe;
129   hd->D = 0x10325476;
130 #elif defined(BUILD_SHA256SUM)
131   hd->h0 = 0x6a09e667;
132   hd->h1 = 0xbb67ae85;
133   hd->h2 = 0x3c6ef372;
134   hd->h3 = 0xa54ff53a;
135   hd->h4 = 0x510e527f;
136   hd->h5 = 0x9b05688c;
137   hd->h6 = 0x1f83d9ab;
138   hd->h7 = 0x5be0cd19;
139 #else /*BUILD_SHA1SUM*/
140   hd->h0 = 0x67452301;
141   hd->h1 = 0xefcdab89;
142   hd->h2 = 0x98badcfe;
143   hd->h3 = 0x10325476;
144   hd->h4 = 0xc3d2e1f0;
145 #endif
146   hd->nblocks = 0;
147   hd->count = 0;
148 }
149
150
151 #if defined(BUILD_MD5SUM)
152 /*
153  * MD5 transform the message X which consists of 16 32-bit-words
154  */
155 /* These are the four functions used in the four steps of the MD5
156    algorithm and defined in the RFC 1321.  The first function is a
157    little bit optimized (as found in Colin Plumbs public domain
158    implementation).  */
159 #define FF(b, c, d) (d ^ (b & (c ^ d)))
160 #define FG(b, c, d) FF (d, b, c)
161 #define FH(b, c, d) (b ^ c ^ d)
162 #define FI(b, c, d) (c ^ (b | ~d))
163 static void
164 transform (DIGEST_CONTEXT *hd, unsigned char *data )
165 {
166   u32 correct_words[16];
167   u32 A = hd->A;
168   u32 B = hd->B;
169   u32 C = hd->C;
170   u32 D = hd->D;
171   u32 *cwp = correct_words;
172     
173   if (big_endian_host)
174     { 
175       int i;
176       unsigned char *p2, *p1;
177       for(i=0, p1=data, p2=(unsigned char*)correct_words;
178           i < 16; i++, p2 += 4 )
179         {
180           p2[3] = *p1++;
181           p2[2] = *p1++;
182           p2[1] = *p1++;
183           p2[0] = *p1++;
184         }
185     }
186   else
187     memcpy (correct_words, data, 64);
188
189 #define OP(a, b, c, d, s, T) \
190   do                                       \
191     {                                      \
192       a += FF (b, c, d) + (*cwp++) + T;    \
193       a = rol(a, s);                       \
194       a += b;                              \
195     }                                      \
196   while (0)
197
198   /* Before we start, one word about the strange constants.
199      They are defined in RFC 1321 as
200
201      T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
202   */
203
204   /* Round 1.  */
205   OP (A, B, C, D,  7, 0xd76aa478);
206   OP (D, A, B, C, 12, 0xe8c7b756);
207   OP (C, D, A, B, 17, 0x242070db);
208   OP (B, C, D, A, 22, 0xc1bdceee);
209   OP (A, B, C, D,  7, 0xf57c0faf);
210   OP (D, A, B, C, 12, 0x4787c62a);
211   OP (C, D, A, B, 17, 0xa8304613);
212   OP (B, C, D, A, 22, 0xfd469501);
213   OP (A, B, C, D,  7, 0x698098d8);
214   OP (D, A, B, C, 12, 0x8b44f7af);
215   OP (C, D, A, B, 17, 0xffff5bb1);
216   OP (B, C, D, A, 22, 0x895cd7be);
217   OP (A, B, C, D,  7, 0x6b901122);
218   OP (D, A, B, C, 12, 0xfd987193);
219   OP (C, D, A, B, 17, 0xa679438e);
220   OP (B, C, D, A, 22, 0x49b40821);
221
222 #undef OP
223 #define OP(f, a, b, c, d, k, s, T)  \
224     do                                                                \
225       {                                                               \
226         a += f (b, c, d) + correct_words[k] + T;                      \
227         a = rol(a, s);                                                \
228         a += b;                                                       \
229       }                                                               \
230     while (0)
231
232   /* Round 2.  */
233   OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
234   OP (FG, D, A, B, C,  6,  9, 0xc040b340);
235   OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
236   OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
237   OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
238   OP (FG, D, A, B, C, 10,  9, 0x02441453);
239   OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
240   OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
241   OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
242   OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
243   OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
244   OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
245   OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
246   OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
247   OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
248   OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
249
250   /* Round 3.  */
251   OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
252   OP (FH, D, A, B, C,  8, 11, 0x8771f681);
253   OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
254   OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
255   OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
256   OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
257   OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
258   OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
259   OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
260   OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
261   OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
262   OP (FH, B, C, D, A,  6, 23, 0x04881d05);
263   OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
264   OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
265   OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
266   OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
267
268   /* Round 4.  */
269   OP (FI, A, B, C, D,  0,  6, 0xf4292244);
270   OP (FI, D, A, B, C,  7, 10, 0x432aff97);
271   OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
272   OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
273   OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
274   OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
275   OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
276   OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
277   OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
278   OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
279   OP (FI, C, D, A, B,  6, 15, 0xa3014314);
280   OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
281   OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
282   OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
283   OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
284   OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
285
286   /* Put checksum in context given as argument.  */
287   hd->A += A;
288   hd->B += B;
289   hd->C += C;
290   hd->D += D;
291 }
292
293 #elif defined(BUILD_SHA256SUM)
294 /*
295  * SHA-256 transform the message X which consists of 16 32-bit-words.
296  * See FIPS-180-2 for details.
297  */
298 # define Cho(x,y,z) (z ^ (x & (y ^ z)))      /* (4.2) same as SHA-1's F1 */
299 # define Maj(x,y,z) ((x & y) | (z & (x|y)))  /* (4.3) same as SHA-1's F3 */
300 # define Sum0(x) (ror ((x), 2) ^ ror ((x), 13) ^ ror ((x), 22))  /* (4.4) */
301 # define Sum1(x) (ror ((x), 6) ^ ror ((x), 11) ^ ror ((x), 25))  /* (4.5) */
302 # define S0(x) (ror ((x), 7) ^ ror ((x), 18) ^ ((x) >> 3))       /* (4.6) */
303 # define S1(x) (ror ((x), 17) ^ ror ((x), 19) ^ ((x) >> 10))     /* (4.7) */
304 # define R(a,b,c,d,e,f,g,h,k,w) do                                \
305            {                                                      \
306             t1 = (h) + Sum1((e)) + Cho((e),(f),(g)) + (k) + (w);  \
307             t2 = Sum0((a)) + Maj((a),(b),(c));                    \
308             h = g;                                                \
309             g = f;                                                \
310             f = e;                                                \
311             e = d + t1;                                           \
312             d = c;                                                \
313             c = b;                                                \
314             b = a;                                                \
315             a = t1 + t2;                                          \
316           } while (0)
317 static void
318 transform (DIGEST_CONTEXT *hd, unsigned char *data)
319 {
320   static const u32 K[64] = {
321     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
322     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
323     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
324     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 
325     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
326     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
327     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
328     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
329     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
330     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
331     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
332     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
333     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
334     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
335     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
336     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
337   };
338
339   u32 a,b,c,d,e,f,g,h,t1,t2;
340   u32 x[16];
341   u32 w[64];
342   int i;
343   
344   a = hd->h0;
345   b = hd->h1;
346   c = hd->h2;
347   d = hd->h3;
348   e = hd->h4;
349   f = hd->h5;
350   g = hd->h6;
351   h = hd->h7;
352   
353   if (big_endian_host)
354     memcpy (x, data, 64);
355   else
356     { 
357       unsigned char *p2;
358       
359       for (i=0, p2=(unsigned char*)x; i < 16; i++, p2 += 4 ) 
360         {
361           p2[3] = *data++;
362           p2[2] = *data++;
363           p2[1] = *data++;
364           p2[0] = *data++;
365         }
366     }
367
368   for (i=0; i < 16; i++)
369     w[i] = x[i];
370   for (; i < 64; i++)
371     w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
372
373   for (i=0; i < 64; i++)
374     R(a,b,c,d,e,f,g,h,K[i],w[i]);
375
376   hd->h0 += a;
377   hd->h1 += b;
378   hd->h2 += c;
379   hd->h3 += d;
380   hd->h4 += e;
381   hd->h5 += f;
382   hd->h6 += g;
383   hd->h7 += h;
384 }
385 # undef Cho
386 # undef Maj
387 # undef Sum0
388 # undef Sum1
389 # undef S0
390 # undef S1
391 # undef R
392
393 #else /*BUILD_SHA1SUM*/
394 /*
395  * SHA-1 transform the message X which consists of 16 32-bit-words
396  */
397 static void
398 transform (DIGEST_CONTEXT *hd, unsigned char *data )
399 {
400   u32 a,b,c,d,e,tm;
401   u32 x[16];
402   
403   /* Get values from the chaining vars. */
404   a = hd->h0;
405   b = hd->h1;
406   c = hd->h2;
407   d = hd->h3;
408   e = hd->h4;
409
410   if (big_endian_host)
411     memcpy (x, data, 64);
412   else
413     { 
414       int i;
415       unsigned char *p2;
416       
417       for (i=0, p2=(unsigned char*)x; i < 16; i++, p2 += 4 )
418         {
419           p2[3] = *data++;
420           p2[2] = *data++;
421           p2[1] = *data++;
422           p2[0] = *data++;
423         }
424     }
425   
426 #define K1  0x5A827999L
427 #define K2  0x6ED9EBA1L
428 #define K3  0x8F1BBCDCL
429 #define K4  0xCA62C1D6L
430 #define F1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )
431 #define F2(x,y,z)   ( x ^ y ^ z )
432 #define F3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )
433 #define F4(x,y,z)   ( x ^ y ^ z )
434
435
436 #define M(i) ( tm =   x[i&0x0f] ^ x[(i-14)&0x0f] \
437                     ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f] \
438                , (x[i&0x0f] = rol(tm,1)) )
439
440 #define R(a,b,c,d,e,f,k,m)  do { e += rol( a, 5 )     \
441                                       + f( b, c, d )  \
442                                       + k             \
443                                       + m;            \
444                                  b = rol( b, 30 );    \
445                                } while(0)
446   R( a, b, c, d, e, F1, K1, x[ 0] );
447   R( e, a, b, c, d, F1, K1, x[ 1] );
448   R( d, e, a, b, c, F1, K1, x[ 2] );
449   R( c, d, e, a, b, F1, K1, x[ 3] );
450   R( b, c, d, e, a, F1, K1, x[ 4] );
451   R( a, b, c, d, e, F1, K1, x[ 5] );
452   R( e, a, b, c, d, F1, K1, x[ 6] );
453   R( d, e, a, b, c, F1, K1, x[ 7] );
454   R( c, d, e, a, b, F1, K1, x[ 8] );
455   R( b, c, d, e, a, F1, K1, x[ 9] );
456   R( a, b, c, d, e, F1, K1, x[10] );
457   R( e, a, b, c, d, F1, K1, x[11] );
458   R( d, e, a, b, c, F1, K1, x[12] );
459   R( c, d, e, a, b, F1, K1, x[13] );
460   R( b, c, d, e, a, F1, K1, x[14] );
461   R( a, b, c, d, e, F1, K1, x[15] );
462   R( e, a, b, c, d, F1, K1, M(16) );
463   R( d, e, a, b, c, F1, K1, M(17) );
464   R( c, d, e, a, b, F1, K1, M(18) );
465   R( b, c, d, e, a, F1, K1, M(19) );
466   R( a, b, c, d, e, F2, K2, M(20) );
467   R( e, a, b, c, d, F2, K2, M(21) );
468   R( d, e, a, b, c, F2, K2, M(22) );
469   R( c, d, e, a, b, F2, K2, M(23) );
470   R( b, c, d, e, a, F2, K2, M(24) );
471   R( a, b, c, d, e, F2, K2, M(25) );
472   R( e, a, b, c, d, F2, K2, M(26) );
473   R( d, e, a, b, c, F2, K2, M(27) );
474   R( c, d, e, a, b, F2, K2, M(28) );
475   R( b, c, d, e, a, F2, K2, M(29) );
476   R( a, b, c, d, e, F2, K2, M(30) );
477   R( e, a, b, c, d, F2, K2, M(31) );
478   R( d, e, a, b, c, F2, K2, M(32) );
479   R( c, d, e, a, b, F2, K2, M(33) );
480   R( b, c, d, e, a, F2, K2, M(34) );
481   R( a, b, c, d, e, F2, K2, M(35) );
482   R( e, a, b, c, d, F2, K2, M(36) );
483   R( d, e, a, b, c, F2, K2, M(37) );
484   R( c, d, e, a, b, F2, K2, M(38) );
485   R( b, c, d, e, a, F2, K2, M(39) );
486   R( a, b, c, d, e, F3, K3, M(40) );
487   R( e, a, b, c, d, F3, K3, M(41) );
488   R( d, e, a, b, c, F3, K3, M(42) );
489   R( c, d, e, a, b, F3, K3, M(43) );
490   R( b, c, d, e, a, F3, K3, M(44) );
491   R( a, b, c, d, e, F3, K3, M(45) );
492   R( e, a, b, c, d, F3, K3, M(46) );
493   R( d, e, a, b, c, F3, K3, M(47) );
494   R( c, d, e, a, b, F3, K3, M(48) );
495   R( b, c, d, e, a, F3, K3, M(49) );
496   R( a, b, c, d, e, F3, K3, M(50) );
497   R( e, a, b, c, d, F3, K3, M(51) );
498   R( d, e, a, b, c, F3, K3, M(52) );
499   R( c, d, e, a, b, F3, K3, M(53) );
500   R( b, c, d, e, a, F3, K3, M(54) );
501   R( a, b, c, d, e, F3, K3, M(55) );
502   R( e, a, b, c, d, F3, K3, M(56) );
503   R( d, e, a, b, c, F3, K3, M(57) );
504   R( c, d, e, a, b, F3, K3, M(58) );
505   R( b, c, d, e, a, F3, K3, M(59) );
506   R( a, b, c, d, e, F4, K4, M(60) );
507   R( e, a, b, c, d, F4, K4, M(61) );
508   R( d, e, a, b, c, F4, K4, M(62) );
509   R( c, d, e, a, b, F4, K4, M(63) );
510   R( b, c, d, e, a, F4, K4, M(64) );
511   R( a, b, c, d, e, F4, K4, M(65) );
512   R( e, a, b, c, d, F4, K4, M(66) );
513   R( d, e, a, b, c, F4, K4, M(67) );
514   R( c, d, e, a, b, F4, K4, M(68) );
515   R( b, c, d, e, a, F4, K4, M(69) );
516   R( a, b, c, d, e, F4, K4, M(70) );
517   R( e, a, b, c, d, F4, K4, M(71) );
518   R( d, e, a, b, c, F4, K4, M(72) );
519   R( c, d, e, a, b, F4, K4, M(73) );
520   R( b, c, d, e, a, F4, K4, M(74) );
521   R( a, b, c, d, e, F4, K4, M(75) );
522   R( e, a, b, c, d, F4, K4, M(76) );
523   R( d, e, a, b, c, F4, K4, M(77) );
524   R( c, d, e, a, b, F4, K4, M(78) );
525   R( b, c, d, e, a, F4, K4, M(79) );
526
527   /* Update chaining vars.  */
528   hd->h0 += a;
529   hd->h1 += b;
530   hd->h2 += c;
531   hd->h3 += d;
532   hd->h4 += e;
533 }
534
535 #endif /*BUILD_SHA1SUM*/
536
537
538 /* Update the message digest with the contents of (DATA,DATALEN).  */
539 static void
540 digest_write (DIGEST_CONTEXT *hd, void *data, size_t datalen)
541 {
542   unsigned char *inbuf = data;
543
544   if (hd->count == 64) /* Flush the buffer.  */
545     {
546       transform ( hd, hd->buf );
547       hd->count = 0;
548       hd->nblocks++;
549     }
550   if ( !inbuf )
551     return;
552   if ( hd->count ) 
553     {
554       for ( ; datalen && hd->count < 64; datalen-- )
555         hd->buf[hd->count++] = *inbuf++;
556       digest_write( hd, NULL, 0 );
557       if ( !datalen )
558         return;
559     }
560   
561   while( datalen >= 64 ) 
562     {
563       transform( hd, inbuf );
564       hd->count = 0;
565       hd->nblocks++;
566       datalen -= 64;
567       inbuf += 64;
568     }
569   for( ; datalen && hd->count < 64; datalen-- )
570     hd->buf[hd->count++] = *inbuf++;
571 }
572
573
574 /* The routine final terminates the computation and
575  * returns the digest.
576  * The handle is prepared for a new cycle, but adding bytes to the
577  * handle will the destroy the returned buffer.
578  * Returns: DIGEST_LENGTH bytes representing the digest.
579  */
580
581 static void
582 digest_final(DIGEST_CONTEXT *hd)
583 {
584   u32 t, msb, lsb;
585   unsigned char *p;
586   
587   digest_write(hd, NULL, 0); /* Flush */;
588   
589   t = hd->nblocks;
590   /* Multiply by 64 to make a byte count.  */
591   lsb = t << 6;
592   msb = t >> 26;
593   /* Add the count.  */
594   t = lsb;
595   if ( (lsb += hd->count) < t )
596     msb++;
597   /* Multiply by 8 to make a bit count. */
598   t = lsb;
599   lsb <<= 3;
600   msb <<= 3;
601   msb |= t >> 29;
602
603   if ( hd->count < 56 ) /* Enough room is available. */
604     {
605       hd->buf[hd->count++] = 0x80; /* pad */
606       while( hd->count < 56 )
607         hd->buf[hd->count++] = 0;  /* pad */
608     }
609   else /* Need one extra block.  */
610     {
611       hd->buf[hd->count++] = 0x80; /* pad character */
612       while ( hd->count < 64 )
613         hd->buf[hd->count++] = 0;
614       digest_write (hd, NULL, 0);  /* Flush */;
615       memset(hd->buf, 0, 56 );     /* Fill next block with zeroes.  */
616     }
617   /* Append the 64 bit count. */
618 #if defined(BUILD_MD5SUM)
619   hd->buf[56] = lsb;
620   hd->buf[57] = lsb >>  8;
621   hd->buf[58] = lsb >> 16;
622   hd->buf[59] = lsb >> 24;
623   hd->buf[60] = msb;
624   hd->buf[61] = msb >>  8;
625   hd->buf[62] = msb >> 16;
626   hd->buf[63] = msb >> 24;
627 #else
628   hd->buf[56] = msb >> 24;
629   hd->buf[57] = msb >> 16;
630   hd->buf[58] = msb >>  8;
631   hd->buf[59] = msb;
632   hd->buf[60] = lsb >> 24;
633   hd->buf[61] = lsb >> 16;
634   hd->buf[62] = lsb >>  8;
635   hd->buf[63] = lsb;
636 #endif
637
638   transform( hd, hd->buf );
639   p = hd->buf;
640 #if defined(BUILD_MD5SUM)
641 #define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
642                   *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
643   X(A);
644   X(B);
645   X(C);
646   X(D);
647 #else /* Not MD5 */
648 # define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;         \
649                    *p++ = hd->h##a >> 8;  *p++ = hd->h##a; } while(0)
650   X(0);
651   X(1);
652   X(2);
653   X(3);
654   X(4);
655 # if defined(BUILD_SHA256SUM) 
656   X(5);
657   X(6);
658   X(7);
659 # endif /*BUILD_SHA256SUM*/
660 #endif /*BUILD_SHA1SUM*/
661 #undef X
662 }
663
664 \f
665 /* Stats for the check fucntion.  */
666 static unsigned int filecount;
667 static unsigned int readerrors;
668 static unsigned int checkcount;
669 static unsigned int matcherrors;
670
671 /* We need to escape the fname so that included linefeeds etc don't
672    mess up the the output file.  On windows we also turn backslashes
673    into slashes so that we don't get into conflicts with the escape
674    character.  Note that the GNU version escapes the backslash and the
675    LF but we also escape the CR.  */
676 static char *
677 escapefname (const char *fname, int *escaped)
678 {
679   const char *s;
680   char *buffer;
681   char *d;
682   size_t n;
683
684   *escaped = 0;
685   for (n = 0, s = fname; *s; s++)
686     {
687       if (*s == '\n' || *s == '\r')
688         n += 2;
689       else if (*s == '\\')
690         {
691 #ifdef _WIN32
692           n++;
693 #else
694           n += 2;
695 #endif
696         }
697       else
698         n++;
699     }
700   n++;
701   buffer = malloc (n);
702   if (!buffer)
703     {
704       fprintf (stderr, PGM": can't allocate buffer: %s\n", strerror (errno));
705       exit (2);
706     }
707
708   d = buffer;
709   for (s = fname; *s; s++)
710     {
711       if (*s == '\n')
712         { 
713           *d++ = '\\';
714           *d++ = 'n' ;
715           *escaped = 1;
716         }
717       else if (*s == '\r')
718         {
719           *d++ = '\\';
720           *d++ = 'r' ;
721           *escaped = 1;
722         }
723       else if (*s == '\\')
724         {
725 #ifdef _WIN32
726           *d++ = '/';
727 #else
728           *d++ = '\\';
729           *d++ = '\\' ;
730           *escaped = 1;
731 #endif
732         }
733       else
734         *d++ = *s;
735     }
736   *d = 0;
737   return buffer;
738 }
739
740
741 /* Revert the escaping in-place.  We handle some more of the standard
742    escaping characters but not all. */
743 static void
744 unescapefname (char *fname)
745 {
746   char *s, *d;
747
748   for (s=d=fname; *s; s++)
749     {
750       if (*s == '\\' && s[1])
751         {
752           s++;
753           switch (*s)
754             {
755             case '\\': *d++ = '\\'; break;
756             case 'n': *d++ = '\n'; break;
757             case 'r': *d++ = '\r'; break;
758             case 'f': *d++ = '\f'; break;
759             case 'v': *d++ = '\v'; break;
760             case 'b': *d++ = '\b'; break;
761             default: *d++ = '\\'; *d++ = *s; break;
762             }
763         }
764       else
765         *d++ = *s;
766     }
767   *d = 0;
768 }
769
770
771
772 static int
773 hash_file (const char *fname, const char *expected)
774 {
775   FILE *fp;
776   char buffer[4096];
777   size_t n;
778   DIGEST_CONTEXT ctx;
779   int i;
780   char *fnamebuf;
781   int escaped;
782
783   filecount++;
784   if (!expected && *fname == '-' && !fname[1])
785     {
786       /* Not in check mode and asked to read from stdin.  */
787       fp = stdin;
788 #ifdef _WIN32
789       setmode (fileno (fp), O_BINARY);
790 #endif
791     }
792   else
793     fp = fopen (fname, "rb");
794   if (!fp)
795     {
796       fprintf (stderr, PGM": can't open `%s': %s\n",
797                fname, strerror (errno));
798       if (expected)
799         printf ("%s: FAILED open\n", fname);
800       readerrors++;
801       return -1;
802     }
803   digest_init (&ctx);
804   while ( (n = fread (buffer, 1, sizeof buffer, fp)))
805     digest_write (&ctx, buffer, n);
806   if (ferror (fp))
807     {
808       fprintf (stderr, PGM": error reading `%s': %s\n",
809                fname, strerror (errno));
810       if (fp != stdin)
811         fclose (fp);
812       if (expected)
813         printf ("%s: FAILED read\n", fname);
814       readerrors++;
815       return -1;
816     }
817   digest_final (&ctx);
818   if (fp != stdin)
819     fclose (fp);
820   
821   fnamebuf = escapefname (fname, &escaped);
822   fname = fnamebuf;
823
824   checkcount++;
825   for (i=0; i < DIGEST_LENGTH; i++)
826     snprintf (buffer+2*i, 10, "%02x", ctx.buf[i]);
827   if (expected)
828     {
829       if (strcmp (buffer, expected))
830         {
831           printf ("%s: FAILED\n", fname);
832           matcherrors++;
833           return -1;
834         }
835       printf ("%s: OK\n", fname);
836     }
837   else
838     printf ("%s%s  %s\n", escaped? "\\":"", buffer, fname);
839   free (fnamebuf);
840   return 0;
841 }
842
843
844 static int
845 check_file (const char *fname)
846 {
847   FILE *fp;
848   char linebuf[4096];
849   char *line;
850   char *p;
851   size_t n;
852   int rc = 0;
853   int escaped;
854       
855   if (*fname == '-' && !fname[1])
856     fp = stdin;
857   else
858     fp = fopen (fname, "r");
859   if (!fp)
860     {
861       fprintf (stderr, PGM": can't open `%s': %s\n",
862                fname, strerror (errno));
863       return -1;
864     }
865
866   while ( fgets (linebuf, sizeof (linebuf)-1, fp) )
867     {
868       escaped = (*linebuf == '\\'); 
869       line = linebuf + escaped;
870       n = strlen(line);
871       if (!n || line[n-1] != '\n')
872         {
873           fprintf (stderr, PGM": error reading `%s': %s\n", fname,
874                    feof (fp)? "last linefeed missing":"line too long");
875           rc = -1;
876           break;
877         }
878       line[--n] = 0;
879       if (n && line[n-1] == '\r')
880         line[--n] = 0;
881       if (!*line)
882         continue;  /* Ignore empty lines.  */
883       if (n < NAME_OFFSET || line[NAME_OFFSET-2] != ' ')
884         {
885           fprintf (stderr, PGM": error parsing `%s': %s\n", fname,
886                    "invalid line");
887           rc = -1;
888           continue;
889         }
890       
891       /* Note that we ignore the binary flag ('*') used by GNU
892          versions of this tool: It does not make sense to compute a
893          digest over some transformation of a file - we always want a
894          reliable checksum.  The flag does not work: On Unix a
895          checksum file is created without the flag because it is the
896          default there.  When checking it on Windows the missing flag
897          would indicate that it has been created in text mode and thus
898          the checksums will differ.  */
899
900       /* Lowercase the checksum.  */
901       line[NAME_OFFSET-2] = 0;
902       for (p=line; *p; p++)
903         if (*p >= 'A' && *p <= 'Z')
904           *p |= 0x20;
905       /* Unescape the fname.  */
906       if (escaped)
907         unescapefname (line+NAME_OFFSET);
908       /* Hash the file.  */
909       if (hash_file (line+NAME_OFFSET, line))
910         rc = -1;
911     }
912
913   if (ferror (fp))
914     {
915       fprintf (stderr, PGM":error reading `%s': %s\n",
916                fname, strerror (errno));
917       rc = -1;
918     }
919   if (fp != stdin)
920     fclose (fp);
921   
922   return rc;
923 }
924
925
926 static int
927 hash_list (void)
928 {
929   int rc = 0;
930   int ready = 0;
931   int c;
932   char namebuf[4096];
933   size_t n = 0;
934   unsigned long lastoff = 0;
935   unsigned long off = 0;
936
937 #ifdef _WIN32
938   setmode (fileno (stdin), O_BINARY);
939 #endif
940   do
941     {
942       if ((c = getc (stdin)) == EOF)
943         {
944           if (ferror (stdin))
945             {
946               fprintf (stderr, PGM":error reading `%s' at offset %lu: %s\n",
947                        "[stdin]", off, strerror (errno));
948               rc = -1;
949               break;
950             }
951           /* Note: The Nul is a delimter and not a terminator.  */
952           c = 0;
953           ready = 1;
954         }
955       if (n >= sizeof namebuf)
956         {
957           fprintf (stderr, PGM": error reading `%s': "
958                    "filename at offset %lu too long\n",
959                    "[stdin]", lastoff);
960           rc = -1;
961           break;
962         }
963       namebuf[n++] = c;
964       off++;
965       if (!c)
966         {
967           if (*namebuf && hash_file (namebuf, NULL))
968             rc = -1;
969           n = 0;
970           lastoff = off;
971         }
972     }
973   while (!ready);
974   
975   return rc;
976 }
977
978
979 static void
980 usage (void)
981 {
982   fprintf (stderr, "usage: sha1sum [-c|-0] [--] FILENAMES|-\n");
983   exit (1);
984 }
985
986 int 
987 main (int argc, char **argv)
988 {
989   int check = 0;
990   int filelist = 0;
991   int rc = 0;
992
993   assert (sizeof (u32) == 4);
994   {
995     union { u32 u; char b[4]; } foo;
996     foo.u = 32;
997     big_endian_host = !foo.b[0];
998   }
999
1000   if (argc)
1001     {
1002       argc--; argv++; 
1003     }
1004
1005   if (argc && !strcmp (*argv, "--version"))
1006     {
1007       fputs (PGM " "VERSION"\n"
1008              "Copyright (C) 2009 g10 Code GmbH\n"
1009              "License GPLv3+: GNU GPL version 3 or later "
1010              "<http://gnu.org/licenses/gpl.html>.\n"
1011              "This is free software: you are free to change "
1012              "and redistribute it.\n"
1013              "There is NO WARRANTY, to the extent permitted by law.\n\n",
1014              stdout);
1015       exit (0);
1016     }
1017   while (argc && argv[0][0] == '-' && argv[0][1])
1018     {
1019       if (!strcmp (*argv, "-c"))
1020         check = 1;
1021       else if (argc && !strcmp (*argv, "-0"))
1022         filelist = 1;
1023       else if (!strcmp (*argv, "--"))
1024         {
1025           argc--; argv++;
1026           break;
1027         }
1028       else
1029         usage ();
1030       argc--; argv++;
1031     }
1032
1033   if (filelist && check)
1034     usage ();
1035   if (!argc)
1036     usage ();
1037
1038   if (filelist)
1039     {
1040       /* With option -0 a dash must be given as filename.  */
1041       if (argc != 1 || strcmp (argv[0], "-"))
1042         usage ();
1043       if (hash_list ())
1044         rc = 1;
1045     }
1046   else
1047     {
1048       for (; argc; argv++, argc--)
1049         {
1050           if (check)
1051             {
1052               if (check_file (*argv))
1053                 rc = 1;
1054             }
1055           else
1056             {
1057               if (hash_file (*argv, NULL))
1058                 rc = 1;
1059             }
1060         }
1061     }
1062
1063   if (check && readerrors)
1064     fprintf (stderr, PGM": WARNING: %u of %u listed files "
1065              "could not be read\n", readerrors, filecount);
1066   if (check && matcherrors)
1067     fprintf (stderr, PGM": WARNING: %u of %u computed checksums "
1068              "did NOT match\n", matcherrors, checkcount);
1069
1070   return rc;
1071 }
1072
1073 /*
1074 Local Variables:
1075 compile-command: "cc -Wall -g -o sha1sum sha1sum.c"
1076 End:
1077 */