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