Decryption and signi via agent is now implemented.
[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       char *p;
98
99       for (;;)
100         {
101           if (sk)
102             free_public_key (sk);
103           sk = xmalloc_clear (sizeof *sk);
104           rc = -1; /* FIXME:enum_secret_keys (&enum_context, sk, 1, 0);*/
105           if (rc)
106             {
107               rc = G10ERR_NO_SECKEY;
108               break;
109             }
110           if (sk->pubkey_algo != k->pubkey_algo)
111             continue;
112           keyid_from_pk (sk, keyid);
113           log_info (_("anonymous recipient; trying secret key %s ...\n"),
114                     keystr (keyid));
115
116           if (!opt.try_all_secrets && !is_status_enabled ())
117             {
118               p = get_last_passphrase ();
119               set_next_passphrase (p);
120               xfree (p);
121             }
122
123           /* rc = check_secret_key( sk, opt.try_all_secrets?1:-1 ); /\* ask */
124           /*                                                        only */
125           /*                                                        once *\/ */
126           /* if( !rc ) */
127           {
128             rc = get_it (k, dek, sk, keyid);
129             /* Successfully checked the secret key (either it was a
130                card, had no passphrase, or had the right passphrase)
131                but couldn't decrypt the session key, so thus that key
132                is not the anonymous recipient.  Move the next
133                passphrase into last for the next round.  We only do
134                this if the secret key was successfully checked as in
135                the normal case, check_secret_key handles this for us
136                via passphrase_to_dek.  */
137             if (rc)
138               next_to_last_passphrase ();
139           }
140
141           if (!rc)
142             {
143               log_info (_("okay, we are the anonymous recipient.\n"));
144               break;
145             }
146         }
147       enum_secret_keys (&enum_context, NULL, 0, 0);     /* free context */
148     }
149
150 leave:
151   if (sk)
152     free_public_key (sk);
153   return rc;
154 }
155
156
157 static gpg_error_t
158 get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
159 {
160   gpg_error_t err;
161   byte *frame = NULL;
162   unsigned int n;
163   size_t nframe;
164   u16 csum, csum2;
165   int card = 0;
166   gcry_sexp_t s_data;
167   char *desc;
168   char *keygrip;
169
170   /* Get the keygrip.  */
171   err = hexkeygrip_from_pk (sk, &keygrip);
172   if (err)
173     goto leave;
174
175   /* Convert the data to an S-expression.  */
176   if (sk->pubkey_algo == GCRY_PK_ELG || sk->pubkey_algo == GCRY_PK_ELG_E)
177     {
178       if (!enc->data[0] || !enc->data[1])
179         err = gpg_error (GPG_ERR_BAD_MPI);
180       else
181         err = gcry_sexp_build (&s_data, NULL, "(enc-val(elg(a%m)(b%m)))", 
182                                enc->data[0], enc->data[1]);
183     }
184   else if (sk->pubkey_algo == GCRY_PK_RSA || sk->pubkey_algo == GCRY_PK_RSA_E)
185     {
186       if (!enc->data[0])
187         err = gpg_error (GPG_ERR_BAD_MPI);
188       else
189         err = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))",
190                                enc->data[0]);
191     }
192   else
193     err = gpg_error (GPG_ERR_BUG);
194
195   if (err)
196     goto leave;
197
198   /* Decrypt. */
199   desc = xtrystrdup ("FIXME: Format a description");
200   err = agent_pkdecrypt (NULL, keygrip, desc, s_data, &frame, &nframe);
201   xfree (desc);
202   gcry_sexp_release (s_data);
203   if (err)
204     goto leave;
205
206   /* Now get the DEK (data encryption key) from the frame
207    *
208    * Old versions encode the DEK in in this format (msb is left):
209    *
210    *     0  1  DEK(16 bytes)  CSUM(2 bytes)  0  RND(n bytes) 2
211    *
212    * Later versions encode the DEK like this:
213    *
214    *     0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
215    *
216    * (mpi_get_buffer already removed the leading zero).
217    *
218    * RND are non-zero randow bytes.
219    * A   is the cipher algorithm
220    * DEK is the encryption key (session key) with length k
221    * CSUM
222    */
223   if (DBG_CIPHER)
224     log_printhex ("DEK frame:", frame, nframe);
225   n = 0;
226   if (!card)
227     {
228       if (n + 7 > nframe)
229         {
230           err = gpg_error (G10ERR_WRONG_SECKEY);
231           goto leave;
232         }
233       if (frame[n] == 1 && frame[nframe - 1] == 2)
234         {
235           log_info (_("old encoding of the DEK is not supported\n"));
236           err = gpg_error (G10ERR_CIPHER_ALGO);
237           goto leave;
238         }
239       if (frame[n] != 2) /* Something went wrong.  */
240         {
241           err = gpg_error (G10ERR_WRONG_SECKEY);
242           goto leave;
243         }
244       for (n++; n < nframe && frame[n]; n++) /* Skip the random bytes.  */
245         ;
246       n++; /* Skip the zero byte.  */
247     }
248
249   if (n + 4 > nframe)
250     {
251       err = gpg_error (G10ERR_WRONG_SECKEY);
252       goto leave;
253     }
254
255   dek->keylen = nframe - (n + 1) - 2;
256   dek->algo = frame[n++];
257   if (dek->algo == CIPHER_ALGO_IDEA)
258     write_status (STATUS_RSA_OR_IDEA);
259   err = openpgp_cipher_test_algo (dek->algo);
260   if (err)
261     {
262       if (!opt.quiet && gpg_err_code (err) == GPG_ERR_CIPHER_ALGO)
263         {
264           log_info (_("cipher algorithm %d%s is unknown or disabled\n"),
265                     dek->algo,
266                     dek->algo == CIPHER_ALGO_IDEA ? " (IDEA)" : "");
267           if (dek->algo == CIPHER_ALGO_IDEA)
268             idea_cipher_warn (0);
269         }
270       dek->algo = 0;
271       goto leave;
272     }
273   if (dek->keylen != openpgp_cipher_get_algo_keylen (dek->algo))
274     {
275       err = gpg_error (GPG_ERR_WRONG_SECKEY);
276       goto leave;
277     }
278
279   /* Copy the key to DEK and compare the checksum.  */
280   csum = frame[nframe - 2] << 8;
281   csum |= frame[nframe - 1];
282   memcpy (dek->key, frame + n, dek->keylen);
283   for (csum2 = 0, n = 0; n < dek->keylen; n++)
284     csum2 += dek->key[n];
285   if (csum != csum2)
286     {
287       err = gpg_error (GPG_ERR_WRONG_SECKEY);
288       goto leave;
289     }
290   if (DBG_CIPHER)
291     log_printhex ("DEK is:", dek->key, dek->keylen);
292
293   /* Check that the algo is in the preferences and whether it has expired.  */
294   {
295     PKT_public_key *pk = NULL;
296     KBNODE pkb = get_pubkeyblock (keyid);
297
298     if (!pkb)
299       {
300         err = -1;
301         log_error ("oops: public key not found for preference check\n");
302       }
303     else if (pkb->pkt->pkt.public_key->selfsigversion > 3
304              && dek->algo != CIPHER_ALGO_3DES
305              && !opt.quiet
306              && !is_algo_in_prefs (pkb, PREFTYPE_SYM, dek->algo))
307       log_info (_("WARNING: cipher algorithm %s not found in recipient"
308                   " preferences\n"), openpgp_cipher_algo_name (dek->algo));
309     if (!err)
310       {
311         KBNODE k;
312
313         for (k = pkb; k; k = k->next)
314           {
315             if (k->pkt->pkttype == PKT_PUBLIC_KEY
316                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
317               {
318                 u32 aki[2];
319                 keyid_from_pk (k->pkt->pkt.public_key, aki);
320
321                 if (aki[0] == keyid[0] && aki[1] == keyid[1])
322                   {
323                     pk = k->pkt->pkt.public_key;
324                     break;
325                   }
326               }
327           }
328         if (!pk)
329           BUG ();
330         if (pk->expiredate && pk->expiredate <= make_timestamp ())
331           {
332             log_info (_("NOTE: secret key %s expired at %s\n"),
333                       keystr (keyid), asctimestamp (pk->expiredate));
334           }
335       }
336
337     if (pk && pk->is_revoked)
338       {
339         log_info (_("NOTE: key has been revoked"));
340         log_printf ("\n");
341         show_revocation_reason (pk, 1);
342       }
343
344     release_kbnode (pkb);
345     err = 0;
346   }
347
348  leave:
349   xfree (frame);
350   xfree (keygrip);
351   return err;
352 }
353
354
355 /*
356  * Get the session key from the given string.
357  * String is supposed to be formatted as this:
358  *  <algo-id>:<even-number-of-hex-digits>
359  */
360 gpg_error_t
361 get_override_session_key (DEK *dek, const char *string)
362 {
363   const char *s;
364   int i;
365
366   if (!string)
367     return G10ERR_BAD_KEY;
368   dek->algo = atoi (string);
369   if (dek->algo < 1)
370     return G10ERR_BAD_KEY;
371   if (!(s = strchr (string, ':')))
372     return G10ERR_BAD_KEY;
373   s++;
374   for (i = 0; i < DIM (dek->key) && *s; i++, s += 2)
375     {
376       int c = hextobyte (s);
377       if (c == -1)
378         return G10ERR_BAD_KEY;
379       dek->key[i] = c;
380     }
381   if (*s)
382     return G10ERR_BAD_KEY;
383   dek->keylen = i;
384   return 0;
385 }