Fix ECDSA 521 bit signing.
[gnupg.git] / g10 / seskey.c
1 /* seskey.c -  make sesssion keys etc.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2006, 2009, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #include "gpg.h"
28 #include "util.h"
29 #include "cipher.h"
30 #include "options.h"
31 #include "main.h"
32 #include "i18n.h"
33
34
35 /****************
36  * Make a session key and put it into DEK
37  */
38 void
39 make_session_key( DEK *dek )
40 {
41     gcry_cipher_hd_t chd;
42     int i, rc;
43
44     dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
45
46     if (openpgp_cipher_open (&chd, dek->algo, GCRY_CIPHER_MODE_CFB,
47                              (GCRY_CIPHER_SECURE
48                               | (dek->algo >= 100 ?
49                                  0 : GCRY_CIPHER_ENABLE_SYNC))) )
50       BUG();
51     gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM );
52     for (i=0; i < 16; i++ )
53       {
54         rc = gcry_cipher_setkey (chd, dek->key, dek->keylen);
55         if (!rc)
56           {
57             gcry_cipher_close (chd);
58             return;
59           }
60         if (gpg_err_code (rc) != GPG_ERR_WEAK_KEY)
61           BUG();
62         log_info(_("weak key created - retrying\n") );
63         /* Renew the session key until we get a non-weak key. */
64         gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM);
65       }
66     log_fatal (_("cannot avoid weak key for symmetric cipher; "
67                  "tried %d times!\n"), i);
68 }
69
70
71 /****************
72  * Encode the session key. NBITS is the number of bits which should be used
73  * for packing the session key.
74  * returns: A mpi with the session key (caller must free)
75  */
76 gcry_mpi_t
77 encode_session_key (int openpgp_pk_algo, DEK *dek, unsigned int nbits)
78 {
79   size_t nframe = (nbits+7) / 8;
80   byte *p;
81   byte *frame;
82   int i,n;
83   u16 csum;
84   gcry_mpi_t a;
85
86   if (DBG_CIPHER)
87     log_debug ("encode_session_key: encoding %d byte DEK", dek->keylen);
88
89   csum = 0;
90   for (p = dek->key, i=0; i < dek->keylen; i++)
91     csum += *p++;
92
93   /* Shortcut for ECDH.  It's padding is minimal to simply make the
94      output be a multiple of 8 bytes.  */
95   if (openpgp_pk_algo == PUBKEY_ALGO_ECDH)
96     {
97       /* Pad to 8 byte granulatiry; the padding byte is the number of
98        * padded bytes.
99        *
100        * A  DEK(k bytes)  CSUM(2 bytes) 0x 0x 0x 0x ... 0x
101        *                                +---- x times ---+
102        */
103       nframe = (( 1 + dek->keylen + 2 /* The value so far is always odd. */
104                   + 7 ) & (~7));
105
106       /* alg+key+csum fit and the size is congruent to 8.  */
107       assert (!(nframe%8) && nframe > 1 + dek->keylen + 2 );
108
109       frame = xmalloc_secure (nframe);
110       n = 0;
111       frame[n++] = dek->algo;
112       memcpy (frame+n, dek->key, dek->keylen);
113       n += dek->keylen;
114       frame[n++] = csum >> 8;
115       frame[n++] = csum;
116       i = nframe - n;         /* Number of padded bytes.  */
117       memset (frame+n, i, i); /* Use it as the value of each padded byte.  */
118       assert (n+i == nframe);
119
120       if (DBG_CIPHER)
121         log_debug ("encode_session_key: "
122                    "[%d] %02x  %02x %02x ...  %02x %02x %02x\n",
123                    nframe, frame[0], frame[1], frame[2],
124                    frame[nframe-3], frame[nframe-2], frame[nframe-1]);
125
126       if (gcry_mpi_scan (&a, GCRYMPI_FMT_USG, frame, nframe, &nframe))
127         BUG();
128       xfree(frame);
129       return a;
130     }
131
132   /* The current limitation is that we can only use a session key
133    * whose length is a multiple of BITS_PER_MPI_LIMB
134    * I think we can live with that.
135    */
136   if (dek->keylen + 7 > nframe || !nframe)
137     log_bug ("can't encode a %d bit key in a %d bits frame\n",
138              dek->keylen*8, nbits );
139
140   /* We encode the session key in this way:
141    *
142    *       0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
143    *
144    * (But how can we store the leading 0 - the external representaion
145    *  of MPIs doesn't allow leading zeroes =:-)
146    *
147    * RND are non-zero random bytes.
148    * A   is the cipher algorithm
149    * DEK is the encryption key (session key) length k depends on the
150    *       cipher algorithm (20 is used with blowfish160).
151    * CSUM is the 16 bit checksum over the DEK
152    */
153
154   frame = xmalloc_secure( nframe );
155   n = 0;
156   frame[n++] = 0;
157   frame[n++] = 2;
158   i = nframe - 6 - dek->keylen;
159   assert( i > 0 );
160   p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
161   /* Replace zero bytes by new values.  */
162   for (;;)
163     {
164       int j, k;
165       byte *pp;
166
167       /* Count the zero bytes. */
168       for (j=k=0; j < i; j++ )
169         if (!p[j])
170           k++;
171       if (!k)
172         break; /* Okay: no zero bytes. */
173       k += k/128 + 3; /* Better get some more. */
174       pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
175       for (j=0; j < i && k ;)
176         {
177           if (!p[j])
178             p[j] = pp[--k];
179           if (p[j])
180             j++;
181         }
182       xfree (pp);
183     }
184   memcpy (frame+n, p, i);
185   xfree (p);
186   n += i;
187   frame[n++] = 0;
188   frame[n++] = dek->algo;
189   memcpy (frame+n, dek->key, dek->keylen );
190   n += dek->keylen;
191   frame[n++] = csum >>8;
192   frame[n++] = csum;
193   assert (n == nframe);
194   if (gcry_mpi_scan( &a, GCRYMPI_FMT_USG, frame, n, &nframe))
195     BUG();
196   xfree (frame);
197   return a;
198 }
199
200
201 static gcry_mpi_t
202 do_encode_md( gcry_md_hd_t md, int algo, size_t len, unsigned nbits,
203               const byte *asn, size_t asnlen )
204 {
205     size_t nframe = (nbits+7) / 8;
206     byte *frame;
207     int i,n;
208     gcry_mpi_t a;
209
210     if( len + asnlen + 4  > nframe )
211       log_bug ("can't encode a %d bit MD into a %d bits frame, algo=%d\n",
212                (int)(len*8), (int)nbits, algo);
213
214     /* We encode the MD in this way:
215      *
216      *     0  1 PAD(n bytes)   0  ASN(asnlen bytes)  MD(len bytes)
217      *
218      * PAD consists of FF bytes.
219      */
220     frame = gcry_md_is_secure (md)? xmalloc_secure (nframe) : xmalloc (nframe);
221     n = 0;
222     frame[n++] = 0;
223     frame[n++] = 1; /* block type */
224     i = nframe - len - asnlen -3 ;
225     assert( i > 1 );
226     memset( frame+n, 0xff, i ); n += i;
227     frame[n++] = 0;
228     memcpy( frame+n, asn, asnlen ); n += asnlen;
229     memcpy( frame+n, gcry_md_read (md, algo), len ); n += len;
230     assert( n == nframe );
231
232     if (gcry_mpi_scan( &a, GCRYMPI_FMT_USG, frame, n, &nframe ))
233         BUG();
234     xfree(frame);
235
236     /* Note that PGP before version 2.3 encoded the MD as:
237      *
238      *   0   1   MD(16 bytes)   0   PAD(n bytes)   1
239      *
240      * The MD is always 16 bytes here because it's always MD5.  We do
241      * not support pre-v2.3 signatures, but I'm including this comment
242      * so the information is easily found in the future.
243      */
244
245     return a;
246 }
247
248
249 /****************
250  * Encode a message digest into an MPI.
251  * If it's for a DSA signature, make sure that the hash is large
252  * enough to fill up q.  If the hash is too big, take the leftmost
253  * bits.
254  */
255 gcry_mpi_t
256 encode_md_value (PKT_public_key *pk, gcry_md_hd_t md, int hash_algo)
257 {
258   gcry_mpi_t frame;
259   int pkalgo;
260   size_t mdlen;
261
262   assert (hash_algo);
263   assert (pk);
264
265   pkalgo = map_pk_openpgp_to_gcry (pk->pubkey_algo);
266
267   if (pkalgo == GCRY_PK_DSA || pkalgo == GCRY_PK_ECDSA)
268     {
269       /* It's a DSA signature, so find out the size of q.  */
270
271       size_t qbits = gcry_mpi_get_nbits (pk->pkey[1]);
272
273       /* pkey[1] is Q for ECDSA, which is an uncompressed point,
274          i.e.  04 <x> <y>  */
275       if (pkalgo == GCRY_PK_ECDSA)
276         qbits = ecdsa_qbits_from_Q (qbits);
277
278       /* Make sure it is a multiple of 8 bits. */
279
280       if ((qbits%8))
281         {
282           log_error(_("DSA requires the hash length to be a"
283                       " multiple of 8 bits\n"));
284           return NULL;
285         }
286
287       /* Don't allow any q smaller than 160 bits.  This might need a
288          revisit as the DSA2 design firms up, but for now, we don't
289          want someone to issue signatures from a key with a 16-bit q
290          or something like that, which would look correct but allow
291          trivial forgeries.  Yes, I know this rules out using MD5 with
292          DSA. ;) */
293       if (qbits < 160)
294         {
295           log_error (_("%s key %s uses an unsafe (%zu bit) hash\n"),
296                      gcry_pk_algo_name (pkalgo), keystr_from_pk (pk), qbits);
297           return NULL;
298         }
299
300       /* Check if we're too short.  Too long is safe as we'll
301          automatically left-truncate.
302
303          FIXME:  Check against FIPS.
304          This checks would require the use of SHA512 with ECDSA 512.  I
305          think this is overkill to fail in this case.  Therefore,
306          relax the check, but only for ECDSA keys. We may need to
307          adjust it later for general case.  (Note that the check will
308          never pass for ECDSA 521 anyway as the only hash that
309          intended to match it is SHA 512, but 512 < 521).  */
310       mdlen = gcry_md_get_algo_dlen (hash_algo);
311       if (mdlen < ((pkalgo == GCRY_PK_ECDSA && qbits > 521) ? 512: qbits)/8)
312         {
313           log_error (_("%s key %s requires a %zu bit or larger hash "
314                        "(hash is %s\n"),
315                      gcry_pk_algo_name (pkalgo),
316                      keystr_from_pk(pk), qbits,
317                      gcry_md_algo_name (hash_algo));
318           return NULL;
319         }
320
321      /* By passing MDLEN as length to mpi_scan, we do the truncation
322         of the hash.
323
324         Note that in case of ECDSA 521 the hash is always smaller
325         than the key size.  */
326       if (gcry_mpi_scan (&frame, GCRYMPI_FMT_USG,
327                          gcry_md_read (md, hash_algo), mdlen, NULL))
328         BUG();
329     }
330   else
331     {
332       gpg_error_t rc;
333       byte *asn;
334       size_t asnlen;
335
336       rc = gcry_md_algo_info (hash_algo, GCRYCTL_GET_ASNOID, NULL, &asnlen);
337       if (rc)
338         log_fatal ("can't get OID of digest algorithm %d: %s\n",
339                    hash_algo, gpg_strerror (rc));
340       asn = xtrymalloc (asnlen);
341       if (!asn)
342         return NULL;
343       if ( gcry_md_algo_info (hash_algo, GCRYCTL_GET_ASNOID, asn, &asnlen) )
344         BUG();
345       frame = do_encode_md (md, hash_algo, gcry_md_get_algo_dlen (hash_algo),
346                             gcry_mpi_get_nbits (pk->pkey[0]), asn, asnlen);
347       xfree (asn);
348     }
349
350   return frame;
351 }