Added some missing ChangeLog entries.
[libgcrypt.git] / cipher / sha256.c
1 /* sha256.c - SHA256 hash function
2  *      Copyright (C) 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21
22 /*  Test vectors:
23     
24     "abc"
25     ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad
26
27     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
28     248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1
29  
30     "a" one million times
31     cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0
32
33  */
34
35
36 #include <config.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <assert.h>
41 #include "g10lib.h"
42 #include "memory.h"
43 #include "dynload.h"
44 #include "bithelp.h"
45
46
47 typedef struct {
48   u32  h0,h1,h2,h3,h4,h5,h6,h7;
49   u32  nblocks;
50   byte buf[64];
51   int  count;
52 } SHA256_CONTEXT;
53
54
55 static void
56 sha256_init (SHA256_CONTEXT *hd)
57 {
58   hd->h0 = 0x6a09e667;
59   hd->h1 = 0xbb67ae85;
60   hd->h2 = 0x3c6ef372;
61   hd->h3 = 0xa54ff53a;
62   hd->h4 = 0x510e527f;
63   hd->h5 = 0x9b05688c;
64   hd->h6 = 0x1f83d9ab;
65   hd->h7 = 0x5be0cd19;
66
67   hd->nblocks = 0;
68   hd->count = 0;
69 }
70
71
72 /*
73   Transform the message X which consists of 16 32-bit-words. See FIPS
74   180-2 for details.  */
75 #define Cho(x,y,z) (z ^ (x & (y ^ z)))      /* (4.2) same as SHA-1's F1 */
76 #define Maj(x,y,z) ((x & y) | (z & (x|y)))  /* (4.3) same as SHA-1's F3 */
77 #define Sum0(x) (ror ((x), 2) ^ ror ((x), 13) ^ ror ((x), 22))  /* (4.4) */
78 #define Sum1(x) (ror ((x), 6) ^ ror ((x), 11) ^ ror ((x), 25))  /* (4.5) */
79 #define S0(x) (ror ((x), 7) ^ ror ((x), 18) ^ ((x) >> 3))       /* (4.6) */
80 #define S1(x) (ror ((x), 17) ^ ror ((x), 19) ^ ((x) >> 10))     /* (4.7) */
81 #define R(a,b,c,d,e,f,g,h,k,w) do                                 \
82           {                                                       \
83             t1 = (h) + Sum1((e)) + Cho((e),(f),(g)) + (k) + (w);  \
84             t2 = Sum0((a)) + Maj((a),(b),(c));                    \
85             h = g;                                                \
86             g = f;                                                \
87             f = e;                                                \
88             e = d + t1;                                           \
89             d = c;                                                \
90             c = b;                                                \
91             b = a;                                                \
92             a = t1 + t2;                                          \
93           } while (0)
94  
95 static void
96 transform (SHA256_CONTEXT *hd, byte *data)
97 {
98   static const u32 K[64] = {
99     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
100     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
101     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
102     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 
103     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
104     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
105     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
106     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
107     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
108     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
109     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
110     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
111     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
112     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
113     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
114     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
115   };
116
117   u32 a,b,c,d,e,f,g,h,t1,t2;
118   u32 x[16];
119   u32 w[64];
120   int i;
121   
122   a = hd->h0;
123   b = hd->h1;
124   c = hd->h2;
125   d = hd->h3;
126   e = hd->h4;
127   f = hd->h5;
128   g = hd->h6;
129   h = hd->h7;
130   
131 #ifdef BIG_ENDIAN_HOST
132   memcpy (x, data, 64);
133 #else
134   { 
135     byte *p2;
136   
137     for (i=0, p2=(byte*)x; i < 16; i++, p2 += 4 ) 
138       {
139         p2[3] = *data++;
140         p2[2] = *data++;
141         p2[1] = *data++;
142         p2[0] = *data++;
143       }
144   }
145 #endif
146
147   for (i=0; i < 16; i++)
148     w[i] = x[i];
149   for (; i < 64; i++)
150     w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
151
152   for (i=0; i < 64; i++)
153     R(a,b,c,d,e,f,g,h,K[i],w[i]);
154
155   hd->h0 += a;
156   hd->h1 += b;
157   hd->h2 += c;
158   hd->h3 += d;
159   hd->h4 += e;
160   hd->h5 += f;
161   hd->h6 += g;
162   hd->h7 += h;
163 }
164 #undef Cho
165 #undef Maj
166 #undef Sum0
167 #undef Sum1
168 #undef S0
169 #undef S1
170 #undef R
171
172
173 /* Update the message digest with the contents of INBUF with length
174   INLEN.  */
175 static void
176 sha256_write (SHA256_CONTEXT *hd, byte *inbuf, size_t inlen)
177 {
178   if (hd->count == 64)
179     { /* flush the buffer */
180       transform (hd, hd->buf);
181       _gcry_burn_stack (74*4+32);
182       hd->count = 0;
183       hd->nblocks++;
184     }
185   if (!inbuf)
186     return;
187   if (hd->count)
188     {
189       for (; inlen && hd->count < 64; inlen--)
190         hd->buf[hd->count++] = *inbuf++;
191       sha256_write (hd, NULL, 0);
192       if (!inlen)
193         return;
194     }
195
196   while (inlen >= 64)
197     {
198       transform (hd, inbuf);
199       hd->count = 0;
200       hd->nblocks++;
201       inlen -= 64;
202       inbuf += 64;
203     }
204   _gcry_burn_stack (74*4+32);
205   for (; inlen && hd->count < 64; inlen--)
206     hd->buf[hd->count++] = *inbuf++;
207 }
208
209
210 /*
211    The routine finally terminates the computation and returns the
212    digest.  The handle is prepared for a new cycle, but adding bytes
213    to the handle will the destroy the returned buffer.  Returns: 32
214    bytes with the message the digest.  */
215 static void
216 sha256_final(SHA256_CONTEXT *hd)
217 {
218   u32 t, msb, lsb;
219   byte *p;
220   
221   sha256_write (hd, NULL, 0); /* flush */;
222
223   t = hd->nblocks;
224   /* multiply by 64 to make a byte count */
225   lsb = t << 6;
226   msb = t >> 26;
227   /* add the count */
228   t = lsb;
229   if ((lsb += hd->count) < t)
230     msb++;
231   /* multiply by 8 to make a bit count */
232   t = lsb;
233   lsb <<= 3;
234   msb <<= 3;
235   msb |= t >> 29;
236
237   if (hd->count < 56)
238     { /* enough room */
239       hd->buf[hd->count++] = 0x80; /* pad */
240       while (hd->count < 56)
241         hd->buf[hd->count++] = 0;  /* pad */
242     }
243   else
244     { /* need one extra block */
245       hd->buf[hd->count++] = 0x80; /* pad character */
246       while (hd->count < 64)
247         hd->buf[hd->count++] = 0;
248       sha256_write (hd, NULL, 0);  /* flush */;
249       memset (hd->buf, 0, 56 ); /* fill next block with zeroes */
250     }
251   /* append the 64 bit count */
252   hd->buf[56] = msb >> 24;
253   hd->buf[57] = msb >> 16;
254   hd->buf[58] = msb >>  8;
255   hd->buf[59] = msb;
256   hd->buf[60] = lsb >> 24;
257   hd->buf[61] = lsb >> 16;
258   hd->buf[62] = lsb >>  8;
259   hd->buf[63] = lsb;
260   transform (hd, hd->buf);
261   _gcry_burn_stack (74*4+32);
262
263   p = hd->buf;
264 #ifdef BIG_ENDIAN_HOST
265 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
266 #else /* little endian */
267 #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;  \
268                   *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
269 #endif
270   X(0);
271   X(1);
272   X(2);
273   X(3);
274   X(4);
275   X(5);
276   X(6);
277   X(7);
278 #undef X
279 }
280
281 static byte *
282 sha256_read (SHA256_CONTEXT *hd)
283 {
284   return hd->buf;
285 }
286
287 /*
288    Return some information about the algorithm.  We need algo here to
289    distinguish different flavors of the algorithm.  Returns: A pointer
290    to string describing the algorithm or NULL if the ALGO is invalid.  */
291 static const char *
292 sha256_get_info (int algo, size_t *contextsize,
293                  byte **r_asnoid, int *r_asnlen, int *r_mdlen,
294                  void (**r_init)( void *c ),
295                  void (**r_write)( void *c, byte *buf, size_t nbytes ),
296                  void (**r_final)( void *c ),
297                  byte *(**r_read)( void *c )
298                  )
299 {
300   static byte asn[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
301   { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
302     0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
303     0x00, 0x04, 0x20 };
304
305   if(algo != 8)
306     return NULL;
307
308   *contextsize = sizeof(SHA256_CONTEXT);
309   *r_asnoid = asn;
310   *r_asnlen = DIM(asn);
311   *r_mdlen = 32;
312   *(void  (**)(SHA256_CONTEXT *))r_init                   = sha256_init;
313   *(void  (**)(SHA256_CONTEXT *, byte*, size_t))r_write = sha256_write;
314   *(void  (**)(SHA256_CONTEXT *))r_final                  = sha256_final;
315   *(byte *(**)(SHA256_CONTEXT *))r_read                   = sha256_read;
316   
317   return "SHA256";
318 }
319
320
321
322 #ifndef IS_MODULE
323 static
324 #endif
325 const char * const gnupgext_version = "SHA256 ($Revision$)";
326
327 static struct {
328     int class;
329     int version;
330     int  value;
331     void (*func)(void);
332 } func_table[] = {
333     { 10, 1, 0, (void(*)(void))sha256_get_info },
334     { 11, 1, 8 },
335 };
336
337
338 #ifndef IS_MODULE
339 static
340 #endif
341 void *
342 gnupgext_enum_func( int what, int *sequence, int *class, int *vers )
343 {
344     void *ret;
345     int i = *sequence;
346
347     do {
348         if( i >= DIM(func_table) || i < 0 ) {
349             return NULL;
350         }
351         *class = func_table[i].class;
352         *vers  = func_table[i].version;
353         switch( *class ) {
354           case 11:
355           case 21:
356           case 31:
357             ret = &func_table[i].value;
358             break;
359           default:
360             ret = func_table[i].func;
361             break;
362         }
363         i++;
364     } while( what && what != *class );
365
366     *sequence = i;
367     return ret;
368 }
369
370
371
372
373 #ifndef IS_MODULE
374 void
375 _gcry_sha256_constructor(void)
376 {
377   _gcry_register_internal_cipher_extension (gnupgext_version,
378                                             gnupgext_enum_func );
379 }
380 #endif