b08394e4addcf195f39020ff1a1d497a13b63d17
[gnupg.git] / g10 / pubkey-enc.c
1 /* pubkey-enc.c -  public key encoded packet handling
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "util.h"
30 #include "memory.h"
31 #include "packet.h"
32 #include "mpi.h"
33 #include "keydb.h"
34 #include "trustdb.h"
35 #include "cipher.h"
36 #include "status.h"
37 #include "options.h"
38 #include "main.h"
39 #include "i18n.h"
40 #include "pkglue.h"
41
42 static int get_it( PKT_pubkey_enc *k,
43                    DEK *dek, PKT_secret_key *sk, u32 *keyid );
44
45
46 /* check that the given algo is mentioned in one of the valid user IDs */
47 static int
48 is_algo_in_prefs ( KBNODE keyblock, preftype_t type, int algo )
49 {
50     KBNODE k;
51
52     for (k=keyblock; k; k=k->next) {
53         if (k->pkt->pkttype == PKT_USER_ID) {
54             PKT_user_id *uid = k->pkt->pkt.user_id;
55             prefitem_t *prefs = uid->prefs;
56             
57             if (uid->created && prefs &&
58                 !uid->is_revoked && !uid->is_expired ) {
59                 for (; prefs->type; prefs++ )
60                     if (prefs->type == type && prefs->value == algo)
61                         return 1;
62             }
63         }
64     }
65     return 0;
66 }
67
68
69 /****************
70  * Get the session key from a pubkey enc packet and return
71  * it in DEK, which should have been allocated in secure memory.
72  */
73 int
74 get_session_key( PKT_pubkey_enc *k, DEK *dek )
75 {
76     PKT_secret_key *sk = NULL;
77     int rc;
78
79     rc = openpgp_pk_test_algo (k->pubkey_algo, PUBKEY_USAGE_ENC);
80     if( rc )
81         goto leave;
82
83     if( (k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets ) {
84         sk = xcalloc (1, sizeof *sk );
85         sk->pubkey_algo = k->pubkey_algo; /* we want a pubkey with this algo*/
86         if( !(rc = get_seckey( sk, k->keyid )) )
87             rc = get_it( k, dek, sk, k->keyid );
88     }
89     else { /* anonymous receiver: Try all available secret keys */
90         void *enum_context = NULL;
91         u32 keyid[2];
92         char *p;
93
94         for(;;) {
95             if( sk )
96                 free_secret_key( sk );
97             sk = xcalloc (1, sizeof *sk );
98             rc=enum_secret_keys( &enum_context, sk, 1, 0);
99             if( rc ) {
100                 rc = GPG_ERR_NO_SECKEY;
101                 break;
102             }
103             if( sk->pubkey_algo != k->pubkey_algo )
104                 continue;
105             keyid_from_sk( sk, keyid );
106             log_info(_("anonymous recipient; trying secret key %08lX ...\n"),
107                      (ulong)keyid[1] );
108
109             if(!opt.try_all_secrets && !is_status_enabled())
110               {
111                 p=get_last_passphrase();
112                 set_next_passphrase(p);
113                 xfree (p);
114               }
115
116             rc = check_secret_key( sk, opt.try_all_secrets?1:-1 ); /* ask
117                                                                       only
118                                                                       once */
119             if( !rc )
120                 rc = get_it( k, dek, sk, keyid );
121             if( !rc ) {
122                 log_info(_("okay, we are the anonymous recipient.\n") );
123                 break;
124             }
125         }
126         enum_secret_keys( &enum_context, NULL, 0, 0 ); /* free context */
127     }
128
129   leave:
130     if( sk )
131         free_secret_key( sk );
132     return rc;
133 }
134
135
136 static int
137 get_it( PKT_pubkey_enc *enc, DEK *dek, PKT_secret_key *sk, u32 *keyid )
138 {
139     int rc;
140     gcry_mpi_t plain_dek  = NULL;
141     byte *frame = NULL;
142     unsigned n, nframe;
143     u16 csum, csum2;
144
145     rc = pk_decrypt (sk->pubkey_algo, &plain_dek, enc->data, sk->skey);
146     if( rc )
147       goto leave;
148     if ( gcry_mpi_aprint (GCRYMPI_FMT_USG, &frame, &nframe, plain_dek))
149       BUG();
150     gcry_mpi_release (plain_dek); plain_dek = NULL;
151
152     /* Now get the DEK (data encryption key) from the frame
153      *
154      * Old versions encode the DEK in in this format (msb is left):
155      *
156      *     0  1  DEK(16 bytes)  CSUM(2 bytes)  0  RND(n bytes) 2
157      *
158      * Later versions encode the DEK like this:
159      *
160      *     0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
161      *
162      * (mpi_get_buffer already removed the leading zero).
163      *
164      * RND are non-zero randow bytes.
165      * A   is the cipher algorithm
166      * DEK is the encryption key (session key) with length k
167      * CSUM
168      */
169     if( DBG_CIPHER )
170         log_printhex ("DEK frame:", frame, nframe );
171     n=0;
172     if( n + 7 > nframe )
173         { rc = GPG_ERR_WRONG_SECKEY; goto leave; }
174     if( frame[n] == 1 && frame[nframe-1] == 2 ) {
175         log_info(_("old encoding of the DEK is not supported\n"));
176         rc = GPG_ERR_CIPHER_ALGO;
177         goto leave;
178     }
179     if( frame[n] != 2 )  /* somethink is wrong */
180         { rc = GPG_ERR_WRONG_SECKEY; goto leave; }
181     for(n++; n < nframe && frame[n]; n++ ) /* skip the random bytes */
182         ;
183     n++; /* and the zero byte */
184     if( n + 4 > nframe )
185         { rc = GPG_ERR_WRONG_SECKEY; goto leave; }
186
187     dek->keylen = nframe - (n+1) - 2;
188     dek->algo = frame[n++];
189     if( dek->algo ==  CIPHER_ALGO_IDEA )
190         write_status(STATUS_RSA_OR_IDEA);
191     rc = openpgp_cipher_test_algo (dek->algo);
192     if( rc ) {
193         if( !opt.quiet && gpg_err_code (rc) == GPG_ERR_CIPHER_ALGO ) {
194             log_info(_("cipher algorithm %d%s is unknown or disabled\n"),
195                      dek->algo, dek->algo == CIPHER_ALGO_IDEA? " (IDEA)":"");
196             if(dek->algo==CIPHER_ALGO_IDEA)
197               idea_cipher_warn(0);
198         }
199         dek->algo = 0;
200         goto leave;
201     }
202     if( dek->keylen != gcry_cipher_get_algo_keylen (dek->algo) ) {
203         rc = GPG_ERR_WRONG_SECKEY;
204         goto leave;
205     }
206
207     /* copy the key to DEK and compare the checksum */
208     csum  = frame[nframe-2] << 8;
209     csum |= frame[nframe-1];
210     memcpy( dek->key, frame+n, dek->keylen );
211     for( csum2=0, n=0; n < dek->keylen; n++ )
212         csum2 += dek->key[n];
213     if( csum != csum2 ) {
214         rc = GPG_ERR_WRONG_SECKEY;
215         goto leave;
216     }
217     if( DBG_CIPHER )
218         log_printhex ("DEK is:", dek->key, dek->keylen );
219     /* check that the algo is in the preferences and whether it has expired */
220     {
221         PKT_public_key *pk = NULL;
222         KBNODE pkb = get_pubkeyblock (keyid);
223
224         if( !pkb ) {
225             rc = -1;
226             log_error("oops: public key not found for preference check\n");
227         }
228         else if( pkb->pkt->pkt.public_key->selfsigversion > 3
229             && dek->algo != CIPHER_ALGO_3DES
230             && !is_algo_in_prefs( pkb, PREFTYPE_SYM, dek->algo ) ) {
231             /* Don't print a note while we are not on verbose mode,
232              * the cipher is blowfish and the preferences have twofish
233              * listed */
234             if( opt.verbose || dek->algo != CIPHER_ALGO_BLOWFISH
235                 || !is_algo_in_prefs( pkb, PREFTYPE_SYM, CIPHER_ALGO_TWOFISH))
236                 log_info(_(
237                     "NOTE: cipher algorithm %d not found in preferences\n"),
238                                                                  dek->algo );
239         }
240
241         if (!rc) {
242             KBNODE k;
243             
244             for (k=pkb; k; k = k->next) {
245                 if (k->pkt->pkttype == PKT_PUBLIC_KEY 
246                     || k->pkt->pkttype == PKT_PUBLIC_SUBKEY){
247                     u32 aki[2];
248                     keyid_from_pk(k->pkt->pkt.public_key, aki);
249
250                     if (aki[0]==keyid[0] && aki[1]==keyid[1]) {
251                         pk = k->pkt->pkt.public_key;
252                         break;
253                     }
254                 }
255             }
256             if (!pk)
257                 BUG ();
258             if ( pk->expiredate && pk->expiredate <= make_timestamp() ) {
259                 log_info(_("NOTE: secret key %08lX expired at %s\n"),
260                          (ulong)keyid[1], asctimestamp( pk->expiredate) );
261             }
262         }
263
264         if ( pk &&  pk->is_revoked ) {
265             log_info( _("NOTE: key has been revoked") );
266             putc( '\n', log_get_stream() );
267             show_revocation_reason( pk, 1 );
268         }
269
270         release_kbnode (pkb);
271         rc = 0;
272     }
273
274
275   leave:
276     gcry_mpi_release (plain_dek);
277     xfree (frame);
278     return rc;
279 }
280
281
282 /****************
283  * Get the session key from the given string.
284  * String is supposed to be formatted as this:
285  *  <algo-id>:<even-number-of-hex-digits>
286  */
287 int
288 get_override_session_key( DEK *dek, const char *string )
289 {
290     const char *s;
291     int i;
292
293     if ( !string )
294         return GPG_ERR_BAD_KEY;
295     dek->algo = atoi(string);
296     if ( dek->algo < 1 )
297         return GPG_ERR_BAD_KEY;
298     if ( !(s = strchr ( string, ':' )) )
299         return GPG_ERR_BAD_KEY;
300     s++;
301     for(i=0; i < DIM(dek->key) && *s; i++, s +=2 ) {
302         int c = hextobyte ( s );
303         if (c == -1)
304             return GPG_ERR_BAD_KEY;
305         dek->key[i] = c;
306     }
307     if ( *s )
308         return GPG_ERR_BAD_KEY;
309     dek->keylen = i;
310     return 0;
311 }
312