Switched to GPLv3.
[gnupg.git] / cipher / sha256.c
1 /* sha256.c - SHA224 and SHA256 hash functions
2  * Copyright (C) 2003, 2006 Free Software Foundation, Inc.
3  *
4  * Please see below for more legal information!
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG 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 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG 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, see <http://www.gnu.org/licenses/>.
20  */
21
22
23 /*  Test vectors from FIPS-180-2:
24  *
25  *  "abc"
26  * 224:
27  *  23097D22 3405D822 8642A477 BDA255B3 2AADBCE4 BDA0B3F7 E36C9DA7
28  * 256:
29  *  BA7816BF 8F01CFEA 414140DE 5DAE2223 B00361A3 96177A9C B410FF61 F20015AD
30  *
31  *  "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
32  * 224:
33  *  75388B16 512776CC 5DBA5DA1 FD890150 B0C6455C B4F58B19 52522525
34  * 256:
35  *  248D6A61 D20638B8 E5C02693 0C3E6039 A33CE459 64FF2167 F6ECEDD4 19DB06C1
36  *
37  *  "a" x 1000000
38  * 224:
39  *  20794655 980C91D8 BBB4C1EA 97618A4B F03F4258 1948B2EE 4EE7AD67
40  * 256:
41  *  CDC76E5C 9914FB92 81A1C7E2 84D73E67 F1809A48 A497200E 046D39CC C7112CD0
42  */
43
44
45 #include <config.h>
46 #include <string.h>
47 #include "util.h"
48 #include "algorithms.h"
49
50
51 typedef struct {
52     u32  h0,h1,h2,h3,h4,h5,h6,h7;
53     u32  nblocks;
54     byte buf[64];
55     int  count;
56 } SHA256_CONTEXT;
57
58 static void
59 burn_stack (int bytes)
60 {
61     char buf[128];
62
63     wipememory(buf,sizeof buf);
64     bytes -= sizeof buf;
65     if (bytes > 0)
66         burn_stack (bytes);
67 }
68
69
70 void
71 sha256_init( SHA256_CONTEXT *hd )
72 {
73     hd->h0 = 0x6a09e667;
74     hd->h1 = 0xbb67ae85;
75     hd->h2 = 0x3c6ef372;
76     hd->h3 = 0xa54ff53a;
77     hd->h4 = 0x510e527f;
78     hd->h5 = 0x9b05688c;
79     hd->h6 = 0x1f83d9ab;
80     hd->h7 = 0x5be0cd19;
81
82     hd->nblocks = 0;
83     hd->count = 0;
84 }
85
86 void
87 sha224_init( SHA256_CONTEXT *hd )
88 {
89     hd->h0 = 0xc1059ed8;
90     hd->h1 = 0x367cd507;
91     hd->h2 = 0x3070dd17;
92     hd->h3 = 0xf70e5939;
93     hd->h4 = 0xffc00b31;
94     hd->h5 = 0x68581511;
95     hd->h6 = 0x64f98fa7;
96     hd->h7 = 0xbefa4fa4;
97
98     hd->nblocks = 0;
99     hd->count = 0;
100 }
101
102
103 /****************
104  * Transform the message w which consists of 16 32-bit words
105  */
106 static void
107 transform( SHA256_CONTEXT *hd, byte *data )
108 {
109   u32 a,b,c,d,e,f,g,h;
110   u32 w[64];
111   int t;
112   static const u32 k[]=
113     {
114       0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
115       0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
116       0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
117       0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
118       0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
119       0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
120       0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
121       0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
122       0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
123       0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
124       0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
125     };
126
127   /* get values from the chaining vars */
128   a = hd->h0;
129   b = hd->h1;
130   c = hd->h2;
131   d = hd->h3;
132   e = hd->h4;
133   f = hd->h5;
134   g = hd->h6;
135   h = hd->h7;
136
137 #ifdef BIG_ENDIAN_HOST
138   memcpy( w, data, 64 );
139 #else
140   {
141     int i;
142     byte *p2;
143
144     for(i=0, p2=(byte*)w; i < 16; i++, p2 += 4 )
145       {
146         p2[3] = *data++;
147         p2[2] = *data++;
148         p2[1] = *data++;
149         p2[0] = *data++;
150       }
151   }
152 #endif
153
154 #define ROTR(x,n) (((x)>>(n)) | ((x)<<(32-(n))))
155 #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
156 #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
157 #define Sum0(x) (ROTR((x),2) ^ ROTR((x),13) ^ ROTR((x),22))
158 #define Sum1(x) (ROTR((x),6) ^ ROTR((x),11) ^ ROTR((x),25))
159 #define S0(x) (ROTR((x),7) ^ ROTR((x),18) ^ ((x)>>3))
160 #define S1(x) (ROTR((x),17) ^ ROTR((x),19) ^ ((x)>>10))
161
162   for(t=16;t<64;t++)
163     w[t] = S1(w[t-2]) + w[t-7] + S0(w[t-15]) + w[t-16];
164
165   for(t=0;t<64;t++)
166     {
167       u32 t1,t2;
168
169       t1=h+Sum1(e)+Ch(e,f,g)+k[t]+w[t];
170       t2=Sum0(a)+Maj(a,b,c);
171       h=g;
172       g=f;
173       f=e;
174       e=d+t1;
175       d=c;
176       c=b;
177       b=a;
178       a=t1+t2;
179       /* printf("t=%d a=%08lX b=%08lX c=%08lX d=%08lX e=%08lX f=%08lX g=%08lX h=%08lX\n",t,a,b,c,d,e,f,g,h); */
180     }
181
182   /* update chaining vars */
183   hd->h0 += a;
184   hd->h1 += b;
185   hd->h2 += c;
186   hd->h3 += d;
187   hd->h4 += e;
188   hd->h5 += f;
189   hd->h6 += g;
190   hd->h7 += h;
191 }
192
193
194 /* Update the message digest with the contents
195  * of INBUF with length INLEN.
196  */
197 static void
198 sha256_write( SHA256_CONTEXT *hd, byte *inbuf, size_t inlen)
199 {
200     if( hd->count == 64 ) { /* flush the buffer */
201         transform( hd, hd->buf );
202         burn_stack (328);
203         hd->count = 0;
204         hd->nblocks++;
205     }
206     if( !inbuf )
207         return;
208     if( hd->count ) {
209         for( ; inlen && hd->count < 64; inlen-- )
210             hd->buf[hd->count++] = *inbuf++;
211         sha256_write( hd, NULL, 0 );
212         if( !inlen )
213             return;
214     }
215
216     while( inlen >= 64 ) {
217         transform( hd, inbuf );
218         hd->count = 0;
219         hd->nblocks++;
220         inlen -= 64;
221         inbuf += 64;
222     }
223     burn_stack (328);
224     for( ; inlen && hd->count < 64; inlen-- )
225         hd->buf[hd->count++] = *inbuf++;
226 }
227
228
229 /* The routine final terminates the computation and
230  * returns the digest.
231  * The handle is prepared for a new cycle, but adding bytes to the
232  * handle will the destroy the returned buffer.
233  * Returns: 32 bytes representing the digest.  When used for sha224,
234  * we take the leftmost 28 of those bytes.
235  */
236
237 static void
238 sha256_final(SHA256_CONTEXT *hd)
239 {
240     u32 t, msb, lsb;
241     byte *p;
242
243     sha256_write(hd, NULL, 0); /* flush */;
244
245     t = hd->nblocks;
246     /* multiply by 64 to make a byte count */
247     lsb = t << 6;
248     msb = t >> 26;
249     /* add the count */
250     t = lsb;
251     if( (lsb += hd->count) < t )
252         msb++;
253     /* multiply by 8 to make a bit count */
254     t = lsb;
255     lsb <<= 3;
256     msb <<= 3;
257     msb |= t >> 29;
258
259     if( hd->count < 56 ) { /* enough room */
260         hd->buf[hd->count++] = 0x80; /* pad */
261         while( hd->count < 56 )
262             hd->buf[hd->count++] = 0;  /* pad */
263     }
264     else { /* need one extra block */
265         hd->buf[hd->count++] = 0x80; /* pad character */
266         while( hd->count < 64 )
267             hd->buf[hd->count++] = 0;
268         sha256_write(hd, NULL, 0);  /* flush */;
269         memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
270     }
271     /* append the 64 bit count */
272     hd->buf[56] = msb >> 24;
273     hd->buf[57] = msb >> 16;
274     hd->buf[58] = msb >>  8;
275     hd->buf[59] = msb      ;
276     hd->buf[60] = lsb >> 24;
277     hd->buf[61] = lsb >> 16;
278     hd->buf[62] = lsb >>  8;
279     hd->buf[63] = lsb      ;
280     transform( hd, hd->buf );
281     burn_stack (328);
282
283     p = hd->buf;
284 #ifdef BIG_ENDIAN_HOST
285 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
286 #else /* little endian */
287 #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;  \
288                       *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
289 #endif
290     X(0);
291     X(1);
292     X(2);
293     X(3);
294     X(4);
295     X(5);
296     X(6);
297     /* Note that this last chunk is included even for SHA224.  We just
298        ignore it. */
299     X(7);
300 #undef X
301 }
302
303 static byte *
304 sha256_read( SHA256_CONTEXT *hd )
305 {
306     return hd->buf;
307 }
308
309 /****************
310  * Return some information about the algorithm.  We need algo here to
311  * distinguish different flavors of the algorithm.
312  * Returns: A pointer to string describing the algorithm or NULL if
313  *          the ALGO is invalid.
314  */
315 const char *
316 sha256_get_info( int algo, size_t *contextsize,
317                  byte **r_asnoid, int *r_asnlen, int *r_mdlen,
318                  void (**r_init)( void *c ),
319                  void (**r_write)( void *c, byte *buf, size_t nbytes ),
320                  void (**r_final)( void *c ),
321                  byte *(**r_read)( void *c )
322                  )
323 {
324     static byte asn[] = /* Object ID is 2.16.840.1.101.3.4.2.1 */
325       { 
326         0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
327         0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
328         0x00, 0x04, 0x20
329       };
330
331     if( algo != 8 )
332         return NULL;
333
334     *contextsize = sizeof(SHA256_CONTEXT);
335     *r_asnoid = asn;
336     *r_asnlen = DIM(asn);
337     *r_mdlen = 32;
338     *(void  (**)(SHA256_CONTEXT *))r_init                 = sha256_init;
339     *(void  (**)(SHA256_CONTEXT *, byte*, size_t))r_write = sha256_write;
340     *(void  (**)(SHA256_CONTEXT *))r_final                = sha256_final;
341     *(byte *(**)(SHA256_CONTEXT *))r_read                 = sha256_read;
342
343     return "SHA256";
344 }
345
346 /* SHA224 is really a truncated SHA256 with a different
347    initialization */
348 const char *
349 sha224_get_info( int algo, size_t *contextsize,
350                  byte **r_asnoid, int *r_asnlen, int *r_mdlen,
351                  void (**r_init)( void *c ),
352                  void (**r_write)( void *c, byte *buf, size_t nbytes ),
353                  void (**r_final)( void *c ),
354                  byte *(**r_read)( void *c )
355                  )
356 {
357     static byte asn[] = /* Object ID is 2.16.840.1.101.3.4.2.4 */
358       { 
359         0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
360         0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05,
361         0x00, 0x04, 0x20
362       };
363
364     if( algo != 11 )
365         return NULL;
366
367     *contextsize = sizeof(SHA256_CONTEXT);
368     *r_asnoid = asn;
369     *r_asnlen = DIM(asn);
370     *r_mdlen = 28;
371     *(void  (**)(SHA256_CONTEXT *))r_init                 = sha224_init;
372     *(void  (**)(SHA256_CONTEXT *, byte*, size_t))r_write = sha256_write;
373     *(void  (**)(SHA256_CONTEXT *))r_final                = sha256_final;
374     *(byte *(**)(SHA256_CONTEXT *))r_read                 = sha256_read;
375
376     return "SHA224";
377 }