1 /*-
2  * Copyright (c) 2001-2003 Allan Saddi <allan@saddi.com>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY ALLAN SADDI AND HIS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL ALLAN SADDI OR HIS CONTRIBUTORS BE
18  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
24  * POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $Id: sha1.c,v 1.3 2005/05/13 18:52:06 harbourn Exp $
27  */
28 
29 /*
30  * Define WORDS_BIGENDIAN if compiling on a big-endian architecture.
31  *
32  * Define SHA1_TEST to test the implementation using the NIST's
33  * sample messages. The output should be:
34  *
35  *   a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d
36  *   84983e44 1c3bd26e baae4aa1 f95129e5 e54670f1
37  *   34aa973c d4c4daa4 f61eeb2b dbad2731 6534016f
38  */
39 
40 #ifdef HAVE_CONFIG_H
41 #include <config.h>
42 #endif /* HAVE_CONFIG_H */
43 
44 #if HAVE_INTTYPES_H
45 # include <inttypes.h>
46 #else
47 # if HAVE_STDINT_H
48 #  include <stdint.h>
49 # endif
50 #endif
51 
52 #include <string.h>
53 
54 #include "sha1.h"
55 
56 #ifndef lint
57 static const char rcsid[] =
58 	"$Id: sha1.c,v 1.3 2005/05/13 18:52:06 harbourn Exp $";
59 #endif /* !lint */
60 
61 #define ROTL(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
62 #define ROTR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
63 
64 #define F_0_19(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
65 #define F_20_39(x, y, z) ((x) ^ (y) ^ (z))
66 #define F_40_59(x, y, z) (((x) & ((y) | (z))) | ((y) & (z)))
67 #define F_60_79(x, y, z) ((x) ^ (y) ^ (z))
68 
69 #define DO_ROUND(F, K) { \
70   temp = ROTL(a, 5) + F(b, c, d) + e + *(W++) + K; \
71   e = d; \
72   d = c; \
73   c = ROTL(b, 30); \
74   b = a; \
75   a = temp; \
76 }
77 
78 #define K_0_19 0x5a827999L
79 #define K_20_39 0x6ed9eba1L
80 #define K_40_59 0x8f1bbcdcL
81 #define K_60_79 0xca62c1d6L
82 
83 #ifndef RUNTIME_ENDIAN
84 
85 #ifdef WORDS_BIGENDIAN
86 
87 #define BYTESWAP(x) (x)
88 #define BYTESWAP64(x) (x)
89 
90 #else /* WORDS_BIGENDIAN */
91 
92 #define BYTESWAP(x) ((ROTR((x), 8) & 0xff00ff00L) | \
93 		     (ROTL((x), 8) & 0x00ff00ffL))
94 #define BYTESWAP64(x) _byteswap64(x)
95 
_byteswap64(uint64_t x)96 static inline uint64_t _byteswap64(uint64_t x)
97 {
98   uint32_t a = x >> 32;
99   uint32_t b = (uint32_t) x;
100   return ((uint64_t) BYTESWAP(b) << 32) | (uint64_t) BYTESWAP(a);
101 }
102 
103 #endif /* WORDS_BIGENDIAN */
104 
105 #else /* !RUNTIME_ENDIAN */
106 
107 #define BYTESWAP(x) _byteswap(sc->littleEndian, x)
108 #define BYTESWAP64(x) _byteswap64(sc->littleEndian, x)
109 
110 #define _BYTESWAP(x) ((ROTR((x), 8) & 0xff00ff00L) | \
111 		      (ROTL((x), 8) & 0x00ff00ffL))
112 #define _BYTESWAP64(x) __byteswap64(x)
113 
__byteswap64(uint64_t x)114 static inline uint64_t __byteswap64(uint64_t x)
115 {
116   uint32_t a = x >> 32;
117   uint32_t b = (uint32_t) x;
118   return ((uint64_t) _BYTESWAP(b) << 32) | (uint64_t) _BYTESWAP(a);
119 }
120 
_byteswap(int littleEndian,uint32_t x)121 static inline uint32_t _byteswap(int littleEndian, uint32_t x)
122 {
123   if (!littleEndian)
124     return x;
125   else
126     return _BYTESWAP(x);
127 }
128 
_byteswap64(int littleEndian,uint64_t x)129 static inline uint64_t _byteswap64(int littleEndian, uint64_t x)
130 {
131   if (!littleEndian)
132     return x;
133   else
134     return _BYTESWAP64(x);
135 }
136 
setEndian(int * littleEndianp)137 static inline void setEndian(int *littleEndianp)
138 {
139   union {
140     uint32_t w;
141     uint8_t b[4];
142   } endian;
143 
144   endian.w = 1L;
145   *littleEndianp = endian.b[0] != 0;
146 }
147 
148 #endif /* !RUNTIME_ENDIAN */
149 
150 static const uint8_t padding[64] = {
151   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
152   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
153   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
154   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
155   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
156   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
157   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
158   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
159 };
160 
161 void
SHA1Init(SHA1Context * sc)162 SHA1Init (SHA1Context *sc)
163 {
164 #ifdef RUNTIME_ENDIAN
165   setEndian (&sc->littleEndian);
166 #endif /* RUNTIME_ENDIAN */
167 
168   sc->totalLength = 0LL;
169   sc->hash[0] = 0x67452301L;
170   sc->hash[1] = 0xefcdab89L;
171   sc->hash[2] = 0x98badcfeL;
172   sc->hash[3] = 0x10325476L;
173   sc->hash[4] = 0xc3d2e1f0L;
174   sc->bufferLength = 0L;
175 }
176 
177 static void
burnStack(int size)178 burnStack (int size)
179 {
180   char buf[128];
181 
182   memset (buf, 0, sizeof (buf));
183   size -= sizeof (buf);
184   if (size > 0)
185     burnStack (size);
186 }
187 
188 static void
SHA1Guts(SHA1Context * sc,const uint32_t * cbuf)189 SHA1Guts (SHA1Context *sc, const uint32_t *cbuf)
190 {
191   uint32_t buf[80];
192   uint32_t *W, *W3, *W8, *W14, *W16;
193   uint32_t a, b, c, d, e, temp;
194   int i;
195 
196   W = buf;
197 
198   for (i = 15; i >= 0; i--) {
199     *(W++) = BYTESWAP(*cbuf);
200     cbuf++;
201   }
202 
203   W16 = &buf[0];
204   W14 = &buf[2];
205   W8 = &buf[8];
206   W3 = &buf[13];
207 
208   for (i = 63; i >= 0; i--) {
209     *W = *(W3++) ^ *(W8++) ^ *(W14++) ^ *(W16++);
210     *W = ROTL(*W, 1);
211     W++;
212   }
213 
214   a = sc->hash[0];
215   b = sc->hash[1];
216   c = sc->hash[2];
217   d = sc->hash[3];
218   e = sc->hash[4];
219 
220   W = buf;
221 
222 #ifndef SHA1_UNROLL
223 #define SHA1_UNROLL 20
224 #endif /* !SHA1_UNROLL */
225 
226 #if SHA1_UNROLL == 1
227   for (i = 19; i >= 0; i--)
228     DO_ROUND(F_0_19, K_0_19);
229 
230   for (i = 19; i >= 0; i--)
231     DO_ROUND(F_20_39, K_20_39);
232 
233   for (i = 19; i >= 0; i--)
234     DO_ROUND(F_40_59, K_40_59);
235 
236   for (i = 19; i >= 0; i--)
237     DO_ROUND(F_60_79, K_60_79);
238 #elif SHA1_UNROLL == 2
239   for (i = 9; i >= 0; i--) {
240     DO_ROUND(F_0_19, K_0_19);
241     DO_ROUND(F_0_19, K_0_19);
242   }
243 
244   for (i = 9; i >= 0; i--) {
245     DO_ROUND(F_20_39, K_20_39);
246     DO_ROUND(F_20_39, K_20_39);
247   }
248 
249   for (i = 9; i >= 0; i--) {
250     DO_ROUND(F_40_59, K_40_59);
251     DO_ROUND(F_40_59, K_40_59);
252   }
253 
254   for (i = 9; i >= 0; i--) {
255     DO_ROUND(F_60_79, K_60_79);
256     DO_ROUND(F_60_79, K_60_79);
257   }
258 #elif SHA1_UNROLL == 4
259   for (i = 4; i >= 0; i--) {
260     DO_ROUND(F_0_19, K_0_19);
261     DO_ROUND(F_0_19, K_0_19);
262     DO_ROUND(F_0_19, K_0_19);
263     DO_ROUND(F_0_19, K_0_19);
264   }
265 
266   for (i = 4; i >= 0; i--) {
267     DO_ROUND(F_20_39, K_20_39);
268     DO_ROUND(F_20_39, K_20_39);
269     DO_ROUND(F_20_39, K_20_39);
270     DO_ROUND(F_20_39, K_20_39);
271   }
272 
273   for (i = 4; i >= 0; i--) {
274     DO_ROUND(F_40_59, K_40_59);
275     DO_ROUND(F_40_59, K_40_59);
276     DO_ROUND(F_40_59, K_40_59);
277     DO_ROUND(F_40_59, K_40_59);
278   }
279 
280   for (i = 4; i >= 0; i--) {
281     DO_ROUND(F_60_79, K_60_79);
282     DO_ROUND(F_60_79, K_60_79);
283     DO_ROUND(F_60_79, K_60_79);
284     DO_ROUND(F_60_79, K_60_79);
285   }
286 #elif SHA1_UNROLL == 5
287   for (i = 3; i >= 0; i--) {
288     DO_ROUND(F_0_19, K_0_19);
289     DO_ROUND(F_0_19, K_0_19);
290     DO_ROUND(F_0_19, K_0_19);
291     DO_ROUND(F_0_19, K_0_19);
292     DO_ROUND(F_0_19, K_0_19);
293   }
294 
295   for (i = 3; i >= 0; i--) {
296     DO_ROUND(F_20_39, K_20_39);
297     DO_ROUND(F_20_39, K_20_39);
298     DO_ROUND(F_20_39, K_20_39);
299     DO_ROUND(F_20_39, K_20_39);
300     DO_ROUND(F_20_39, K_20_39);
301   }
302 
303   for (i = 3; i >= 0; i--) {
304     DO_ROUND(F_40_59, K_40_59);
305     DO_ROUND(F_40_59, K_40_59);
306     DO_ROUND(F_40_59, K_40_59);
307     DO_ROUND(F_40_59, K_40_59);
308     DO_ROUND(F_40_59, K_40_59);
309   }
310 
311   for (i = 3; i >= 0; i--) {
312     DO_ROUND(F_60_79, K_60_79);
313     DO_ROUND(F_60_79, K_60_79);
314     DO_ROUND(F_60_79, K_60_79);
315     DO_ROUND(F_60_79, K_60_79);
316     DO_ROUND(F_60_79, K_60_79);
317   }
318 #elif SHA1_UNROLL == 10
319   for (i = 1; i >= 0; i--) {
320     DO_ROUND(F_0_19, K_0_19);
321     DO_ROUND(F_0_19, K_0_19);
322     DO_ROUND(F_0_19, K_0_19);
323     DO_ROUND(F_0_19, K_0_19);
324     DO_ROUND(F_0_19, K_0_19);
325     DO_ROUND(F_0_19, K_0_19);
326     DO_ROUND(F_0_19, K_0_19);
327     DO_ROUND(F_0_19, K_0_19);
328     DO_ROUND(F_0_19, K_0_19);
329     DO_ROUND(F_0_19, K_0_19);
330   }
331 
332   for (i = 1; i >= 0; i--) {
333     DO_ROUND(F_20_39, K_20_39);
334     DO_ROUND(F_20_39, K_20_39);
335     DO_ROUND(F_20_39, K_20_39);
336     DO_ROUND(F_20_39, K_20_39);
337     DO_ROUND(F_20_39, K_20_39);
338     DO_ROUND(F_20_39, K_20_39);
339     DO_ROUND(F_20_39, K_20_39);
340     DO_ROUND(F_20_39, K_20_39);
341     DO_ROUND(F_20_39, K_20_39);
342     DO_ROUND(F_20_39, K_20_39);
343   }
344 
345   for (i = 1; i >= 0; i--) {
346     DO_ROUND(F_40_59, K_40_59);
347     DO_ROUND(F_40_59, K_40_59);
348     DO_ROUND(F_40_59, K_40_59);
349     DO_ROUND(F_40_59, K_40_59);
350     DO_ROUND(F_40_59, K_40_59);
351     DO_ROUND(F_40_59, K_40_59);
352     DO_ROUND(F_40_59, K_40_59);
353     DO_ROUND(F_40_59, K_40_59);
354     DO_ROUND(F_40_59, K_40_59);
355     DO_ROUND(F_40_59, K_40_59);
356   }
357 
358   for (i = 1; i >= 0; i--) {
359     DO_ROUND(F_60_79, K_60_79);
360     DO_ROUND(F_60_79, K_60_79);
361     DO_ROUND(F_60_79, K_60_79);
362     DO_ROUND(F_60_79, K_60_79);
363     DO_ROUND(F_60_79, K_60_79);
364     DO_ROUND(F_60_79, K_60_79);
365     DO_ROUND(F_60_79, K_60_79);
366     DO_ROUND(F_60_79, K_60_79);
367     DO_ROUND(F_60_79, K_60_79);
368     DO_ROUND(F_60_79, K_60_79);
369   }
370 #elif SHA1_UNROLL == 20
371   DO_ROUND(F_0_19, K_0_19);
372   DO_ROUND(F_0_19, K_0_19);
373   DO_ROUND(F_0_19, K_0_19);
374   DO_ROUND(F_0_19, K_0_19);
375   DO_ROUND(F_0_19, K_0_19);
376   DO_ROUND(F_0_19, K_0_19);
377   DO_ROUND(F_0_19, K_0_19);
378   DO_ROUND(F_0_19, K_0_19);
379   DO_ROUND(F_0_19, K_0_19);
380   DO_ROUND(F_0_19, K_0_19);
381   DO_ROUND(F_0_19, K_0_19);
382   DO_ROUND(F_0_19, K_0_19);
383   DO_ROUND(F_0_19, K_0_19);
384   DO_ROUND(F_0_19, K_0_19);
385   DO_ROUND(F_0_19, K_0_19);
386   DO_ROUND(F_0_19, K_0_19);
387   DO_ROUND(F_0_19, K_0_19);
388   DO_ROUND(F_0_19, K_0_19);
389   DO_ROUND(F_0_19, K_0_19);
390   DO_ROUND(F_0_19, K_0_19);
391 
392   DO_ROUND(F_20_39, K_20_39);
393   DO_ROUND(F_20_39, K_20_39);
394   DO_ROUND(F_20_39, K_20_39);
395   DO_ROUND(F_20_39, K_20_39);
396   DO_ROUND(F_20_39, K_20_39);
397   DO_ROUND(F_20_39, K_20_39);
398   DO_ROUND(F_20_39, K_20_39);
399   DO_ROUND(F_20_39, K_20_39);
400   DO_ROUND(F_20_39, K_20_39);
401   DO_ROUND(F_20_39, K_20_39);
402   DO_ROUND(F_20_39, K_20_39);
403   DO_ROUND(F_20_39, K_20_39);
404   DO_ROUND(F_20_39, K_20_39);
405   DO_ROUND(F_20_39, K_20_39);
406   DO_ROUND(F_20_39, K_20_39);
407   DO_ROUND(F_20_39, K_20_39);
408   DO_ROUND(F_20_39, K_20_39);
409   DO_ROUND(F_20_39, K_20_39);
410   DO_ROUND(F_20_39, K_20_39);
411   DO_ROUND(F_20_39, K_20_39);
412 
413   DO_ROUND(F_40_59, K_40_59);
414   DO_ROUND(F_40_59, K_40_59);
415   DO_ROUND(F_40_59, K_40_59);
416   DO_ROUND(F_40_59, K_40_59);
417   DO_ROUND(F_40_59, K_40_59);
418   DO_ROUND(F_40_59, K_40_59);
419   DO_ROUND(F_40_59, K_40_59);
420   DO_ROUND(F_40_59, K_40_59);
421   DO_ROUND(F_40_59, K_40_59);
422   DO_ROUND(F_40_59, K_40_59);
423   DO_ROUND(F_40_59, K_40_59);
424   DO_ROUND(F_40_59, K_40_59);
425   DO_ROUND(F_40_59, K_40_59);
426   DO_ROUND(F_40_59, K_40_59);
427   DO_ROUND(F_40_59, K_40_59);
428   DO_ROUND(F_40_59, K_40_59);
429   DO_ROUND(F_40_59, K_40_59);
430   DO_ROUND(F_40_59, K_40_59);
431   DO_ROUND(F_40_59, K_40_59);
432   DO_ROUND(F_40_59, K_40_59);
433 
434   DO_ROUND(F_60_79, K_60_79);
435   DO_ROUND(F_60_79, K_60_79);
436   DO_ROUND(F_60_79, K_60_79);
437   DO_ROUND(F_60_79, K_60_79);
438   DO_ROUND(F_60_79, K_60_79);
439   DO_ROUND(F_60_79, K_60_79);
440   DO_ROUND(F_60_79, K_60_79);
441   DO_ROUND(F_60_79, K_60_79);
442   DO_ROUND(F_60_79, K_60_79);
443   DO_ROUND(F_60_79, K_60_79);
444   DO_ROUND(F_60_79, K_60_79);
445   DO_ROUND(F_60_79, K_60_79);
446   DO_ROUND(F_60_79, K_60_79);
447   DO_ROUND(F_60_79, K_60_79);
448   DO_ROUND(F_60_79, K_60_79);
449   DO_ROUND(F_60_79, K_60_79);
450   DO_ROUND(F_60_79, K_60_79);
451   DO_ROUND(F_60_79, K_60_79);
452   DO_ROUND(F_60_79, K_60_79);
453   DO_ROUND(F_60_79, K_60_79);
454 #else /* SHA1_UNROLL */
455 #error SHA1_UNROLL must be 1, 2, 4, 5, 10 or 20!
456 #endif
457 
458   sc->hash[0] += a;
459   sc->hash[1] += b;
460   sc->hash[2] += c;
461   sc->hash[3] += d;
462   sc->hash[4] += e;
463 }
464 
465 void
SHA1Update(SHA1Context * sc,const void * vdata,uint32_t len)466 SHA1Update (SHA1Context *sc, const void *vdata, uint32_t len)
467 {
468   const uint8_t *data = vdata;
469   uint32_t bufferBytesLeft;
470   uint32_t bytesToCopy;
471   int needBurn = 0;
472 
473 #ifdef SHA1_FAST_COPY
474   if (sc->bufferLength) {
475     bufferBytesLeft = 64L - sc->bufferLength;
476 
477     bytesToCopy = bufferBytesLeft;
478     if (bytesToCopy > len)
479       bytesToCopy = len;
480 
481     memcpy (&sc->buffer.bytes[sc->bufferLength], data, bytesToCopy);
482 
483     sc->totalLength += bytesToCopy * 8L;
484 
485     sc->bufferLength += bytesToCopy;
486     data += bytesToCopy;
487     len -= bytesToCopy;
488 
489     if (sc->bufferLength == 64L) {
490       SHA1Guts (sc, sc->buffer.words);
491       needBurn = 1;
492       sc->bufferLength = 0L;
493     }
494   }
495 
496   while (len > 63) {
497     sc->totalLength += 512L;
498 
499     SHA1Guts (sc, data);
500     needBurn = 1;
501 
502     data += 64L;
503     len -= 64L;
504   }
505 
506   if (len) {
507     memcpy (&sc->buffer.bytes[sc->bufferLength], data, len);
508 
509     sc->totalLength += len * 8L;
510 
511     sc->bufferLength += len;
512   }
513 #else /* SHA1_FAST_COPY */
514   while (len) {
515     bufferBytesLeft = 64L - sc->bufferLength;
516 
517     bytesToCopy = bufferBytesLeft;
518     if (bytesToCopy > len)
519       bytesToCopy = len;
520 
521     memcpy (&sc->buffer.bytes[sc->bufferLength], data, bytesToCopy);
522 
523     sc->totalLength += bytesToCopy * 8L;
524 
525     sc->bufferLength += bytesToCopy;
526     data += bytesToCopy;
527     len -= bytesToCopy;
528 
529     if (sc->bufferLength == 64L) {
530       SHA1Guts (sc, sc->buffer.words);
531       needBurn = 1;
532       sc->bufferLength = 0L;
533     }
534   }
535 #endif /* SHA1_FAST_COPY */
536 
537   if (needBurn)
538     burnStack (sizeof (uint32_t[86]) + sizeof (uint32_t *[5]) + sizeof (int));
539 }
540 
541 void
SHA1Final(SHA1Context * sc,uint8_t hash[SHA1_HASH_SIZE])542 SHA1Final (SHA1Context *sc, uint8_t hash[SHA1_HASH_SIZE])
543 {
544   uint32_t bytesToPad;
545   uint64_t lengthPad;
546   int i;
547 
548   bytesToPad = 120L - sc->bufferLength;
549   if (bytesToPad > 64L)
550     bytesToPad -= 64L;
551 
552   lengthPad = BYTESWAP64(sc->totalLength);
553 
554   SHA1Update (sc, padding, bytesToPad);
555   SHA1Update (sc, &lengthPad, 8L);
556 
557   if (hash) {
558     for (i = 0; i < SHA1_HASH_WORDS; i++) {
559 #ifdef SHA1_FAST_COPY
560       *((uint32_t *) hash) = BYTESWAP(sc->hash[i]);
561 #else /* SHA1_FAST_COPY */
562       hash[0] = (uint8_t) (sc->hash[i] >> 24);
563       hash[1] = (uint8_t) (sc->hash[i] >> 16);
564       hash[2] = (uint8_t) (sc->hash[i] >> 8);
565       hash[3] = (uint8_t) sc->hash[i];
566 #endif /* SHA1_FAST_COPY */
567       hash += 4;
568     }
569   }
570 }
571 
572 void
SHA1End(SHA1Context * sc,char * hashstrbuf)573 SHA1End (SHA1Context *sc, char *hashstrbuf)
574 {
575     static const char *sha1_hex_digits = "0123456789abcdef";
576     uint8_t digest[SHA1_HASH_SIZE], *d = digest;
577     int i;
578 
579     /* Sanity check: */
580     if (sc == NULL)
581         return;
582     if (hashstrbuf == NULL)
583         return;
584 
585     SHA1Final(sc, digest);
586 
587     for (i = 0; i < SHA1_HASH_SIZE; i++) {
588         *hashstrbuf++ = sha1_hex_digits[(*d & 0xf0) >> 4];
589         *hashstrbuf++ = sha1_hex_digits[(*d & 0x0f)];
590         d++;
591     }
592     *hashstrbuf = '\0';
593 }
594 
595 #ifdef SHA1_TEST
596 
597 #include <stdio.h>
598 #include <stdlib.h>
599 #include <string.h>
600 
601 int
main(int argc,char * argv[])602 main (int argc, char *argv[])
603 {
604   SHA1Context foo;
605   uint8_t hash[SHA1_HASH_SIZE];
606   char buf[1000];
607   int i;
608 
609   SHA1Init (&foo);
610   SHA1Update (&foo, "abc", 3);
611   SHA1Final (&foo, hash);
612 
613   for (i = 0; i < SHA1_HASH_SIZE;) {
614     printf ("%02x", hash[i++]);
615     if (!(i % 4))
616       printf (" ");
617   }
618   printf ("\n");
619 
620   SHA1Init (&foo);
621   SHA1Update (&foo,
622 		"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
623 		56);
624   SHA1Final (&foo, hash);
625 
626   for (i = 0; i < SHA1_HASH_SIZE;) {
627     printf ("%02x", hash[i++]);
628     if (!(i % 4))
629       printf (" ");
630   }
631   printf ("\n");
632 
633   SHA1Init (&foo);
634   memset (buf, 'a', sizeof (buf));
635   for (i = 0; i < 1000; i++)
636     SHA1Update (&foo, buf, sizeof (buf));
637   SHA1Final (&foo, hash);
638 
639   for (i = 0; i < SHA1_HASH_SIZE;) {
640     printf ("%02x", hash[i++]);
641     if (!(i % 4))
642       printf (" ");
643   }
644   printf ("\n");
645 
646   exit (0);
647 }
648 
649 #endif /* SHA1_TEST */
650