9270ef24dc77443eda534755dd50c9022b403663
[gnupg.git] / cipher / sha512.c
1 /* sha512.c - SHA384 and SHA512 hash functions
2  *      Copyright (C) 2003 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 2 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, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21  */
22
23
24 /*  Test vectors from FIPS-180-2:
25  *
26  *  "abc"
27  * 384:
28  *  CB00753F 45A35E8B B5A03D69 9AC65007 272C32AB 0EDED163
29  *  1A8B605A 43FF5BED 8086072B A1E7CC23 58BAECA1 34C825A7
30  * 512:
31  *  DDAF35A1 93617ABA CC417349 AE204131 12E6FA4E 89A97EA2 0A9EEEE6 4B55D39A
32  *  2192992A 274FC1A8 36BA3C23 A3FEEBBD 454D4423 643CE80E 2A9AC94F A54CA49F
33  *
34  *  "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
35  * 384:
36  *  09330C33 F71147E8 3D192FC7 82CD1B47 53111B17 3B3B05D2
37  *  2FA08086 E3B0F712 FCC7C71A 557E2DB9 66C3E9FA 91746039
38  * 512:
39  *  8E959B75 DAE313DA 8CF4F728 14FC143F 8F7779C6 EB9F7FA1 7299AEAD B6889018
40  *  501D289E 4900F7E4 331B99DE C4B5433A C7D329EE B6DD2654 5E96E55B 874BE909
41  *
42  *  "a" x 1000000
43  * 384:
44  *  9D0E1809 716474CB 086E834E 310A4A1C ED149E9C 00F24852
45  *  7972CEC5 704C2A5B 07B8B3DC 38ECC4EB AE97DDD8 7F3D8985
46  * 512:
47  *  E718483D 0CE76964 4E2E42C7 BC15B463 8E1F98B1 3B204428 5632A803 AFA973EB
48  *  DE0FF244 877EA60A 4CB0432C E577C31B EB009C5C 2C49AA2E 4EADB217 AD8CC09B
49  */
50
51
52 #include <config.h>
53 #include <string.h>
54 #include "util.h"
55 #include "algorithms.h"
56
57
58 typedef struct {
59     u64  h0,h1,h2,h3,h4,h5,h6,h7;
60     u64  nblocks;
61     byte buf[128];
62     int  count;
63 } SHA512_CONTEXT;
64
65 static void
66 burn_stack (int bytes)
67 {
68     char buf[128];
69
70     wipememory(buf,sizeof buf);
71     bytes -= sizeof buf;
72     if (bytes > 0)
73         burn_stack (bytes);
74 }
75
76
77 void
78 sha512_init( SHA512_CONTEXT *hd )
79 {
80     hd->h0 = 0x6a09e667f3bcc908;
81     hd->h1 = 0xbb67ae8584caa73b;
82     hd->h2 = 0x3c6ef372fe94f82b;
83     hd->h3 = 0xa54ff53a5f1d36f1;
84     hd->h4 = 0x510e527fade682d1;
85     hd->h5 = 0x9b05688c2b3e6c1f;
86     hd->h6 = 0x1f83d9abfb41bd6b;
87     hd->h7 = 0x5be0cd19137e2179;
88
89     hd->nblocks = 0;
90     hd->count = 0;
91 }
92
93 void
94 sha384_init( SHA512_CONTEXT *hd )
95 {
96   hd->h0 = 0xcbbb9d5dc1059ed8;
97   hd->h1 = 0x629a292a367cd507;
98   hd->h2 = 0x9159015a3070dd17;
99   hd->h3 = 0x152fecd8f70e5939;
100   hd->h4 = 0x67332667ffc00b31;
101   hd->h5 = 0x8eb44a8768581511;
102   hd->h6 = 0xdb0c2e0d64f98fa7;
103   hd->h7 = 0x47b5481dbefa4fa4;
104
105   hd->nblocks = 0;
106   hd->count = 0;
107 }
108
109
110 /****************
111  * Transform the message W which consists of 16 64-bit-words
112  */
113 static void
114 transform( SHA512_CONTEXT *hd, byte *data )
115 {
116   u64 a,b,c,d,e,f,g,h;
117   u64 w[80];
118   int t;
119   static const u64 k[]=
120     {
121       0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f,
122       0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019,
123       0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242,
124       0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
125       0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
126       0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
127       0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275,
128       0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
129       0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f,
130       0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
131       0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc,
132       0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
133       0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6,
134       0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001,
135       0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
136       0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
137       0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99,
138       0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
139       0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc,
140       0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
141       0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915,
142       0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207,
143       0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba,
144       0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
145       0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
146       0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
147       0x5fcb6fab3ad6faec, 0x6c44198c4a475817
148     };
149
150   /* get values from the chaining vars */
151   a = hd->h0;
152   b = hd->h1;
153   c = hd->h2;
154   d = hd->h3;
155   e = hd->h4;
156   f = hd->h5;
157   g = hd->h6;
158   h = hd->h7;
159
160 #ifdef BIG_ENDIAN_HOST
161   memcpy( w, data, 128 );
162 #else
163   {
164     int i;
165     byte *p2;
166
167     for(i=0, p2=(byte*)w; i < 16; i++, p2 += 8 )
168       {
169         p2[7] = *data++;
170         p2[6] = *data++;
171         p2[5] = *data++;
172         p2[4] = *data++;
173         p2[3] = *data++;
174         p2[2] = *data++;
175         p2[1] = *data++;
176         p2[0] = *data++;
177       }
178   }
179 #endif
180
181 #define ROTR(x,n) (((x)>>(n)) | ((x)<<(64-(n))))
182 #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
183 #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
184 #define Sum0(x) (ROTR((x),28) ^ ROTR((x),34) ^ ROTR((x),39))
185 #define Sum1(x) (ROTR((x),14) ^ ROTR((x),18) ^ ROTR((x),41))
186 #define S0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
187 #define S1(x) (ROTR((x),19) ^ ROTR((x),61) ^ ((x)>>6))
188
189   for(t=16;t<80;t++)
190     w[t] = S1(w[t-2]) + w[t-7] + S0(w[t-15]) + w[t-16];
191
192   for(t=0;t<80;t++)
193     {
194       u64 t1,t2;
195
196       t1=h+Sum1(e)+Ch(e,f,g)+k[t]+w[t];
197       t2=Sum0(a)+Maj(a,b,c);
198       h=g;
199       g=f;
200       f=e;
201       e=d+t1;
202       d=c;
203       c=b;
204       b=a;
205       a=t1+t2;
206
207       /* printf("t=%d a=%016llX b=%016llX c=%016llX d=%016llX e=%016llX f=%016llX g=%016llX h=%016llX\n",t,a,b,c,d,e,f,g,h); */
208     }
209
210   /* update chaining vars */
211   hd->h0 += a;
212   hd->h1 += b;
213   hd->h2 += c;
214   hd->h3 += d;
215   hd->h4 += e;
216   hd->h5 += f;
217   hd->h6 += g;
218   hd->h7 += h;
219 }
220
221
222 /* Update the message digest with the contents
223  * of INBUF with length INLEN.
224  */
225 static void
226 sha512_write( SHA512_CONTEXT *hd, byte *inbuf, size_t inlen)
227 {
228     if( hd->count == 128 ) { /* flush the buffer */
229         transform( hd, hd->buf );
230         burn_stack (768);
231         hd->count = 0;
232         hd->nblocks++;
233     }
234     if( !inbuf )
235         return;
236     if( hd->count ) {
237         for( ; inlen && hd->count < 128; inlen-- )
238             hd->buf[hd->count++] = *inbuf++;
239         sha512_write( hd, NULL, 0 );
240         if( !inlen )
241             return;
242     }
243
244     while( inlen >= 128 ) {
245         transform( hd, inbuf );
246         hd->count = 0;
247         hd->nblocks++;
248         inlen -= 128;
249         inbuf += 128;
250     }
251     burn_stack (768);
252     for( ; inlen && hd->count < 128; inlen-- )
253         hd->buf[hd->count++] = *inbuf++;
254 }
255
256
257 /* The routine final terminates the computation and
258  * returns the digest.
259  * The handle is prepared for a new cycle, but adding bytes to the
260  * handle will the destroy the returned buffer.
261  * Returns: 64 bytes representing the digest.  When used for sha384,
262  * we take the leftmost 48 of those bytes.
263  */
264
265 static void
266 sha512_final(SHA512_CONTEXT *hd)
267 {
268     u64 t, msb, lsb;
269     byte *p;
270
271     sha512_write(hd, NULL, 0); /* flush */;
272
273     t = hd->nblocks;
274     /* multiply by 128 to make a byte count */
275     lsb = t << 7;
276     msb = t >> 57;
277     /* add the count */
278     t = lsb;
279     if( (lsb += hd->count) < t )
280         msb++;
281     /* multiply by 8 to make a bit count */
282     t = lsb;
283     lsb <<= 3;
284     msb <<= 3;
285     msb |= t >> 61;
286
287     if( hd->count < 112 ) { /* enough room */
288         hd->buf[hd->count++] = 0x80; /* pad */
289         while( hd->count < 112 )
290             hd->buf[hd->count++] = 0;  /* pad */
291     }
292     else { /* need one extra block */
293         hd->buf[hd->count++] = 0x80; /* pad character */
294         while( hd->count < 128 )
295             hd->buf[hd->count++] = 0;
296         sha512_write(hd, NULL, 0);  /* flush */;
297         memset(hd->buf, 0, 112 ); /* fill next block with zeroes */
298     }
299     /* append the 128 bit count */
300     hd->buf[112] = msb >> 56;
301     hd->buf[113] = msb >> 48;
302     hd->buf[114] = msb >> 40;
303     hd->buf[115] = msb >> 32;
304     hd->buf[116] = msb >> 24;
305     hd->buf[117] = msb >> 16;
306     hd->buf[118] = msb >>  8;
307     hd->buf[119] = msb     ;
308
309     hd->buf[120] = lsb >> 56;
310     hd->buf[121] = lsb >> 48;
311     hd->buf[122] = lsb >> 40;
312     hd->buf[123] = lsb >> 32;
313     hd->buf[124] = lsb >> 24;
314     hd->buf[125] = lsb >> 16;
315     hd->buf[126] = lsb >>  8;
316     hd->buf[127] = lsb     ;
317     transform( hd, hd->buf );
318     burn_stack (768);
319
320     p = hd->buf;
321   #ifdef BIG_ENDIAN_HOST
322     #define X(a) do { *(u64*)p = hd->h##a ; p += 8; } while(0)
323   #else /* little endian */
324     #define X(a) do { *p++ = hd->h##a >> 56; *p++ = hd->h##a >> 48;      \
325                       *p++ = hd->h##a >> 40; *p++ = hd->h##a >> 32;      \
326                       *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;      \
327                       *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
328   #endif
329     X(0);
330     X(1);
331     X(2);
332     X(3);
333     X(4);
334     X(5);
335     /* Note that these last two chunks are included even for SHA384.
336        We just ignore them. */
337     X(6);
338     X(7);
339   #undef X
340 }
341
342 static byte *
343 sha512_read( SHA512_CONTEXT *hd )
344 {
345     return hd->buf;
346 }
347
348 /****************
349  * Return some information about the algorithm.  We need algo here to
350  * distinguish different flavors of the algorithm.
351  * Returns: A pointer to string describing the algorithm or NULL if
352  *          the ALGO is invalid.
353  */
354 const char *
355 sha512_get_info( int algo, size_t *contextsize,
356                  byte **r_asnoid, int *r_asnlen, int *r_mdlen,
357                  void (**r_init)( void *c ),
358                  void (**r_write)( void *c, byte *buf, size_t nbytes ),
359                  void (**r_final)( void *c ),
360                  byte *(**r_read)( void *c )
361                  )
362 {
363   static byte asn[] = /* Object ID is 2.16.840.1.101.3.4.2.3 */
364     { 
365       0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
366       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
367       0x00, 0x04, 0x40
368     };
369
370     if( algo != 10 )
371         return NULL;
372
373     *contextsize = sizeof(SHA512_CONTEXT);
374     *r_asnoid = asn;
375     *r_asnlen = DIM(asn);
376     *r_mdlen = 64;
377     *(void  (**)(SHA512_CONTEXT *))r_init                 = sha512_init;
378     *(void  (**)(SHA512_CONTEXT *, byte*, size_t))r_write = sha512_write;
379     *(void  (**)(SHA512_CONTEXT *))r_final                = sha512_final;
380     *(byte *(**)(SHA512_CONTEXT *))r_read                 = sha512_read;
381
382     return "SHA512";
383 }
384
385 /* SHA384 is really a truncated SHA512 with a different
386    initialization */
387 const char *
388 sha384_get_info( int algo, size_t *contextsize,
389                  byte **r_asnoid, int *r_asnlen, int *r_mdlen,
390                  void (**r_init)( void *c ),
391                  void (**r_write)( void *c, byte *buf, size_t nbytes ),
392                  void (**r_final)( void *c ),
393                  byte *(**r_read)( void *c )
394                  )
395 {
396   static byte asn[] = /* Object ID is 2.16.840.1.101.3.4.2.2 */
397     {
398       0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
399       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
400       0x00, 0x04, 0x30
401     };
402
403     if( algo != 9 )
404         return NULL;
405
406     *contextsize = sizeof(SHA512_CONTEXT);
407     *r_asnoid = asn;
408     *r_asnlen = DIM(asn);
409     *r_mdlen = 48;
410     *(void  (**)(SHA512_CONTEXT *))r_init                 = sha384_init;
411     *(void  (**)(SHA512_CONTEXT *, byte*, size_t))r_write = sha512_write;
412     *(void  (**)(SHA512_CONTEXT *))r_final                = sha512_final;
413     *(byte *(**)(SHA512_CONTEXT *))r_read                 = sha512_read;
414
415     return "SHA384";
416 }