Bug in blowfish behoben
[gnupg.git] / cipher / sha1.c
1 /* sha1.c - SHA1 hash function
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * Please see below for more legal informations!
5  *
6  * This file is part of G10.
7  *
8  * G10 is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * G10 is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21  */
22
23 /* I took the code for transform() from the Linux kernel
24  * (/usr/src/linux/drivers/char/random.c) which has
25  *
26  * a) This notice:
27  * ---------------
28  * SHA transform algorithm, taken from code written by Peter Gutman,
29  * and apparently in the public domain.
30  *
31  * b) This copyright notice:
32  * -------------------------
33  * Version 1.00, last modified 26-May-96
34  *
35  * Copyright Theodore Ts'o, 1994, 1995, 1996.  All rights reserved.
36  *
37  * Redistribution and use in source and binary forms, with or without
38  * modification, are permitted provided that the following conditions
39  * are met:
40  * 1. Redistributions of source code must retain the above copyright
41  *    notice, and the entire permission notice in its entirety,
42  *    including the disclaimer of warranties.
43  * 2. Redistributions in binary form must reproduce the above copyright
44  *    notice, this list of conditions and the following disclaimer in the
45  *    documentation and/or other materials provided with the distribution.
46  * 3. The name of the author may not be used to endorse or promote
47  *    products derived from this software without specific prior
48  *    written permission.
49  *
50  * ALTERNATIVELY, this product may be distributed under the terms of
51  * the GNU Public License, in which case the provisions of the GPL are
52  * required INSTEAD OF the above restrictions.  (This clause is
53  * necessary due to a potential bad interaction between the GPL and
54  * the restrictions contained in a BSD-style copyright.)
55  *
56  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
57  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
58  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
59  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
60  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
61  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
62  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
64  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
65  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
66  * OF THE POSSIBILITY OF SUCH DAMAGE.
67  */
68
69
70 /*  Test vectors:
71  *
72  *  "abc"
73  *  A999 3E36 4706 816A BA3E  2571 7850 C26C 9CD0 D89D
74  *
75  *  "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
76  *  8498 3E44 1C3B D26E BAAE  4AA1 F951 29E5 E546 70F1
77  */
78
79
80 #include <config.h>
81 #include <stdio.h>
82 #include <stdlib.h>
83 #include <string.h>
84 #include <assert.h>
85 #include "util.h"
86 #include "memory.h"
87 #include "cipher.h" /* grrrr */
88 #include "sha1.h"
89
90
91 /* The SHA f()-functions.  */
92 #define f1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )           /* Rounds  0-19 */
93 #define f2(x,y,z)   ( x ^ y ^ z )                       /* Rounds 20-39 */
94 #define f3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )   /* Rounds 40-59 */
95 #define f4(x,y,z)   ( x ^ y ^ z )                       /* Rounds 60-79 */
96
97 /* The SHA Mysterious Constants */
98 #define K1  0x5A827999L                                 /* Rounds  0-19 */
99 #define K2  0x6ED9EBA1L                                 /* Rounds 20-39 */
100 #define K3  0x8F1BBCDCL                                 /* Rounds 40-59 */
101 #define K4  0xCA62C1D6L                                 /* Rounds 60-79 */
102
103 #define ROTL(n,X)  ( ( ( X ) << n ) | ( ( X ) >> ( 32 - n ) ) )
104
105 #define expand(W,i) ( W[ i & 15 ] = \
106                      ROTL( 1, ( W[ i & 15 ] ^ W[ (i - 14) & 15 ] ^ \
107                                 W[ (i - 8) & 15 ] ^ W[ (i - 3) & 15 ] ) ) )
108
109 #define subRound(a, b, c, d, e, f, k, data) \
110     ( e += ROTL( 5, a ) + f( b, c, d ) + k + data, b = ROTL( 30, b ) )
111
112
113 static void
114 initialize( SHA1HANDLE hd )
115 {
116     hd->h0 = 0x67452301;
117     hd->h1 = 0xefcdab89;
118     hd->h2 = 0x98badcfe;
119     hd->h3 = 0x10325476;
120     hd->h4 = 0xc3d2e1f0;
121     hd->bufcount = 0;
122     hd->nblocks = 0;
123 }
124
125
126 /****************
127  * Transform the message X which consists of 16 32-bit-words
128  */
129 static void
130 transform( SHA1HANDLE hd, byte *data )
131 {
132     u32 A, B, C, D, E;     /* Local vars */
133     u32 eData[ 16 ];       /* Expanded data */
134
135     /* Set up first buffer and local data buffer */
136     A = hd->h0;
137     B = hd->h1;
138     C = hd->h2;
139     D = hd->h3;
140     E = hd->h4;
141
142   #ifdef BIG_ENDIAN_HOST
143     memcpy( eData, data, 64 );
144   #else
145     { int i;
146       byte *p2;
147       for(i=0, p2=(byte*)eData; i < 16; i++, p2 += 4 ) {
148         p2[3] = *data++;
149         p2[2] = *data++;
150         p2[1] = *data++;
151         p2[0] = *data++;
152       }
153     }
154   #endif
155
156     /* Heavy mangling, in 4 sub-rounds of 20 iterations each. */
157     subRound( A, B, C, D, E, f1, K1, eData[  0 ] );
158     subRound( E, A, B, C, D, f1, K1, eData[  1 ] );
159     subRound( D, E, A, B, C, f1, K1, eData[  2 ] );
160     subRound( C, D, E, A, B, f1, K1, eData[  3 ] );
161     subRound( B, C, D, E, A, f1, K1, eData[  4 ] );
162     subRound( A, B, C, D, E, f1, K1, eData[  5 ] );
163     subRound( E, A, B, C, D, f1, K1, eData[  6 ] );
164     subRound( D, E, A, B, C, f1, K1, eData[  7 ] );
165     subRound( C, D, E, A, B, f1, K1, eData[  8 ] );
166     subRound( B, C, D, E, A, f1, K1, eData[  9 ] );
167     subRound( A, B, C, D, E, f1, K1, eData[ 10 ] );
168     subRound( E, A, B, C, D, f1, K1, eData[ 11 ] );
169     subRound( D, E, A, B, C, f1, K1, eData[ 12 ] );
170     subRound( C, D, E, A, B, f1, K1, eData[ 13 ] );
171     subRound( B, C, D, E, A, f1, K1, eData[ 14 ] );
172     subRound( A, B, C, D, E, f1, K1, eData[ 15 ] );
173     subRound( E, A, B, C, D, f1, K1, expand( eData, 16 ) );
174     subRound( D, E, A, B, C, f1, K1, expand( eData, 17 ) );
175     subRound( C, D, E, A, B, f1, K1, expand( eData, 18 ) );
176     subRound( B, C, D, E, A, f1, K1, expand( eData, 19 ) );
177
178     subRound( A, B, C, D, E, f2, K2, expand( eData, 20 ) );
179     subRound( E, A, B, C, D, f2, K2, expand( eData, 21 ) );
180     subRound( D, E, A, B, C, f2, K2, expand( eData, 22 ) );
181     subRound( C, D, E, A, B, f2, K2, expand( eData, 23 ) );
182     subRound( B, C, D, E, A, f2, K2, expand( eData, 24 ) );
183     subRound( A, B, C, D, E, f2, K2, expand( eData, 25 ) );
184     subRound( E, A, B, C, D, f2, K2, expand( eData, 26 ) );
185     subRound( D, E, A, B, C, f2, K2, expand( eData, 27 ) );
186     subRound( C, D, E, A, B, f2, K2, expand( eData, 28 ) );
187     subRound( B, C, D, E, A, f2, K2, expand( eData, 29 ) );
188     subRound( A, B, C, D, E, f2, K2, expand( eData, 30 ) );
189     subRound( E, A, B, C, D, f2, K2, expand( eData, 31 ) );
190     subRound( D, E, A, B, C, f2, K2, expand( eData, 32 ) );
191     subRound( C, D, E, A, B, f2, K2, expand( eData, 33 ) );
192     subRound( B, C, D, E, A, f2, K2, expand( eData, 34 ) );
193     subRound( A, B, C, D, E, f2, K2, expand( eData, 35 ) );
194     subRound( E, A, B, C, D, f2, K2, expand( eData, 36 ) );
195     subRound( D, E, A, B, C, f2, K2, expand( eData, 37 ) );
196     subRound( C, D, E, A, B, f2, K2, expand( eData, 38 ) );
197     subRound( B, C, D, E, A, f2, K2, expand( eData, 39 ) );
198
199     subRound( A, B, C, D, E, f3, K3, expand( eData, 40 ) );
200     subRound( E, A, B, C, D, f3, K3, expand( eData, 41 ) );
201     subRound( D, E, A, B, C, f3, K3, expand( eData, 42 ) );
202     subRound( C, D, E, A, B, f3, K3, expand( eData, 43 ) );
203     subRound( B, C, D, E, A, f3, K3, expand( eData, 44 ) );
204     subRound( A, B, C, D, E, f3, K3, expand( eData, 45 ) );
205     subRound( E, A, B, C, D, f3, K3, expand( eData, 46 ) );
206     subRound( D, E, A, B, C, f3, K3, expand( eData, 47 ) );
207     subRound( C, D, E, A, B, f3, K3, expand( eData, 48 ) );
208     subRound( B, C, D, E, A, f3, K3, expand( eData, 49 ) );
209     subRound( A, B, C, D, E, f3, K3, expand( eData, 50 ) );
210     subRound( E, A, B, C, D, f3, K3, expand( eData, 51 ) );
211     subRound( D, E, A, B, C, f3, K3, expand( eData, 52 ) );
212     subRound( C, D, E, A, B, f3, K3, expand( eData, 53 ) );
213     subRound( B, C, D, E, A, f3, K3, expand( eData, 54 ) );
214     subRound( A, B, C, D, E, f3, K3, expand( eData, 55 ) );
215     subRound( E, A, B, C, D, f3, K3, expand( eData, 56 ) );
216     subRound( D, E, A, B, C, f3, K3, expand( eData, 57 ) );
217     subRound( C, D, E, A, B, f3, K3, expand( eData, 58 ) );
218     subRound( B, C, D, E, A, f3, K3, expand( eData, 59 ) );
219
220     subRound( A, B, C, D, E, f4, K4, expand( eData, 60 ) );
221     subRound( E, A, B, C, D, f4, K4, expand( eData, 61 ) );
222     subRound( D, E, A, B, C, f4, K4, expand( eData, 62 ) );
223     subRound( C, D, E, A, B, f4, K4, expand( eData, 63 ) );
224     subRound( B, C, D, E, A, f4, K4, expand( eData, 64 ) );
225     subRound( A, B, C, D, E, f4, K4, expand( eData, 65 ) );
226     subRound( E, A, B, C, D, f4, K4, expand( eData, 66 ) );
227     subRound( D, E, A, B, C, f4, K4, expand( eData, 67 ) );
228     subRound( C, D, E, A, B, f4, K4, expand( eData, 68 ) );
229     subRound( B, C, D, E, A, f4, K4, expand( eData, 69 ) );
230     subRound( A, B, C, D, E, f4, K4, expand( eData, 70 ) );
231     subRound( E, A, B, C, D, f4, K4, expand( eData, 71 ) );
232     subRound( D, E, A, B, C, f4, K4, expand( eData, 72 ) );
233     subRound( C, D, E, A, B, f4, K4, expand( eData, 73 ) );
234     subRound( B, C, D, E, A, f4, K4, expand( eData, 74 ) );
235     subRound( A, B, C, D, E, f4, K4, expand( eData, 75 ) );
236     subRound( E, A, B, C, D, f4, K4, expand( eData, 76 ) );
237     subRound( D, E, A, B, C, f4, K4, expand( eData, 77 ) );
238     subRound( C, D, E, A, B, f4, K4, expand( eData, 78 ) );
239     subRound( B, C, D, E, A, f4, K4, expand( eData, 79 ) );
240
241     /* Build message digest */
242     hd->h0 += A;
243     hd->h1 += B;
244     hd->h2 += C;
245     hd->h3 += D;
246     hd->h4 += E;
247 }
248
249
250
251
252 SHA1HANDLE
253 sha1_open( int secure )
254 {
255     SHA1HANDLE hd;
256
257     hd = secure? m_alloc_secure( sizeof *hd )
258                : m_alloc( sizeof *hd );
259     initialize(hd);
260     return hd;
261 }
262
263
264 SHA1HANDLE
265 sha1_copy( SHA1HANDLE a )
266 {
267     SHA1HANDLE b;
268
269     assert(a);
270     b = m_is_secure(a)? m_alloc_secure( sizeof *b )
271                       : m_alloc( sizeof *b );
272     memcpy( b, a, sizeof *a );
273     return b;
274 }
275
276
277 /* BAD Kludge!!! */
278 MD_HANDLE *
279 sha1_copy2md( SHA1HANDLE a )
280 {
281     MD_HANDLE *md = md_makecontainer( DIGEST_ALGO_SHA1 );
282     md->u.sha1 = sha1_copy( a );
283     return md;
284 }
285
286
287
288 void
289 sha1_close(SHA1HANDLE hd)
290 {
291     if( hd )
292         m_free(hd);
293 }
294
295
296
297 /* Update the message digest with the contents
298  * of INBUF with length INLEN.
299  */
300 void
301 sha1_write( SHA1HANDLE hd, byte *inbuf, size_t inlen)
302 {
303     if( hd->bufcount == 64 ) { /* flush the buffer */
304         transform( hd, hd->buffer );
305         hd->bufcount = 0;
306         hd->nblocks++;
307     }
308     if( !inbuf )
309         return;
310     if( hd->bufcount ) {
311         for( ; inlen && hd->bufcount < 64; inlen-- )
312             hd->buffer[hd->bufcount++] = *inbuf++;
313         sha1_write( hd, NULL, 0 );
314         if( !inlen )
315             return;
316     }
317
318     while( inlen >= 64 ) {
319         transform( hd, inbuf );
320         hd->bufcount = 0;
321         hd->nblocks++;
322         inlen -= 64;
323         inbuf += 64;
324     }
325     for( ; inlen && hd->bufcount < 64; inlen-- )
326         hd->buffer[hd->bufcount++] = *inbuf++;
327 }
328
329
330 /* The routine final terminates the computation and
331  * returns the digest.
332  * The handle is prepared for a new cycle, but adding bytes to the
333  * handle will the destroy the returned buffer.
334  * Returns: 20 bytes representing the digest.
335  */
336
337 byte *
338 sha1_final(SHA1HANDLE hd)
339 {
340     u32 t, msb, lsb;
341     byte *p;
342
343     sha1_write(hd, NULL, 0); /* flush */;
344
345     msb = 0;
346     t = hd->nblocks;
347     if( (lsb = t << 6) < t ) /* multiply by 64 to make a byte count */
348         msb++;
349     msb += t >> 26;
350     t = lsb;
351     if( (lsb = t + hd->bufcount) < t ) /* add the bufcount */
352         msb++;
353     t = lsb;
354     if( (lsb = t << 3) < t ) /* multiply by 8 to make a bit count */
355         msb++;
356     msb += t >> 29;
357
358     if( hd->bufcount < 56 ) { /* enough room */
359         hd->buffer[hd->bufcount++] = 0x80; /* pad */
360         while( hd->bufcount < 56 )
361             hd->buffer[hd->bufcount++] = 0;  /* pad */
362     }
363     else { /* need one extra block */
364         hd->buffer[hd->bufcount++] = 0x80; /* pad character */
365         while( hd->bufcount < 64 )
366             hd->buffer[hd->bufcount++] = 0;
367         sha1_write(hd, NULL, 0);  /* flush */;
368         memset(hd->buffer, 0, 56 ); /* fill next block with zeroes */
369     }
370     /* append the 64 bit count */
371     hd->buffer[56] = msb >> 24;
372     hd->buffer[57] = msb >> 16;
373     hd->buffer[58] = msb >>  8;
374     hd->buffer[59] = msb      ;
375     hd->buffer[60] = lsb >> 24;
376     hd->buffer[61] = lsb >> 16;
377     hd->buffer[62] = lsb >>  8;
378     hd->buffer[63] = lsb      ;
379     transform( hd, hd->buffer );
380
381     p = hd->buffer;
382   #ifdef BIG_ENDIAN_HOST
383     #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
384   #else /* little endian */
385     #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;      \
386                       *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
387   #endif
388     X(0);
389     X(1);
390     X(2);
391     X(3);
392     X(4);
393   #undef X
394
395     initialize( hd );  /* prepare for next cycle */
396     return hd->buffer; /* now contains the digest */
397 }
398
399