Integrating http://code.google.com/p/gnupg-ecc/source/detail?r=15 .
[gnupg.git] / g10 / pubkey-enc.c
1 /* pubkey-enc.c - Process a public key encoded packet.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2006, 2009,
3  *               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 "packet.h"
30 #include "keydb.h"
31 #include "trustdb.h"
32 #include "cipher.h"
33 #include "status.h"
34 #include "options.h"
35 #include "main.h"
36 #include "i18n.h"
37 #include "pkglue.h"
38 #include "call-agent.h"
39
40
41 static gpg_error_t get_it (PKT_pubkey_enc *k,
42                            DEK *dek, PKT_public_key *sk, u32 *keyid);
43
44
45 /* Check that the given algo is mentioned in one of the valid user-ids. */
46 static int
47 is_algo_in_prefs (kbnode_t keyblock, preftype_t type, int algo)
48 {
49   kbnode_t k;
50
51   for (k = keyblock; k; k = k->next)
52     {
53       if (k->pkt->pkttype == PKT_USER_ID)
54         {
55           PKT_user_id *uid = k->pkt->pkt.user_id;
56           prefitem_t *prefs = uid->prefs;
57
58           if (uid->created && prefs && !uid->is_revoked && !uid->is_expired)
59             {
60               for (; prefs->type; prefs++)
61                 if (prefs->type == type && prefs->value == algo)
62                   return 1;
63             }
64         }
65     }
66   return 0;
67 }
68
69
70 /*
71  * Get the session key from a pubkey enc packet and return it in DEK,
72  * which should have been allocated in secure memory by the caller.
73  */
74 gpg_error_t
75 get_session_key (PKT_pubkey_enc * k, DEK * dek)
76 {
77   PKT_public_key *sk = NULL;
78   int rc;
79
80   rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
81   if (rc)
82     goto leave;
83
84   if ((k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets)
85     {
86       sk = xmalloc_clear (sizeof *sk);
87       sk->pubkey_algo = k->pubkey_algo; /* We want a pubkey with this algo.  */
88       if (!(rc = get_seckey (sk, k->keyid)))
89         rc = get_it (k, dek, sk, k->keyid);
90     }
91   else if (opt.skip_hidden_recipients)
92     rc = gpg_error (GPG_ERR_NO_SECKEY);
93   else  /* Anonymous receiver: Try all available secret keys.  */
94     {
95       void *enum_context = NULL;
96       u32 keyid[2];
97
98       for (;;)
99         {
100           if (sk)
101             free_public_key (sk);
102           sk = xmalloc_clear (sizeof *sk);
103           rc = enum_secret_keys (&enum_context, sk);
104           if (rc)
105             {
106               rc = G10ERR_NO_SECKEY;
107               break;
108             }
109           if (sk->pubkey_algo != k->pubkey_algo)
110             continue;
111           if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
112             continue;
113           keyid_from_pk (sk, keyid);
114           log_info (_("anonymous recipient; trying secret key %s ...\n"),
115                     keystr (keyid));
116
117           rc = get_it (k, dek, sk, keyid);
118           if (!rc)
119             {
120               log_info (_("okay, we are the anonymous recipient.\n"));
121               break;
122             }
123           else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
124             break; /* Don't try any more secret keys.  */
125         }
126       enum_secret_keys (&enum_context, NULL);  /* free context */
127     }
128
129 leave:
130   if (sk)
131     free_public_key (sk);
132   return rc;
133 }
134
135
136 static gpg_error_t
137 get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
138 {
139   gpg_error_t err;
140   byte *frame = NULL;
141   unsigned int n;
142   size_t nframe;
143   u16 csum, csum2;
144   int card = 0;
145   gcry_sexp_t s_data;
146   char *desc;
147   char *keygrip;
148   byte fp[MAX_FINGERPRINT_LEN]; 
149   size_t fpn;
150
151   /* Get the keygrip.  */
152   err = hexkeygrip_from_pk (sk, &keygrip);
153   if (err)
154     goto leave;
155
156   /* Convert the data to an S-expression.  */
157   if (sk->pubkey_algo == GCRY_PK_ELG || sk->pubkey_algo == GCRY_PK_ELG_E)
158     {
159       if (!enc->data[0] || !enc->data[1])
160         err = gpg_error (GPG_ERR_BAD_MPI);
161       else
162         err = gcry_sexp_build (&s_data, NULL, "(enc-val(elg(a%m)(b%m)))", 
163                                enc->data[0], enc->data[1]);
164     }
165   else if (sk->pubkey_algo == GCRY_PK_RSA || sk->pubkey_algo == GCRY_PK_RSA_E)
166     {
167       if (!enc->data[0])
168         err = gpg_error (GPG_ERR_BAD_MPI);
169       else
170         err = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))",
171                                enc->data[0]);
172     }
173   else
174     err = gpg_error (GPG_ERR_BUG);
175
176   if (err)
177     goto leave;
178
179   fingerprint_from_pk( sk, fp, &fpn );
180   assert( fpn == 20 );
181
182   /* Decrypt. */
183   desc = gpg_format_keydesc (sk, 0, 1);
184   err = agent_pkdecrypt (NULL, keygrip, desc, s_data, fp, &frame, &nframe);
185   xfree (desc);
186   gcry_sexp_release (s_data);
187   if (err)
188     goto leave;
189
190   /* Now get the DEK (data encryption key) from the frame
191    *
192    * Old versions encode the DEK in in this format (msb is left):
193    *
194    *     0  1  DEK(16 bytes)  CSUM(2 bytes)  0  RND(n bytes) 2
195    *
196    * Later versions encode the DEK like this:
197    *
198    *     0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
199    *
200    * (mpi_get_buffer already removed the leading zero).
201    *
202    * RND are non-zero randow bytes.
203    * A   is the cipher algorithm
204    * DEK is the encryption key (session key) with length k
205    * CSUM
206    */
207   if (DBG_CIPHER)
208     log_printhex ("DEK frame:", frame, nframe);
209   n = 0;
210
211   if( sk->pubkey_algo != PUBKEY_ALGO_ECDH )  {
212     if (!card)
213       {
214         if (n + 7 > nframe)
215           {
216             err = gpg_error (G10ERR_WRONG_SECKEY);
217             goto leave;
218           }
219         if (frame[n] == 1 && frame[nframe - 1] == 2)
220           {
221             log_info (_("old encoding of the DEK is not supported\n"));
222             err = gpg_error (G10ERR_CIPHER_ALGO);
223             goto leave;
224           }
225         if (frame[n] != 2) /* Something went wrong.  */
226           {
227             err = gpg_error (G10ERR_WRONG_SECKEY);
228             goto leave;
229           }
230         for (n++; n < nframe && frame[n]; n++) /* Skip the random bytes.  */
231           ;
232         n++; /* Skip the zero byte.  */
233       }
234   }
235   else  {
236     /* Allow double padding for the benefit of DEK size concealment.
237      * Higher than this is wasteful.  
238      */
239     if( frame[nframe-1] > 8*2 || nframe <= 8 )  {
240       err = G10ERR_WRONG_SECKEY; goto leave; 
241     }
242     nframe -= frame[nframe-1];  /* remove padding */
243     assert( n==0 );     /* used just bellow */
244   }
245
246   if (n + 4 > nframe)
247     {
248       err = gpg_error (G10ERR_WRONG_SECKEY);
249       goto leave;
250     }
251
252   dek->keylen = nframe - (n + 1) - 2;
253   dek->algo = frame[n++];
254   if (dek->algo == CIPHER_ALGO_IDEA)
255     write_status (STATUS_RSA_OR_IDEA);
256   err = openpgp_cipher_test_algo (dek->algo);
257   if (err)
258     {
259       if (!opt.quiet && gpg_err_code (err) == GPG_ERR_CIPHER_ALGO)
260         {
261           log_info (_("cipher algorithm %d%s is unknown or disabled\n"),
262                     dek->algo,
263                     dek->algo == CIPHER_ALGO_IDEA ? " (IDEA)" : "");
264           if (dek->algo == CIPHER_ALGO_IDEA)
265             idea_cipher_warn (0);
266         }
267       dek->algo = 0;
268       goto leave;
269     }
270   if (dek->keylen != openpgp_cipher_get_algo_keylen (dek->algo))
271     {
272       err = gpg_error (GPG_ERR_WRONG_SECKEY);
273       goto leave;
274     }
275
276   /* Copy the key to DEK and compare the checksum.  */
277   csum = frame[nframe - 2] << 8;
278   csum |= frame[nframe - 1];
279   memcpy (dek->key, frame + n, dek->keylen);
280   for (csum2 = 0, n = 0; n < dek->keylen; n++)
281     csum2 += dek->key[n];
282   if (csum != csum2)
283     {
284       err = gpg_error (GPG_ERR_WRONG_SECKEY);
285       goto leave;
286     }
287   if (DBG_CIPHER)
288     log_printhex ("DEK is:", dek->key, dek->keylen);
289
290   /* Check that the algo is in the preferences and whether it has expired.  */
291   {
292     PKT_public_key *pk = NULL;
293     KBNODE pkb = get_pubkeyblock (keyid);
294
295     if (!pkb)
296       {
297         err = -1;
298         log_error ("oops: public key not found for preference check\n");
299       }
300     else if (pkb->pkt->pkt.public_key->selfsigversion > 3
301              && dek->algo != CIPHER_ALGO_3DES
302              && !opt.quiet
303              && !is_algo_in_prefs (pkb, PREFTYPE_SYM, dek->algo))
304       log_info (_("WARNING: cipher algorithm %s not found in recipient"
305                   " preferences\n"), openpgp_cipher_algo_name (dek->algo));
306     if (!err)
307       {
308         KBNODE k;
309
310         for (k = pkb; k; k = k->next)
311           {
312             if (k->pkt->pkttype == PKT_PUBLIC_KEY
313                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
314               {
315                 u32 aki[2];
316                 keyid_from_pk (k->pkt->pkt.public_key, aki);
317
318                 if (aki[0] == keyid[0] && aki[1] == keyid[1])
319                   {
320                     pk = k->pkt->pkt.public_key;
321                     break;
322                   }
323               }
324           }
325         if (!pk)
326           BUG ();
327         if (pk->expiredate && pk->expiredate <= make_timestamp ())
328           {
329             log_info (_("NOTE: secret key %s expired at %s\n"),
330                       keystr (keyid), asctimestamp (pk->expiredate));
331           }
332       }
333
334     if (pk && pk->flags.revoked)
335       {
336         log_info (_("NOTE: key has been revoked"));
337         log_printf ("\n");
338         show_revocation_reason (pk, 1);
339       }
340
341     release_kbnode (pkb);
342     err = 0;
343   }
344
345  leave:
346   xfree (frame);
347   xfree (keygrip);
348   return err;
349 }
350
351
352 /*
353  * Get the session key from the given string.
354  * String is supposed to be formatted as this:
355  *  <algo-id>:<even-number-of-hex-digits>
356  */
357 gpg_error_t
358 get_override_session_key (DEK *dek, const char *string)
359 {
360   const char *s;
361   int i;
362
363   if (!string)
364     return G10ERR_BAD_KEY;
365   dek->algo = atoi (string);
366   if (dek->algo < 1)
367     return G10ERR_BAD_KEY;
368   if (!(s = strchr (string, ':')))
369     return G10ERR_BAD_KEY;
370   s++;
371   for (i = 0; i < DIM (dek->key) && *s; i++, s += 2)
372     {
373       int c = hextobyte (s);
374       if (c == -1)
375         return G10ERR_BAD_KEY;
376       dek->key[i] = c;
377     }
378   if (*s)
379     return G10ERR_BAD_KEY;
380   dek->keylen = i;
381   return 0;
382 }