No more warnings for AMD64 (at least when cross-compiling). Thus tehre is a
[gnupg.git] / g10 / seckey-cert.c
1 /* seckey-cert.c -  secret key certificate packet handling
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2006  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 2 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, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #include "gpg.h"
30 #include "util.h"
31 #include "packet.h"
32 #include "keydb.h"
33 #include "cipher.h"
34 #include "main.h"
35 #include "options.h"
36 #include "i18n.h"
37 #include "status.h"
38 #include "pkglue.h"
39
40 static int
41 do_check( PKT_secret_key *sk, const char *tryagain_text, int mode,
42           int *canceled )
43 {
44     gpg_error_t err;
45     byte *buffer;
46     u16 csum=0;
47     int i, res;
48     size_t nbytes;
49
50     if( sk->is_protected ) { /* remove the protection */
51         DEK *dek = NULL;
52         u32 keyid[4]; /* 4! because we need two of them */
53         gcry_cipher_hd_t cipher_hd=NULL;
54         PKT_secret_key *save_sk;
55
56         if( sk->protect.s2k.mode == 1001 ) {
57             log_info(_("secret key parts are not available\n"));
58             return G10ERR_GENERAL;
59         }
60         if( sk->protect.algo == CIPHER_ALGO_NONE )
61             BUG();
62         if( openpgp_cipher_test_algo( sk->protect.algo ) ) {
63             log_info(_("protection algorithm %d%s is not supported\n"),
64                         sk->protect.algo,sk->protect.algo==1?" (IDEA)":"" );
65             if (sk->protect.algo==CIPHER_ALGO_IDEA)
66               {
67                 write_status (STATUS_RSA_OR_IDEA);
68                 idea_cipher_warn (0);
69               }
70             return G10ERR_CIPHER_ALGO;
71         }
72         if(gcry_md_test_algo (sk->protect.s2k.hash_algo))
73           {
74             log_info(_("protection digest %d is not supported\n"),
75                      sk->protect.s2k.hash_algo);
76             return G10ERR_DIGEST_ALGO;
77           }
78         keyid_from_sk( sk, keyid );
79         keyid[2] = keyid[3] = 0;
80         if( !sk->is_primary ) {
81             keyid[2] = sk->main_keyid[0];
82             keyid[3] = sk->main_keyid[1];
83         }
84         dek = passphrase_to_dek( keyid, sk->pubkey_algo, sk->protect.algo,
85                                  &sk->protect.s2k, mode,
86                                  tryagain_text, canceled );
87         if (!dek && canceled && *canceled)
88             return G10ERR_GENERAL;
89
90
91         err = gcry_cipher_open (&cipher_hd, sk->protect.algo,
92                                 GCRY_CIPHER_MODE_CFB,
93                                 (GCRY_CIPHER_SECURE
94                                  | (sk->protect.algo >= 100 ?
95                                     0 : GCRY_CIPHER_ENABLE_SYNC)));
96         if (err)
97           log_fatal ("cipher open failed: %s\n", gpg_strerror (err) );
98
99         err = gcry_cipher_setkey (cipher_hd, dek->key, dek->keylen);
100         if (err)
101           log_fatal ("set key failed: %s\n", gpg_strerror (err) );
102
103         xfree(dek);
104         save_sk = copy_secret_key( NULL, sk );
105
106         gcry_cipher_setiv ( cipher_hd, sk->protect.iv, sk->protect.ivlen );
107
108         csum = 0;
109         if( sk->version >= 4 ) {
110             int ndata;
111             unsigned int ndatabits;
112             byte *p, *data;
113             u16 csumc = 0;
114
115             i = pubkey_get_npkey(sk->pubkey_algo);
116
117             assert ( gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE ));
118             p = gcry_mpi_get_opaque ( sk->skey[i], &ndatabits );
119             ndata = (ndatabits+7)/8;
120
121             if ( ndata > 1 )
122                 csumc = p[ndata-2] << 8 | p[ndata-1];
123             data = xmalloc_secure ( ndata );
124             gcry_cipher_decrypt ( cipher_hd, data, ndata, p, ndata );
125             gcry_mpi_release (sk->skey[i]); sk->skey[i] = NULL ;
126
127             p = data;
128             if (sk->protect.sha1chk) {
129                 /* This is the new SHA1 checksum method to detect
130                    tampering with the key as used by the Klima/Rosa
131                    attack */
132                 sk->csum = 0;
133                 csum = 1;
134                 if( ndata < 20 ) 
135                     log_error("not enough bytes for SHA-1 checksum\n");
136                 else {
137                     gcry_md_hd_t h;
138
139                     if ( gcry_md_open (&h, DIGEST_ALGO_SHA1, 1))
140                         BUG(); /* Algo not available. */
141                     gcry_md_write (h, data, ndata - 20);
142                     gcry_md_final (h);
143                     if (!memcmp (gcry_md_read (h, DIGEST_ALGO_SHA1),
144                                  data + ndata - 20, 20) ) 
145                       {
146                         /* Digest does match.  We have to keep the old
147                            style checksum in sk->csum, so that the
148                            test used for unprotected keys does work.
149                            This test gets used when we are adding new
150                            keys. */
151                         sk->csum = csum = checksum (data, ndata-20);
152                       } 
153                     gcry_md_close (h);
154                 }
155             }
156             else {
157                 if( ndata < 2 ) {
158                     log_error("not enough bytes for checksum\n");
159                     sk->csum = 0;
160                     csum = 1;
161                 }
162                 else {
163                     csum = checksum( data, ndata-2);
164                     sk->csum = data[ndata-2] << 8 | data[ndata-1];
165                     if ( sk->csum != csum ) {
166                         /* This is a PGP 7.0.0 workaround */
167                         sk->csum = csumc; /* take the encrypted one */
168                     }
169                 }
170             }
171
172             /* Must check it here otherwise the mpi_read_xx would fail
173                because the length may have an arbitrary value */
174             if( sk->csum == csum ) {
175                 for( ; i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
176                     if ( gcry_mpi_scan( &sk->skey[i], GCRYMPI_FMT_PGP,
177                                         p, ndata, &nbytes))
178                       {
179                         /* Checksum was okay, but not correctly
180                            decrypted.  */
181                         sk->csum = 0;
182                         csum = 1;
183                         break;
184                       }
185                     ndata -= nbytes;
186                     p += nbytes;
187                 }
188                 /* Note: at this point ndata should be 2 for a simple
189                    checksum or 20 for the sha1 digest */
190             }
191             xfree(data);
192         }
193         else {
194             for(i=pubkey_get_npkey(sk->pubkey_algo);
195                     i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
196                 byte *p;
197                 size_t ndata;
198                 unsigned int ndatabits;
199
200                 assert (gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE));
201                 p = gcry_mpi_get_opaque (sk->skey[i], &ndatabits);
202                 ndata = (ndatabits+7)/8;
203                 assert (ndata >= 2);
204                 assert (ndata == ((p[0] << 8 | p[1]) + 7)/8 + 2);
205                 buffer = xmalloc_secure (ndata);
206                 gcry_cipher_sync (cipher_hd);
207                 buffer[0] = p[0];
208                 buffer[1] = p[1];
209                 gcry_cipher_decrypt (cipher_hd, buffer+2, ndata-2,
210                                      p+2, ndata-2);
211                 csum += checksum (buffer, ndata);
212                 gcry_mpi_release (sk->skey[i]);
213
214                 err = gcry_mpi_scan( &sk->skey[i], GCRYMPI_FMT_USG,
215                                      buffer, ndata, &ndata );
216                 xfree (buffer);
217                 if (err)
218                   {
219                     /* Checksum was okay, but not correctly
220                        decrypted.  */
221                     sk->csum = 0;
222                     csum = 1;
223                     break;
224                   }
225 /*              csum += checksum_mpi (sk->skey[i]); */
226             }
227         }
228         gcry_cipher_close ( cipher_hd );
229
230         /* Now let's see whether we have used the correct passphrase. */
231         if( csum != sk->csum ) {
232             copy_secret_key( sk, save_sk );
233             passphrase_clear_cache ( keyid, NULL, sk->pubkey_algo );
234             free_secret_key( save_sk );
235             return gpg_error (GPG_ERR_BAD_PASSPHRASE);
236         }
237
238         /* The checksum may fail, so we also check the key itself. */
239         res = pk_check_secret_key ( sk->pubkey_algo, sk->skey );
240         if( res ) {
241             copy_secret_key( sk, save_sk );
242             passphrase_clear_cache ( keyid, NULL, sk->pubkey_algo );
243             free_secret_key( save_sk );
244             return gpg_error (GPG_ERR_BAD_PASSPHRASE);
245         }
246         free_secret_key( save_sk );
247         sk->is_protected = 0;
248     }
249     else { /* not protected, assume it is okay if the checksum is okay */
250         csum = 0;
251         for(i=pubkey_get_npkey(sk->pubkey_algo);
252                 i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
253             csum += checksum_mpi( sk->skey[i] );
254         }
255         if( csum != sk->csum )
256             return G10ERR_CHECKSUM;
257     }
258
259     return 0;
260 }
261
262
263
264 /****************
265  * Check the secret key
266  * Ask up to 3 (or n) times for a correct passphrase
267  * If n is negative, disable the key info prompt and make n=abs(n)
268  */
269 int
270 check_secret_key( PKT_secret_key *sk, int n )
271 {
272     int rc = gpg_error (GPG_ERR_BAD_PASSPHRASE);
273     int i,mode;
274
275     if (sk && sk->is_protected && sk->protect.s2k.mode == 1002)
276       return 0; /* Let the scdaemon handle this. */
277
278     if(n<0)
279       {
280         n=abs(n);
281         mode=1;
282       }
283     else
284       mode=0;
285
286     if( n < 1 )
287         n = 3; /* Use the default value */
288
289     for(i=0; i < n && gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE; i++ ) {
290         int canceled = 0;
291         const char *tryagain = NULL;
292         if (i) {
293             tryagain = N_("Invalid passphrase; please try again");
294             log_info (_("%s ...\n"), _(tryagain));
295         }
296         rc = do_check( sk, tryagain, mode, &canceled );
297         if ( gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
298              && is_status_enabled () ) {
299             u32 kid[2];
300             char buf[50];
301
302             keyid_from_sk( sk, kid );
303             sprintf(buf, "%08lX%08lX", (ulong)kid[0], (ulong)kid[1]);
304             write_status_text( STATUS_BAD_PASSPHRASE, buf );
305         }
306         if( have_static_passphrase() || canceled)
307             break;
308     }
309
310     if( !rc )
311         write_status( STATUS_GOOD_PASSPHRASE );
312
313     return rc;
314 }
315
316 /****************
317  * check whether the secret key is protected.
318  * Returns: 0 not protected, -1 on error or the protection algorithm
319  *                           -2 indicates a card stub.
320  *                           -3 indicates a not-online stub.
321  */
322 int
323 is_secret_key_protected( PKT_secret_key *sk )
324 {
325     return sk->is_protected?
326                sk->protect.s2k.mode == 1002? -2 :
327                sk->protect.s2k.mode == 1001? -3 : sk->protect.algo : 0;
328 }
329
330
331
332 /****************
333  * Protect the secret key with the passphrase from DEK
334  */
335 int
336 protect_secret_key( PKT_secret_key *sk, DEK *dek )
337 {
338     int i,j, rc = 0;
339     byte *buffer;
340     size_t nbytes;
341     u16 csum;
342
343     if( !dek )
344         return 0;
345
346     if( !sk->is_protected ) { /* okay, apply the protection */
347         gcry_cipher_hd_t cipher_hd=NULL;
348
349         if ( openpgp_cipher_test_algo ( sk->protect.algo ) ) {
350             /* Unsupport protection algorithm. */
351             rc = gpg_error (GPG_ERR_CIPHER_ALGO); 
352         }
353         else {
354             print_cipher_algo_note( sk->protect.algo );
355             
356             if ( gcry_cipher_open (&cipher_hd, sk->protect.algo,
357                                    GCRY_CIPHER_MODE_CFB,
358                                    (GCRY_CIPHER_SECURE
359                                     | (sk->protect.algo >= 100 ?
360                                        0 : GCRY_CIPHER_ENABLE_SYNC))) )
361               BUG();
362             if ( gcry_cipher_setkey ( cipher_hd, dek->key, dek->keylen ) )
363                 log_info(_("WARNING: Weak key detected"
364                            " - please change passphrase again.\n"));
365             sk->protect.ivlen = gcry_cipher_get_algo_blklen (sk->protect.algo);
366             assert( sk->protect.ivlen <= DIM(sk->protect.iv) );
367             if( sk->protect.ivlen != 8 && sk->protect.ivlen != 16 )
368                 BUG(); /* yes, we are very careful */
369             gcry_create_nonce (sk->protect.iv, sk->protect.ivlen);
370             gcry_cipher_setiv (cipher_hd, sk->protect.iv, sk->protect.ivlen);
371             if( sk->version >= 4 ) {
372                 byte *bufarr[PUBKEY_MAX_NSKEY];
373                 size_t narr[PUBKEY_MAX_NSKEY];
374                 unsigned int nbits[PUBKEY_MAX_NSKEY];
375                 int ndata=0;
376                 byte *p, *data;
377
378                 for (j=0, i = pubkey_get_npkey(sk->pubkey_algo);
379                         i < pubkey_get_nskey(sk->pubkey_algo); i++, j++ )
380                   {
381                     assert (!gcry_mpi_get_flag (sk->skey[i],
382                                                 GCRYMPI_FLAG_OPAQUE));
383                     if (gcry_mpi_aprint (GCRYMPI_FMT_USG, bufarr+j,
384                                          narr+j, sk->skey[i]))
385                       BUG();
386                     nbits[j] = gcry_mpi_get_nbits (sk->skey[i]);
387                     ndata += narr[j] + 2;
388                   }
389                 for ( ; j < PUBKEY_MAX_NSKEY; j++ )
390                   bufarr[j] = NULL;
391
392                 ndata += opt.simple_sk_checksum? 2 : 20; /* for checksum */
393
394                 data = xmalloc_secure( ndata );
395                 p = data;
396                 for(j=0; j < PUBKEY_MAX_NSKEY && bufarr[j]; j++ ) {
397                     p[0] = nbits[j] >> 8 ;
398                     p[1] = nbits[j];
399                     p += 2;
400                     memcpy(p, bufarr[j], narr[j] );
401                     p += narr[j];
402                     xfree(bufarr[j]);
403                 }
404                 
405                 if (opt.simple_sk_checksum) {
406                     log_info (_("generating the deprecated 16-bit checksum"
407                               " for secret key protection\n")); 
408                     csum = checksum( data, ndata-2);
409                     sk->csum = csum;
410                     *p++ =      csum >> 8;
411                     *p++ =      csum;
412                     sk->protect.sha1chk = 0;
413                 }
414                 else {
415                     gcry_md_hd_t h;
416
417                     if (gcry_md_open (&h, GCRY_MD_SHA1, 1))
418                       BUG(); /* Algo not available. */
419                     gcry_md_write (h, data, ndata - 20);
420                     gcry_md_final (h);
421                     memcpy (p, gcry_md_read (h, DIGEST_ALGO_SHA1), 20);
422                     p += 20;
423                     gcry_md_close (h);
424                     sk->csum = csum = 0;
425                     sk->protect.sha1chk = 1;
426                 }
427                 assert( p == data+ndata );
428
429                 gcry_cipher_encrypt (cipher_hd, data, ndata, NULL, 0);
430                 for (i = pubkey_get_npkey(sk->pubkey_algo);
431                      i < pubkey_get_nskey(sk->pubkey_algo); i++ )
432                   {
433                     gcry_mpi_release (sk->skey[i]);
434                     sk->skey[i] = NULL;
435                   }
436                 i = pubkey_get_npkey(sk->pubkey_algo);
437                 sk->skey[i] = gcry_mpi_set_opaque (NULL, data, ndata*8 );
438             }
439             else {
440                 csum = 0;
441                 for(i=pubkey_get_npkey(sk->pubkey_algo);
442                         i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
443                     byte *data;
444                     unsigned int nbits;
445
446                     csum += checksum_mpi (sk->skey[i]);
447
448                     if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer,
449                                          &nbytes, sk->skey[i] ))
450                       BUG();
451                     gcry_cipher_sync (cipher_hd);
452                     assert (!gcry_mpi_get_flag (sk->skey[i],
453                                                 GCRYMPI_FLAG_OPAQUE));
454
455                     data = xmalloc (nbytes+2);  /* fixme: need xtrymalloc. */
456                     nbits = gcry_mpi_get_nbits (sk->skey[i]);
457                     assert (nbytes == (nbits + 7)/8);
458                     data[0] = nbits >> 8;
459                     data[1] = nbits;
460                     gcry_cipher_encrypt (cipher_hd, data+2, nbytes,
461                                          buffer, nbytes);
462                     xfree( buffer );
463                     
464                     gcry_mpi_release (sk->skey[i]);
465                     sk->skey[i] = gcry_mpi_set_opaque (NULL,
466                                                        data, (nbytes+2)*8 );
467                 }
468                 sk->csum = csum;
469             }
470             sk->is_protected = 1;
471             gcry_cipher_close (cipher_hd);
472         }
473     }
474     return rc;
475 }
476