gpg: Pass CTRL to many more functions.
[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 <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "gpg.h"
27 #include "../common/util.h"
28 #include "packet.h"
29 #include "keydb.h"
30 #include "trustdb.h"
31 #include "../common/status.h"
32 #include "options.h"
33 #include "main.h"
34 #include "../common/i18n.h"
35 #include "pkglue.h"
36 #include "call-agent.h"
37 #include "../common/host2net.h"
38
39
40 static gpg_error_t get_it (ctrl_t ctrl, PKT_pubkey_enc *k,
41                            DEK *dek, PKT_public_key *sk, u32 *keyid);
42
43
44 /* Check that the given algo is mentioned in one of the valid user-ids. */
45 static int
46 is_algo_in_prefs (kbnode_t keyblock, preftype_t type, int algo)
47 {
48   kbnode_t k;
49
50   for (k = keyblock; k; k = k->next)
51     {
52       if (k->pkt->pkttype == PKT_USER_ID)
53         {
54           PKT_user_id *uid = k->pkt->pkt.user_id;
55           prefitem_t *prefs = uid->prefs;
56
57           if (uid->created && prefs && !uid->flags.revoked && !uid->flags.expired)
58             {
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 it in DEK,
71  * which should have been allocated in secure memory by the caller.
72  */
73 gpg_error_t
74 get_session_key (ctrl_t ctrl, PKT_pubkey_enc * k, DEK * dek)
75 {
76   PKT_public_key *sk = NULL;
77   int rc;
78
79   if (DBG_CLOCK)
80     log_clock ("get_session_key enter");
81
82   rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
83   if (rc)
84     goto leave;
85
86   if ((k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets)
87     {
88       sk = xmalloc_clear (sizeof *sk);
89       sk->pubkey_algo = k->pubkey_algo; /* We want a pubkey with this algo.  */
90       if (!(rc = get_seckey (ctrl, sk, k->keyid)))
91         rc = get_it (ctrl, k, dek, sk, k->keyid);
92     }
93   else if (opt.skip_hidden_recipients)
94     rc = gpg_error (GPG_ERR_NO_SECKEY);
95   else  /* Anonymous receiver: Try all available secret keys.  */
96     {
97       void *enum_context = NULL;
98       u32 keyid[2];
99
100       for (;;)
101         {
102           free_public_key (sk);
103           sk = xmalloc_clear (sizeof *sk);
104           rc = enum_secret_keys (ctrl, &enum_context, sk);
105           if (rc)
106             {
107               rc = GPG_ERR_NO_SECKEY;
108               break;
109             }
110           if (sk->pubkey_algo != k->pubkey_algo)
111             continue;
112           if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
113             continue;
114           keyid_from_pk (sk, keyid);
115           if (!opt.quiet)
116             log_info (_("anonymous recipient; trying secret key %s ...\n"),
117                       keystr (keyid));
118
119           rc = get_it (ctrl, k, dek, sk, keyid);
120           if (!rc)
121             {
122               if (!opt.quiet)
123                 log_info (_("okay, we are the anonymous recipient.\n"));
124               break;
125             }
126           else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
127             break; /* Don't try any more secret keys.  */
128         }
129       enum_secret_keys (ctrl, &enum_context, NULL);  /* free context */
130     }
131
132 leave:
133   free_public_key (sk);
134   if (DBG_CLOCK)
135     log_clock ("get_session_key leave");
136   return rc;
137 }
138
139
140 static gpg_error_t
141 get_it (ctrl_t ctrl,
142         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 padding;
150   gcry_sexp_t s_data;
151   char *desc;
152   char *keygrip;
153   byte fp[MAX_FINGERPRINT_LEN];
154   size_t fpn;
155
156   if (DBG_CLOCK)
157     log_clock ("decryption start");
158
159   /* Get the keygrip.  */
160   err = hexkeygrip_from_pk (sk, &keygrip);
161   if (err)
162     goto leave;
163
164   /* Convert the data to an S-expression.  */
165   if (sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
166       || sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_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 (sk->pubkey_algo == PUBKEY_ALGO_RSA
175            || sk->pubkey_algo == PUBKEY_ALGO_RSA_E)
176     {
177       if (!enc->data[0])
178         err = gpg_error (GPG_ERR_BAD_MPI);
179       else
180         err = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))",
181                                enc->data[0]);
182     }
183   else if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
184     {
185       if (!enc->data[0] || !enc->data[1])
186         err = gpg_error (GPG_ERR_BAD_MPI);
187       else
188         err = gcry_sexp_build (&s_data, NULL, "(enc-val(ecdh(s%m)(e%m)))",
189                                enc->data[1], enc->data[0]);
190     }
191   else
192     err = gpg_error (GPG_ERR_BUG);
193
194   if (err)
195     goto leave;
196
197   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
198     {
199       fingerprint_from_pk (sk, fp, &fpn);
200       log_assert (fpn == 20);
201     }
202
203   /* Decrypt. */
204   desc = gpg_format_keydesc (ctrl, sk, FORMAT_KEYDESC_NORMAL, 1);
205   err = agent_pkdecrypt (NULL, keygrip,
206                          desc, sk->keyid, sk->main_keyid, sk->pubkey_algo,
207                          s_data, &frame, &nframe, &padding);
208   xfree (desc);
209   gcry_sexp_release (s_data);
210   if (err)
211     goto leave;
212
213   /* Now get the DEK (data encryption key) from the frame
214    *
215    * Old versions encode the DEK in this format (msb is left):
216    *
217    *     0  1  DEK(16 bytes)  CSUM(2 bytes)  0  RND(n bytes) 2
218    *
219    * Later versions encode the DEK like this:
220    *
221    *     0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
222    *
223    * (mpi_get_buffer already removed the leading zero).
224    *
225    * RND are non-zero randow bytes.
226    * A   is the cipher algorithm
227    * DEK is the encryption key (session key) with length k
228    * CSUM
229    */
230   if (DBG_CRYPTO)
231     log_printhex ("DEK frame:", frame, nframe);
232   n = 0;
233
234   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
235     {
236       gcry_mpi_t shared_mpi;
237       gcry_mpi_t decoded;
238
239       /* At the beginning the frame are the bytes of shared point MPI.  */
240       err = gcry_mpi_scan (&shared_mpi, GCRYMPI_FMT_USG, frame, nframe, NULL);
241       if (err)
242         {
243           err = gpg_error (GPG_ERR_WRONG_SECKEY);
244           goto leave;
245         }
246
247       err = pk_ecdh_decrypt (&decoded, fp, enc->data[1]/*encr data as an MPI*/,
248                              shared_mpi, sk->pkey);
249       mpi_release (shared_mpi);
250       if(err)
251         goto leave;
252
253       xfree (frame);
254       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &frame, &nframe, decoded);
255       mpi_release (decoded);
256       if (err)
257         goto leave;
258
259       /* Now the frame are the bytes decrypted but padded session key.  */
260
261       /* Allow double padding for the benefit of DEK size concealment.
262          Higher than this is wasteful. */
263       if (!nframe || frame[nframe-1] > 8*2 || nframe <= 8
264           || frame[nframe-1] > nframe)
265         {
266           err = gpg_error (GPG_ERR_WRONG_SECKEY);
267           goto leave;
268         }
269       nframe -= frame[nframe-1]; /* Remove padding.  */
270       log_assert (!n); /* (used just below) */
271     }
272   else
273     {
274       if (padding)
275         {
276           if (n + 7 > nframe)
277             {
278               err = gpg_error (GPG_ERR_WRONG_SECKEY);
279               goto leave;
280             }
281           if (frame[n] == 1 && frame[nframe - 1] == 2)
282             {
283               log_info (_("old encoding of the DEK is not supported\n"));
284               err = gpg_error (GPG_ERR_CIPHER_ALGO);
285               goto leave;
286             }
287           if (frame[n] != 2) /* Something went wrong.  */
288             {
289               err = gpg_error (GPG_ERR_WRONG_SECKEY);
290               goto leave;
291             }
292           for (n++; n < nframe && frame[n]; n++) /* Skip the random bytes.  */
293             ;
294           n++; /* Skip the zero byte.  */
295         }
296     }
297
298   if (n + 4 > nframe)
299     {
300       err = gpg_error (GPG_ERR_WRONG_SECKEY);
301       goto leave;
302     }
303
304   dek->keylen = nframe - (n + 1) - 2;
305   dek->algo = frame[n++];
306   err = openpgp_cipher_test_algo (dek->algo);
307   if (err)
308     {
309       if (!opt.quiet && gpg_err_code (err) == GPG_ERR_CIPHER_ALGO)
310         {
311           log_info (_("cipher algorithm %d%s is unknown or disabled\n"),
312                     dek->algo,
313                     dek->algo == CIPHER_ALGO_IDEA ? " (IDEA)" : "");
314         }
315       dek->algo = 0;
316       goto leave;
317     }
318   if (dek->keylen != openpgp_cipher_get_algo_keylen (dek->algo))
319     {
320       err = gpg_error (GPG_ERR_WRONG_SECKEY);
321       goto leave;
322     }
323
324   /* Copy the key to DEK and compare the checksum.  */
325   csum = buf16_to_u16 (frame+nframe-2);
326   memcpy (dek->key, frame + n, dek->keylen);
327   for (csum2 = 0, n = 0; n < dek->keylen; n++)
328     csum2 += dek->key[n];
329   if (csum != csum2)
330     {
331       err = gpg_error (GPG_ERR_WRONG_SECKEY);
332       goto leave;
333     }
334   if (DBG_CLOCK)
335     log_clock ("decryption ready");
336   if (DBG_CRYPTO)
337     log_printhex ("DEK is:", dek->key, dek->keylen);
338
339   /* Check that the algo is in the preferences and whether it has
340    * expired.  Also print a status line with the key's fingerprint.  */
341   {
342     PKT_public_key *pk = NULL;
343     PKT_public_key *mainpk = NULL;
344     KBNODE pkb = get_pubkeyblock (ctrl, keyid);
345
346     if (!pkb)
347       {
348         err = -1;
349         log_error ("oops: public key not found for preference check\n");
350       }
351     else if (pkb->pkt->pkt.public_key->selfsigversion > 3
352              && dek->algo != CIPHER_ALGO_3DES
353              && !opt.quiet
354              && !is_algo_in_prefs (pkb, PREFTYPE_SYM, dek->algo))
355       log_info (_("WARNING: cipher algorithm %s not found in recipient"
356                   " preferences\n"), openpgp_cipher_algo_name (dek->algo));
357
358     if (!err)
359       {
360         kbnode_t k;
361         int first = 1;
362
363         for (k = pkb; k; k = k->next)
364           {
365             if (k->pkt->pkttype == PKT_PUBLIC_KEY
366                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
367               {
368                 u32 aki[2];
369
370                 if (first)
371                   {
372                     first = 0;
373                     mainpk = k->pkt->pkt.public_key;
374                   }
375
376                 keyid_from_pk (k->pkt->pkt.public_key, aki);
377                 if (aki[0] == keyid[0] && aki[1] == keyid[1])
378                   {
379                     pk = k->pkt->pkt.public_key;
380                     break;
381                   }
382               }
383           }
384         if (!pk)
385           BUG ();
386         if (pk->expiredate && pk->expiredate <= make_timestamp ())
387           {
388             log_info (_("Note: secret key %s expired at %s\n"),
389                       keystr (keyid), asctimestamp (pk->expiredate));
390           }
391       }
392
393     if (pk && pk->flags.revoked)
394       {
395         log_info (_("Note: key has been revoked"));
396         log_printf ("\n");
397         show_revocation_reason (ctrl, pk, 1);
398       }
399
400     if (is_status_enabled () && pk && mainpk)
401       {
402         char pkhex[MAX_FINGERPRINT_LEN*2+1];
403         char mainpkhex[MAX_FINGERPRINT_LEN*2+1];
404
405         hexfingerprint (pk, pkhex, sizeof pkhex);
406         hexfingerprint (mainpk, mainpkhex, sizeof mainpkhex);
407
408         /* Note that we do not want to create a trustdb just for
409          * getting the ownertrust: If there is no trustdb there can't
410          * be ulitmately trusted key anyway and thus the ownertrust
411          * value is irrelevant.  */
412         write_status_printf (STATUS_DECRYPTION_KEY, "%s %s %c",
413                              pkhex, mainpkhex,
414                              get_ownertrust_info (ctrl, mainpk, 1));
415
416       }
417
418     release_kbnode (pkb);
419     err = 0;
420   }
421
422  leave:
423   xfree (frame);
424   xfree (keygrip);
425   return err;
426 }
427
428
429 /*
430  * Get the session key from the given string.
431  * String is supposed to be formatted as this:
432  *  <algo-id>:<even-number-of-hex-digits>
433  */
434 gpg_error_t
435 get_override_session_key (DEK *dek, const char *string)
436 {
437   const char *s;
438   int i;
439
440   if (!string)
441     return GPG_ERR_BAD_KEY;
442   dek->algo = atoi (string);
443   if (dek->algo < 1)
444     return GPG_ERR_BAD_KEY;
445   if (!(s = strchr (string, ':')))
446     return GPG_ERR_BAD_KEY;
447   s++;
448   for (i = 0; i < DIM (dek->key) && *s; i++, s += 2)
449     {
450       int c = hextobyte (s);
451       if (c == -1)
452         return GPG_ERR_BAD_KEY;
453       dek->key[i] = c;
454     }
455   if (*s)
456     return GPG_ERR_BAD_KEY;
457   dek->keylen = i;
458   return 0;
459 }