gpg: Report STATUS_NO_SECKEY when it is examined.
[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 #include "../common/compliance.h"
39
40
41 static gpg_error_t get_it (ctrl_t ctrl, struct pubkey_enc_list *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->flags.revoked && !uid->flags.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 (ctrl_t ctrl, struct pubkey_enc_list *list, DEK *dek)
76 {
77   PKT_public_key *sk = NULL;
78   int rc;
79   void *enum_context = NULL;
80   u32 keyid[2];
81   int search_for_secret_keys = 1;
82
83   if (DBG_CLOCK)
84     log_clock ("get_session_key enter");
85
86   while (search_for_secret_keys)
87     {
88       struct pubkey_enc_list *k;
89
90       sk = xmalloc_clear (sizeof *sk);
91       rc = enum_secret_keys (ctrl, &enum_context, sk);
92       if (rc)
93         {
94           rc = GPG_ERR_NO_SECKEY;
95           break;
96         }
97
98       if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
99         continue;
100
101       /* Check compliance.  */
102       if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_DECRYPTION,
103                                  sk->pubkey_algo,
104                                  sk->pkey, nbits_from_pk (sk), NULL))
105         {
106           log_info (_("key %s is not suitable for decryption"
107                       " in %s mode\n"),
108                     keystr_from_pk (sk),
109                     gnupg_compliance_option_string (opt.compliance));
110           continue;
111         }
112
113       /* FIXME: The list needs to be sorted so that we try the keys in
114        * an appropriate order.  For example:
115        * - On-disk keys w/o protection
116        * - On-disk keys with a cached passphrase
117        * - On-card keys of an active card
118        * - On-disk keys with protection
119        * - On-card keys from cards which are not plugged it.  Here a
120        *   cancel-all button should stop aksing for other cards.
121        * Without any anonymous keys the sorting can be skipped.
122        */
123       for (k = list; k; k = k->next)
124         {
125           if (!(k->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E
126                 || k->pubkey_algo == PUBKEY_ALGO_ECDH
127                 || k->pubkey_algo == PUBKEY_ALGO_RSA
128                 || k->pubkey_algo == PUBKEY_ALGO_RSA_E
129                 || k->pubkey_algo == PUBKEY_ALGO_ELGAMAL))
130             continue;
131
132           if (openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC))
133             continue;
134
135           k->result = GPG_ERR_NO_SECKEY;
136
137           if (sk->pubkey_algo != k->pubkey_algo)
138             continue;
139
140           keyid_from_pk (sk, keyid);
141
142           if (!k->keyid[0] && !k->keyid[1])
143             {
144               if (opt.skip_hidden_recipients)
145                 continue;
146
147               if (!opt.quiet)
148                 log_info (_("anonymous recipient; trying secret key %s ...\n"),
149                           keystr (keyid));
150             }
151           else if (opt.try_all_secrets
152                    || (k->keyid[0] == keyid[0] && k->keyid[1] == keyid[1]))
153             ;
154           else
155             continue;
156
157           rc = get_it (ctrl, k, dek, sk, keyid);
158           if (!rc)
159             {
160               k->result = 0;
161               if (!opt.quiet && !k->keyid[0] && !k->keyid[1])
162                 log_info (_("okay, we are the anonymous recipient.\n"));
163               search_for_secret_keys = 0;
164               break;
165             }
166           else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
167             {
168               search_for_secret_keys = 0;
169               break; /* Don't try any more secret keys.  */
170             }
171         }
172     }
173   enum_secret_keys (ctrl, &enum_context, NULL);  /* free context */
174
175   if (DBG_CLOCK)
176     log_clock ("get_session_key leave");
177   return rc;
178 }
179
180
181 static gpg_error_t
182 get_it (ctrl_t ctrl,
183         struct pubkey_enc_list *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
184 {
185   gpg_error_t err;
186   byte *frame = NULL;
187   unsigned int n;
188   size_t nframe;
189   u16 csum, csum2;
190   int padding;
191   gcry_sexp_t s_data;
192   char *desc;
193   char *keygrip;
194   byte fp[MAX_FINGERPRINT_LEN];
195   size_t fpn;
196
197   if (DBG_CLOCK)
198     log_clock ("decryption start");
199
200   /* Get the keygrip.  */
201   err = hexkeygrip_from_pk (sk, &keygrip);
202   if (err)
203     goto leave;
204
205   /* Convert the data to an S-expression.  */
206   if (sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
207       || sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E)
208     {
209       if (!enc->data[0] || !enc->data[1])
210         err = gpg_error (GPG_ERR_BAD_MPI);
211       else
212         err = gcry_sexp_build (&s_data, NULL, "(enc-val(elg(a%m)(b%m)))",
213                                enc->data[0], enc->data[1]);
214     }
215   else if (sk->pubkey_algo == PUBKEY_ALGO_RSA
216            || sk->pubkey_algo == PUBKEY_ALGO_RSA_E)
217     {
218       if (!enc->data[0])
219         err = gpg_error (GPG_ERR_BAD_MPI);
220       else
221         err = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))",
222                                enc->data[0]);
223     }
224   else if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
225     {
226       if (!enc->data[0] || !enc->data[1])
227         err = gpg_error (GPG_ERR_BAD_MPI);
228       else
229         err = gcry_sexp_build (&s_data, NULL, "(enc-val(ecdh(s%m)(e%m)))",
230                                enc->data[1], enc->data[0]);
231     }
232   else
233     err = gpg_error (GPG_ERR_BUG);
234
235   if (err)
236     goto leave;
237
238   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
239     {
240       fingerprint_from_pk (sk, fp, &fpn);
241       log_assert (fpn == 20);
242     }
243
244   /* Decrypt. */
245   desc = gpg_format_keydesc (ctrl, sk, FORMAT_KEYDESC_NORMAL, 1);
246   err = agent_pkdecrypt (NULL, keygrip,
247                          desc, sk->keyid, sk->main_keyid, sk->pubkey_algo,
248                          s_data, &frame, &nframe, &padding);
249   xfree (desc);
250   gcry_sexp_release (s_data);
251   if (err)
252     goto leave;
253
254   /* Now get the DEK (data encryption key) from the frame
255    *
256    * Old versions encode the DEK in this format (msb is left):
257    *
258    *     0  1  DEK(16 bytes)  CSUM(2 bytes)  0  RND(n bytes) 2
259    *
260    * Later versions encode the DEK like this:
261    *
262    *     0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
263    *
264    * (mpi_get_buffer already removed the leading zero).
265    *
266    * RND are non-zero randow bytes.
267    * A   is the cipher algorithm
268    * DEK is the encryption key (session key) with length k
269    * CSUM
270    */
271   if (DBG_CRYPTO)
272     log_printhex (frame, nframe, "DEK frame:");
273   n = 0;
274
275   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
276     {
277       gcry_mpi_t shared_mpi;
278       gcry_mpi_t decoded;
279
280       /* At the beginning the frame are the bytes of shared point MPI.  */
281       err = gcry_mpi_scan (&shared_mpi, GCRYMPI_FMT_USG, frame, nframe, NULL);
282       if (err)
283         {
284           err = gpg_error (GPG_ERR_WRONG_SECKEY);
285           goto leave;
286         }
287
288       err = pk_ecdh_decrypt (&decoded, fp, enc->data[1]/*encr data as an MPI*/,
289                              shared_mpi, sk->pkey);
290       mpi_release (shared_mpi);
291       if(err)
292         goto leave;
293
294       xfree (frame);
295       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &frame, &nframe, decoded);
296       mpi_release (decoded);
297       if (err)
298         goto leave;
299
300       /* Now the frame are the bytes decrypted but padded session key.  */
301
302       /* Allow double padding for the benefit of DEK size concealment.
303          Higher than this is wasteful. */
304       if (!nframe || frame[nframe-1] > 8*2 || nframe <= 8
305           || frame[nframe-1] > nframe)
306         {
307           err = gpg_error (GPG_ERR_WRONG_SECKEY);
308           goto leave;
309         }
310       nframe -= frame[nframe-1]; /* Remove padding.  */
311       log_assert (!n); /* (used just below) */
312     }
313   else
314     {
315       if (padding)
316         {
317           if (n + 7 > nframe)
318             {
319               err = gpg_error (GPG_ERR_WRONG_SECKEY);
320               goto leave;
321             }
322           if (frame[n] == 1 && frame[nframe - 1] == 2)
323             {
324               log_info (_("old encoding of the DEK is not supported\n"));
325               err = gpg_error (GPG_ERR_CIPHER_ALGO);
326               goto leave;
327             }
328           if (frame[n] != 2) /* Something went wrong.  */
329             {
330               err = gpg_error (GPG_ERR_WRONG_SECKEY);
331               goto leave;
332             }
333           for (n++; n < nframe && frame[n]; n++) /* Skip the random bytes.  */
334             ;
335           n++; /* Skip the zero byte.  */
336         }
337     }
338
339   if (n + 4 > nframe)
340     {
341       err = gpg_error (GPG_ERR_WRONG_SECKEY);
342       goto leave;
343     }
344
345   dek->keylen = nframe - (n + 1) - 2;
346   dek->algo = frame[n++];
347   err = openpgp_cipher_test_algo (dek->algo);
348   if (err)
349     {
350       if (!opt.quiet && gpg_err_code (err) == GPG_ERR_CIPHER_ALGO)
351         {
352           log_info (_("cipher algorithm %d%s is unknown or disabled\n"),
353                     dek->algo,
354                     dek->algo == CIPHER_ALGO_IDEA ? " (IDEA)" : "");
355         }
356       dek->algo = 0;
357       goto leave;
358     }
359   if (dek->keylen != openpgp_cipher_get_algo_keylen (dek->algo))
360     {
361       err = gpg_error (GPG_ERR_WRONG_SECKEY);
362       goto leave;
363     }
364
365   /* Copy the key to DEK and compare the checksum.  */
366   csum = buf16_to_u16 (frame+nframe-2);
367   memcpy (dek->key, frame + n, dek->keylen);
368   for (csum2 = 0, n = 0; n < dek->keylen; n++)
369     csum2 += dek->key[n];
370   if (csum != csum2)
371     {
372       err = gpg_error (GPG_ERR_WRONG_SECKEY);
373       goto leave;
374     }
375   if (DBG_CLOCK)
376     log_clock ("decryption ready");
377   if (DBG_CRYPTO)
378     log_printhex (dek->key, dek->keylen, "DEK is:");
379
380   /* Check that the algo is in the preferences and whether it has
381    * expired.  Also print a status line with the key's fingerprint.  */
382   {
383     PKT_public_key *pk = NULL;
384     PKT_public_key *mainpk = NULL;
385     KBNODE pkb = get_pubkeyblock (ctrl, keyid);
386
387     if (!pkb)
388       {
389         err = -1;
390         log_error ("oops: public key not found for preference check\n");
391       }
392     else if (pkb->pkt->pkt.public_key->selfsigversion > 3
393              && dek->algo != CIPHER_ALGO_3DES
394              && !opt.quiet
395              && !is_algo_in_prefs (pkb, PREFTYPE_SYM, dek->algo))
396       log_info (_("WARNING: cipher algorithm %s not found in recipient"
397                   " preferences\n"), openpgp_cipher_algo_name (dek->algo));
398
399     if (!err)
400       {
401         kbnode_t k;
402         int first = 1;
403
404         for (k = pkb; k; k = k->next)
405           {
406             if (k->pkt->pkttype == PKT_PUBLIC_KEY
407                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
408               {
409                 u32 aki[2];
410
411                 if (first)
412                   {
413                     first = 0;
414                     mainpk = k->pkt->pkt.public_key;
415                   }
416
417                 keyid_from_pk (k->pkt->pkt.public_key, aki);
418                 if (aki[0] == keyid[0] && aki[1] == keyid[1])
419                   {
420                     pk = k->pkt->pkt.public_key;
421                     break;
422                   }
423               }
424           }
425         if (!pk)
426           BUG ();
427         if (pk->expiredate && pk->expiredate <= make_timestamp ())
428           {
429             log_info (_("Note: secret key %s expired at %s\n"),
430                       keystr (keyid), asctimestamp (pk->expiredate));
431           }
432       }
433
434     if (pk && pk->flags.revoked)
435       {
436         log_info (_("Note: key has been revoked"));
437         log_printf ("\n");
438         show_revocation_reason (ctrl, pk, 1);
439       }
440
441     if (is_status_enabled () && pk && mainpk)
442       {
443         char pkhex[MAX_FINGERPRINT_LEN*2+1];
444         char mainpkhex[MAX_FINGERPRINT_LEN*2+1];
445
446         hexfingerprint (pk, pkhex, sizeof pkhex);
447         hexfingerprint (mainpk, mainpkhex, sizeof mainpkhex);
448
449         /* Note that we do not want to create a trustdb just for
450          * getting the ownertrust: If there is no trustdb there can't
451          * be ulitmately trusted key anyway and thus the ownertrust
452          * value is irrelevant.  */
453         write_status_printf (STATUS_DECRYPTION_KEY, "%s %s %c",
454                              pkhex, mainpkhex,
455                              get_ownertrust_info (ctrl, mainpk, 1));
456
457       }
458
459     release_kbnode (pkb);
460     err = 0;
461   }
462
463  leave:
464   xfree (frame);
465   xfree (keygrip);
466   return err;
467 }
468
469
470 /*
471  * Get the session key from the given string.
472  * String is supposed to be formatted as this:
473  *  <algo-id>:<even-number-of-hex-digits>
474  */
475 gpg_error_t
476 get_override_session_key (DEK *dek, const char *string)
477 {
478   const char *s;
479   int i;
480
481   if (!string)
482     return GPG_ERR_BAD_KEY;
483   dek->algo = atoi (string);
484   if (dek->algo < 1)
485     return GPG_ERR_BAD_KEY;
486   if (!(s = strchr (string, ':')))
487     return GPG_ERR_BAD_KEY;
488   s++;
489   for (i = 0; i < DIM (dek->key) && *s; i++, s += 2)
490     {
491       int c = hextobyte (s);
492       if (c == -1)
493         return GPG_ERR_BAD_KEY;
494       dek->key[i] = c;
495     }
496   if (*s)
497     return GPG_ERR_BAD_KEY;
498   dek->keylen = i;
499   return 0;
500 }