a69536e1de6053968c0436f2de3a4041b72a865e
[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   if (DBG_CLOCK)
81     log_clock ("get_session_key enter");
82
83   rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
84   if (rc)
85     goto leave;
86
87   if ((k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets)
88     {
89       sk = xmalloc_clear (sizeof *sk);
90       sk->pubkey_algo = k->pubkey_algo; /* We want a pubkey with this algo.  */
91       if (!(rc = get_seckey (sk, k->keyid)))
92         rc = get_it (k, dek, sk, k->keyid);
93     }
94   else if (opt.skip_hidden_recipients)
95     rc = gpg_error (GPG_ERR_NO_SECKEY);
96   else  /* Anonymous receiver: Try all available secret keys.  */
97     {
98       void *enum_context = NULL;
99       u32 keyid[2];
100
101       for (;;)
102         {
103           free_public_key (sk);
104           sk = xmalloc_clear (sizeof *sk);
105           rc = enum_secret_keys (&enum_context, sk);
106           if (rc)
107             {
108               rc = G10ERR_NO_SECKEY;
109               break;
110             }
111           if (sk->pubkey_algo != k->pubkey_algo)
112             continue;
113           if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
114             continue;
115           keyid_from_pk (sk, keyid);
116           if (!opt.quiet)
117             log_info (_("anonymous recipient; trying secret key %s ...\n"),
118                       keystr (keyid));
119
120           rc = get_it (k, dek, sk, keyid);
121           if (!rc)
122             {
123               if (!opt.quiet)
124                 log_info (_("okay, we are the anonymous recipient.\n"));
125               break;
126             }
127           else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
128             break; /* Don't try any more secret keys.  */
129         }
130       enum_secret_keys (&enum_context, NULL);  /* free context */
131     }
132
133 leave:
134   free_public_key (sk);
135   if (DBG_CLOCK)
136     log_clock ("get_session_key leave");
137   return rc;
138 }
139
140
141 static gpg_error_t
142 get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
143 {
144   gpg_error_t err;
145   byte *frame = NULL;
146   unsigned int n;
147   size_t nframe;
148   u16 csum, csum2;
149   int card = 0;
150   gcry_sexp_t s_data;
151   char *desc;
152   char *keygrip;
153   byte fp[MAX_FINGERPRINT_LEN];
154   size_t fpn;
155   const int pkalgo = map_pk_openpgp_to_gcry (sk->pubkey_algo);
156
157   if (DBG_CLOCK)
158     log_clock ("decryption start");
159
160   /* Get the keygrip.  */
161   err = hexkeygrip_from_pk (sk, &keygrip);
162   if (err)
163     goto leave;
164
165   /* Convert the data to an S-expression.  */
166   if (pkalgo == GCRY_PK_ELG || pkalgo == GCRY_PK_ELG_E)
167     {
168       if (!enc->data[0] || !enc->data[1])
169         err = gpg_error (GPG_ERR_BAD_MPI);
170       else
171         err = gcry_sexp_build (&s_data, NULL, "(enc-val(elg(a%m)(b%m)))",
172                                enc->data[0], enc->data[1]);
173     }
174   else if (pkalgo == GCRY_PK_RSA || pkalgo == GCRY_PK_RSA_E)
175     {
176       if (!enc->data[0])
177         err = gpg_error (GPG_ERR_BAD_MPI);
178       else
179         err = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))",
180                                enc->data[0]);
181     }
182   else if (pkalgo == GCRY_PK_ECDH)
183     {
184       if (!enc->data[0] || !enc->data[1])
185         err = gpg_error (GPG_ERR_BAD_MPI);
186       else
187         err = gcry_sexp_build (&s_data, NULL, "(enc-val(ecdh(s%m)(e%m)))",
188                                enc->data[0], enc->data[1]);
189     }
190   else
191     err = gpg_error (GPG_ERR_BUG);
192
193   if (err)
194     goto leave;
195
196   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
197     {
198       fingerprint_from_pk (sk, fp, &fpn);
199       assert (fpn == 20);
200     }
201
202   /* Decrypt. */
203   desc = gpg_format_keydesc (sk, 0, 1);
204   err = agent_pkdecrypt (NULL, keygrip, desc, s_data, &frame, &nframe);
205   xfree (desc);
206   gcry_sexp_release (s_data);
207   if (err)
208     goto leave;
209
210   /* Now get the DEK (data encryption key) from the frame
211    *
212    * Old versions encode the DEK in in this format (msb is left):
213    *
214    *     0  1  DEK(16 bytes)  CSUM(2 bytes)  0  RND(n bytes) 2
215    *
216    * Later versions encode the DEK like this:
217    *
218    *     0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
219    *
220    * (mpi_get_buffer already removed the leading zero).
221    *
222    * RND are non-zero randow bytes.
223    * A   is the cipher algorithm
224    * DEK is the encryption key (session key) with length k
225    * CSUM
226    */
227   if (DBG_CIPHER)
228     log_printhex ("DEK frame:", frame, nframe);
229   n = 0;
230
231   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
232     {
233       gcry_mpi_t shared_mpi;
234       gcry_mpi_t decoded;
235
236       /* At the beginning the frame are the bytes of shared point MPI.  */
237       err = gcry_mpi_scan (&shared_mpi, GCRYMPI_FMT_USG, frame, nframe, NULL);
238       if (err)
239         {
240           err = gpg_error (GPG_ERR_WRONG_SECKEY);
241           goto leave;
242         }
243
244       err = pk_ecdh_decrypt (&decoded, fp, enc->data[1]/*encr data as an MPI*/,
245                              shared_mpi, sk->pkey);
246       mpi_release (shared_mpi);
247       if(err)
248         goto leave;
249
250       /* Reuse NFRAME, which size is sufficient to include the session key.  */
251       err = gcry_mpi_print (GCRYMPI_FMT_USG, frame, nframe, &nframe, decoded);
252       mpi_release (decoded);
253       if (err)
254         goto leave;
255
256       /* Now the frame are the bytes decrypted but padded session key.  */
257
258       /* Allow double padding for the benefit of DEK size concealment.
259          Higher than this is wasteful. */
260       if (!nframe || frame[nframe-1] > 8*2 || nframe <= 8
261           || frame[nframe-1] > nframe)
262         {
263           err = gpg_error (GPG_ERR_WRONG_SECKEY);
264           goto leave;
265         }
266       nframe -= frame[nframe-1]; /* Remove padding.  */
267       assert (!n); /* (used just below) */
268     }
269   else
270     {
271       if (!card)
272         {
273           if (n + 7 > nframe)
274             {
275               err = gpg_error (GPG_ERR_WRONG_SECKEY);
276               goto leave;
277             }
278           if (frame[n] == 1 && frame[nframe - 1] == 2)
279             {
280               log_info (_("old encoding of the DEK is not supported\n"));
281               err = gpg_error (GPG_ERR_CIPHER_ALGO);
282               goto leave;
283             }
284           if (frame[n] != 2) /* Something went wrong.  */
285             {
286               err = gpg_error (GPG_ERR_WRONG_SECKEY);
287               goto leave;
288             }
289           for (n++; n < nframe && frame[n]; n++) /* Skip the random bytes.  */
290             ;
291           n++; /* Skip the zero byte.  */
292         }
293     }
294
295   if (n + 4 > nframe)
296     {
297       err = gpg_error (GPG_ERR_WRONG_SECKEY);
298       goto leave;
299     }
300
301   dek->keylen = nframe - (n + 1) - 2;
302   dek->algo = frame[n++];
303   err = openpgp_cipher_test_algo (dek->algo);
304   if (err)
305     {
306       if (!opt.quiet && gpg_err_code (err) == GPG_ERR_CIPHER_ALGO)
307         {
308           log_info (_("cipher algorithm %d%s is unknown or disabled\n"),
309                     dek->algo,
310                     dek->algo == CIPHER_ALGO_IDEA ? " (IDEA)" : "");
311         }
312       dek->algo = 0;
313       goto leave;
314     }
315   if (dek->keylen != openpgp_cipher_get_algo_keylen (dek->algo))
316     {
317       err = gpg_error (GPG_ERR_WRONG_SECKEY);
318       goto leave;
319     }
320
321   /* Copy the key to DEK and compare the checksum.  */
322   csum = frame[nframe - 2] << 8;
323   csum |= frame[nframe - 1];
324   memcpy (dek->key, frame + n, dek->keylen);
325   for (csum2 = 0, n = 0; n < dek->keylen; n++)
326     csum2 += dek->key[n];
327   if (csum != csum2)
328     {
329       err = gpg_error (GPG_ERR_WRONG_SECKEY);
330       goto leave;
331     }
332   if (DBG_CLOCK)
333     log_clock ("decryption ready");
334   if (DBG_CIPHER)
335     log_printhex ("DEK is:", dek->key, dek->keylen);
336
337   /* Check that the algo is in the preferences and whether it has expired.  */
338   {
339     PKT_public_key *pk = NULL;
340     KBNODE pkb = get_pubkeyblock (keyid);
341
342     if (!pkb)
343       {
344         err = -1;
345         log_error ("oops: public key not found for preference check\n");
346       }
347     else if (pkb->pkt->pkt.public_key->selfsigversion > 3
348              && dek->algo != CIPHER_ALGO_3DES
349              && !opt.quiet
350              && !is_algo_in_prefs (pkb, PREFTYPE_SYM, dek->algo))
351       log_info (_("WARNING: cipher algorithm %s not found in recipient"
352                   " preferences\n"), openpgp_cipher_algo_name (dek->algo));
353     if (!err)
354       {
355         KBNODE k;
356
357         for (k = pkb; k; k = k->next)
358           {
359             if (k->pkt->pkttype == PKT_PUBLIC_KEY
360                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
361               {
362                 u32 aki[2];
363                 keyid_from_pk (k->pkt->pkt.public_key, aki);
364
365                 if (aki[0] == keyid[0] && aki[1] == keyid[1])
366                   {
367                     pk = k->pkt->pkt.public_key;
368                     break;
369                   }
370               }
371           }
372         if (!pk)
373           BUG ();
374         if (pk->expiredate && pk->expiredate <= make_timestamp ())
375           {
376             log_info (_("NOTE: secret key %s expired at %s\n"),
377                       keystr (keyid), asctimestamp (pk->expiredate));
378           }
379       }
380
381     if (pk && pk->flags.revoked)
382       {
383         log_info (_("NOTE: key has been revoked"));
384         log_printf ("\n");
385         show_revocation_reason (pk, 1);
386       }
387
388     release_kbnode (pkb);
389     err = 0;
390   }
391
392  leave:
393   xfree (frame);
394   xfree (keygrip);
395   return err;
396 }
397
398
399 /*
400  * Get the session key from the given string.
401  * String is supposed to be formatted as this:
402  *  <algo-id>:<even-number-of-hex-digits>
403  */
404 gpg_error_t
405 get_override_session_key (DEK *dek, const char *string)
406 {
407   const char *s;
408   int i;
409
410   if (!string)
411     return G10ERR_BAD_KEY;
412   dek->algo = atoi (string);
413   if (dek->algo < 1)
414     return G10ERR_BAD_KEY;
415   if (!(s = strchr (string, ':')))
416     return G10ERR_BAD_KEY;
417   s++;
418   for (i = 0; i < DIM (dek->key) && *s; i++, s += 2)
419     {
420       int c = hextobyte (s);
421       if (c == -1)
422         return G10ERR_BAD_KEY;
423       dek->key[i] = c;
424     }
425   if (*s)
426     return G10ERR_BAD_KEY;
427   dek->keylen = i;
428   return 0;
429 }