Fix preference setting in new keys
[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, 2009 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 "packet.h"
30 #include "keydb.h"
31 #include "cipher.h"
32 #include "main.h"
33 #include "options.h"
34 #include "i18n.h"
35 #include "status.h"
36 #include "pkglue.h"
37
38 #if 0 /* Not anymore used - kept for reference.  */
39 static int
40 do_check( PKT_secret_key *sk, const char *tryagain_text, int mode,
41           int *canceled )
42 {
43     gpg_error_t err;
44     byte *buffer;
45     u16 csum=0;
46     int i, res;
47     size_t nbytes;
48
49     if( sk->is_protected ) { /* remove the protection */
50         DEK *dek = NULL;
51         u32 keyid[4]; /* 4! because we need two of them */
52         gcry_cipher_hd_t cipher_hd=NULL;
53         PKT_secret_key *save_sk;
54
55         if( sk->protect.s2k.mode == 1001 ) {
56             log_info(_("secret key parts are not available\n"));
57             return G10ERR_UNU_SECKEY;
58         }
59         if( sk->protect.algo == CIPHER_ALGO_NONE )
60             BUG();
61         if( openpgp_cipher_test_algo( sk->protect.algo ) ) {
62             log_info(_("protection algorithm %d%s is not supported\n"),
63                         sk->protect.algo,sk->protect.algo==1?" (IDEA)":"" );
64             if (sk->protect.algo==CIPHER_ALGO_IDEA)
65               {
66                 write_status (STATUS_RSA_OR_IDEA);
67                 idea_cipher_warn (0);
68               }
69             return G10ERR_CIPHER_ALGO;
70         }
71         if(gcry_md_test_algo (sk->protect.s2k.hash_algo))
72           {
73             log_info(_("protection digest %d is not supported\n"),
74                      sk->protect.s2k.hash_algo);
75             return G10ERR_DIGEST_ALGO;
76           }
77         keyid_from_sk( sk, keyid );
78         keyid[2] = keyid[3] = 0;
79         if( !sk->is_primary ) {
80             keyid[2] = sk->main_keyid[0];
81             keyid[3] = sk->main_keyid[1];
82         }
83         dek = passphrase_to_dek( keyid, sk->pubkey_algo, sk->protect.algo,
84                                  &sk->protect.s2k, mode,
85                                  tryagain_text, canceled );
86         if (!dek && canceled && *canceled)
87             return GPG_ERR_CANCELED;
88
89
90         err = openpgp_cipher_open (&cipher_hd, sk->protect.algo,
91                                    GCRY_CIPHER_MODE_CFB,
92                                    (GCRY_CIPHER_SECURE
93                                     | (sk->protect.algo >= 100 ?
94                                        0 : GCRY_CIPHER_ENABLE_SYNC)));
95         if (err)
96           log_fatal ("cipher open failed: %s\n", gpg_strerror (err) );
97
98         err = gcry_cipher_setkey (cipher_hd, dek->key, dek->keylen);
99         if (err)
100           log_fatal ("set key failed: %s\n", gpg_strerror (err) );
101
102         xfree(dek);
103         save_sk = copy_secret_key( NULL, sk );
104
105         gcry_cipher_setiv ( cipher_hd, sk->protect.iv, sk->protect.ivlen );
106
107         csum = 0;
108         if( sk->version >= 4 ) {
109             int ndata;
110             unsigned int ndatabits;
111             byte *p, *data;
112             u16 csumc = 0;
113
114             i = pubkey_get_npkey(sk->pubkey_algo);
115
116             assert ( gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE ));
117             p = gcry_mpi_get_opaque ( sk->skey[i], &ndatabits );
118             ndata = (ndatabits+7)/8;
119
120             if ( ndata > 1 )
121                 csumc = p[ndata-2] << 8 | p[ndata-1];
122             data = xmalloc_secure ( ndata );
123             gcry_cipher_decrypt ( cipher_hd, data, ndata, p, ndata );
124             gcry_mpi_release (sk->skey[i]); sk->skey[i] = NULL ;
125
126             p = data;
127             if (sk->protect.sha1chk) {
128                 /* This is the new SHA1 checksum method to detect
129                    tampering with the key as used by the Klima/Rosa
130                    attack */
131                 sk->csum = 0;
132                 csum = 1;
133                 if( ndata < 20 ) 
134                     log_error("not enough bytes for SHA-1 checksum\n");
135                 else {
136                     gcry_md_hd_t h;
137
138                     if ( gcry_md_open (&h, DIGEST_ALGO_SHA1, 1))
139                         BUG(); /* Algo not available. */
140                     gcry_md_write (h, data, ndata - 20);
141                     gcry_md_final (h);
142                     if (!memcmp (gcry_md_read (h, DIGEST_ALGO_SHA1),
143                                  data + ndata - 20, 20) ) 
144                       {
145                         /* Digest does match.  We have to keep the old
146                            style checksum in sk->csum, so that the
147                            test used for unprotected keys does work.
148                            This test gets used when we are adding new
149                            keys. */
150                         sk->csum = csum = checksum (data, ndata-20);
151                       } 
152                     gcry_md_close (h);
153                 }
154             }
155             else {
156                 if( ndata < 2 ) {
157                     log_error("not enough bytes for checksum\n");
158                     sk->csum = 0;
159                     csum = 1;
160                 }
161                 else {
162                     csum = checksum( data, ndata-2);
163                     sk->csum = data[ndata-2] << 8 | data[ndata-1];
164                     if ( sk->csum != csum ) {
165                         /* This is a PGP 7.0.0 workaround */
166                         sk->csum = csumc; /* take the encrypted one */
167                     }
168                 }
169             }
170
171             /* Must check it here otherwise the mpi_read_xx would fail
172                because the length may have an arbitrary value */
173             if( sk->csum == csum ) {
174                 for( ; i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
175                     if ( gcry_mpi_scan( &sk->skey[i], GCRYMPI_FMT_PGP,
176                                         p, ndata, &nbytes))
177                       {
178                         /* Checksum was okay, but not correctly
179                            decrypted.  */
180                         sk->csum = 0;
181                         csum = 1;
182                         break;
183                       }
184                     ndata -= nbytes;
185                     p += nbytes;
186                 }
187                 /* Note: at this point ndata should be 2 for a simple
188                    checksum or 20 for the sha1 digest */
189             }
190             xfree(data);
191         }
192         else {
193             for(i=pubkey_get_npkey(sk->pubkey_algo);
194                     i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
195                 byte *p;
196                 size_t ndata;
197                 unsigned int ndatabits;
198
199                 assert (gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE));
200                 p = gcry_mpi_get_opaque (sk->skey[i], &ndatabits);
201                 ndata = (ndatabits+7)/8;
202                 assert (ndata >= 2);
203                 assert (ndata == ((p[0] << 8 | p[1]) + 7)/8 + 2);
204                 buffer = xmalloc_secure (ndata);
205                 gcry_cipher_sync (cipher_hd);
206                 buffer[0] = p[0];
207                 buffer[1] = p[1];
208                 gcry_cipher_decrypt (cipher_hd, buffer+2, ndata-2,
209                                      p+2, ndata-2);
210                 csum += checksum (buffer, ndata);
211                 gcry_mpi_release (sk->skey[i]);
212
213                 err = gcry_mpi_scan( &sk->skey[i], GCRYMPI_FMT_PGP,
214                                      buffer, ndata, &ndata );
215                 xfree (buffer);
216                 if (err)
217                   {
218                     /* Checksum was okay, but not correctly
219                        decrypted.  */
220                     sk->csum = 0;
221                     csum = 1;
222                     break;
223                   }
224 /*              csum += checksum_mpi (sk->skey[i]); */
225             }
226         }
227         gcry_cipher_close ( cipher_hd );
228
229         /* Now let's see whether we have used the correct passphrase. */
230         if( csum != sk->csum ) {
231             copy_secret_key( sk, save_sk );
232             passphrase_clear_cache ( keyid, NULL, sk->pubkey_algo );
233             free_secret_key( save_sk );
234             return gpg_error (GPG_ERR_BAD_PASSPHRASE);
235         }
236
237         /* The checksum may fail, so we also check the key itself. */
238         res = pk_check_secret_key ( sk->pubkey_algo, sk->skey );
239         if( res ) {
240             copy_secret_key( sk, save_sk );
241             passphrase_clear_cache ( keyid, NULL, sk->pubkey_algo );
242             free_secret_key( save_sk );
243             return gpg_error (GPG_ERR_BAD_PASSPHRASE);
244         }
245         free_secret_key( save_sk );
246         sk->is_protected = 0;
247     }
248     else { /* not protected, assume it is okay if the checksum is okay */
249         csum = 0;
250         for(i=pubkey_get_npkey(sk->pubkey_algo);
251                 i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
252             csum += checksum_mpi( sk->skey[i] );
253         }
254         if( csum != sk->csum )
255             return G10ERR_CHECKSUM;
256     }
257
258     return 0;
259 }
260 #endif /*0*/
261
262
263 /****************
264  * check whether the secret key is protected.
265  * Returns: 0 not protected, -1 on error or the protection algorithm
266  *                           -2 indicates a card stub.
267  *                           -3 indicates a not-online stub.
268  */
269 int
270 is_secret_key_protected (PKT_public_key *pk)
271 {
272   return 0; /* FIXME:  use agent_get_keyinfo?*/
273     /* return sk->is_protected? */
274     /*            sk->protect.s2k.mode == 1002? -2 : */
275     /*            sk->protect.s2k.mode == 1001? -3 : sk->protect.algo : 0; */
276 }