Truncate the DSA hash; fixes regression.
[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
261   assert (hash_algo);
262   assert (pk);
263
264   pkalgo = map_pk_openpgp_to_gcry (pk->pubkey_algo);
265
266   if (pkalgo == GCRY_PK_DSA || pkalgo == GCRY_PK_ECDSA)
267     {
268       /* It's a DSA signature, so find out the size of q.  */
269
270       size_t qbytes = gcry_mpi_get_nbits (pk->pkey[1]);
271
272       /* pkey[1] is Q for ECDSA, which is an uncompressed point,
273          i.e.  04 <x> <y>  */
274       if (pkalgo == GCRY_PK_ECDSA)
275         qbytes = ecdsa_qbits_from_Q (qbytes);
276       
277       /* Make sure it is a multiple of 8 bits. */
278       
279       if (qbytes%8)
280         {
281           log_error(_("DSA requires the hash length to be a"
282                       " multiple of 8 bits\n"));
283           return NULL;
284         }
285
286       /* Don't allow any q smaller than 160 bits.  This might need a
287          revisit as the DSA2 design firms up, but for now, we don't
288          want someone to issue signatures from a key with a 16-bit q
289          or something like that, which would look correct but allow
290          trivial forgeries.  Yes, I know this rules out using MD5 with
291          DSA. ;) */
292       if (qbytes < 160)
293         {
294           log_error (_("%s key %s uses an unsafe (%zu bit) hash\n"),
295                      gcry_pk_algo_name (pkalgo), keystr_from_pk (pk), qbytes);
296           return NULL;
297         }
298       
299       qbytes /= 8;
300
301       /* Check if we're too short.  Too long is safe as we'll
302          automatically left-truncate. 
303
304          FIXME:  Check against FIPS.
305          This checks would require the use of SHA512 with ECDSA 512.  I
306          think this is overkill to fail in this case.  Therefore,
307          relax the check, but only for ECDSA keys. We may need to
308          adjust it later for general case.  (Note that the check will
309          never pass for ECDSA 521 anyway as the only hash that
310          intended to match it is SHA 512, but 512 < 521).  */
311       if (gcry_md_get_algo_dlen (hash_algo) 
312           < ((pkalgo == GCRY_PK_ECDSA && qbytes > (521)/8) ? 512/8 : qbytes))
313         {
314           log_error (_("%s key %s requires a %zu bit or larger hash "
315                        "(hash is %s\n"),
316                      gcry_pk_algo_name (pkalgo),
317                      keystr_from_pk(pk), qbytes*8,
318                      gcry_md_algo_name (hash_algo));
319           return NULL;
320         }
321
322       /* By passing QBYTES as length to mpi_scan, we do the truncation
323          of the hash.
324
325          Note that in case of ECDSA 521 the hash is always smaller
326          than the key size.  */
327       if (gcry_mpi_scan (&frame, GCRYMPI_FMT_USG,
328                          gcry_md_read (md, hash_algo), qbytes, &qbytes))
329         BUG();
330     }
331   else
332     {
333       gpg_error_t rc;
334       byte *asn;
335       size_t asnlen;
336
337       rc = gcry_md_algo_info (hash_algo, GCRYCTL_GET_ASNOID, NULL, &asnlen);
338       if (rc)
339         log_fatal ("can't get OID of digest algorithm %d: %s\n",
340                    hash_algo, gpg_strerror (rc));
341       asn = xtrymalloc (asnlen);
342       if (!asn)
343         return NULL;
344       if ( gcry_md_algo_info (hash_algo, GCRYCTL_GET_ASNOID, asn, &asnlen) )
345         BUG();
346       frame = do_encode_md (md, hash_algo, gcry_md_get_algo_dlen (hash_algo),
347                             gcry_mpi_get_nbits (pk->pkey[0]), asn, asnlen);
348       xfree (asn);
349     }
350
351   return frame;
352 }