agent: Include missing prototype.
[gnupg.git] / agent / cvt-openpgp.c
1 /* cvt-openpgp.c - Convert an OpenPGP key to our internal format.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2006, 2009,
3  *               2010 Free Software Foundation, Inc.
4  * Copyright (C) 2013 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "agent.h"
29 #include "i18n.h"
30 #include "cvt-openpgp.h"
31
32
33 /* Helper to pass data via the callback to do_unprotect. */
34 struct try_do_unprotect_arg_s
35 {
36   int  is_v4;
37   int  is_protected;
38   int  pubkey_algo;
39   int  protect_algo;
40   char *iv;
41   int  ivlen;
42   int  s2k_mode;
43   int  s2k_algo;
44   byte *s2k_salt;
45   u32  s2k_count;
46   u16 desired_csum;
47   gcry_mpi_t *skey;
48   size_t skeysize;
49   int skeyidx;
50   gcry_sexp_t *r_key;
51 };
52
53
54
55 /* Compute the keygrip from the public key and store it at GRIP.  */
56 static gpg_error_t
57 get_keygrip (int pubkey_algo, gcry_mpi_t *pkey, unsigned char *grip)
58 {
59   gpg_error_t err;
60   gcry_sexp_t s_pkey = NULL;
61
62   switch (pubkey_algo)
63     {
64     case GCRY_PK_DSA:
65       err = gcry_sexp_build (&s_pkey, NULL,
66                              "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
67                              pkey[0], pkey[1], pkey[2], pkey[3]);
68       break;
69
70     case GCRY_PK_ELG:
71     case GCRY_PK_ELG_E:
72       err = gcry_sexp_build (&s_pkey, NULL,
73                              "(public-key(elg(p%m)(g%m)(y%m)))",
74                              pkey[0], pkey[1], pkey[2]);
75       break;
76
77     case GCRY_PK_RSA:
78     case GCRY_PK_RSA_E:
79     case GCRY_PK_RSA_S:
80       err = gcry_sexp_build (&s_pkey, NULL,
81                              "(public-key(rsa(n%m)(e%m)))", pkey[0], pkey[1]);
82       break;
83
84     case GCRY_PK_ECDSA:
85     case GCRY_PK_ECDH:
86       err = gcry_sexp_build (&s_pkey, NULL,
87                              "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
88                              pkey[0], pkey[1], pkey[2], pkey[3], pkey[4],
89                              pkey[5]);
90       break;
91
92     default:
93       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
94       break;
95     }
96
97   if (!err && !gcry_pk_get_keygrip (s_pkey, grip))
98     err = gpg_error (GPG_ERR_INTERNAL);
99
100   gcry_sexp_release (s_pkey);
101   return err;
102 }
103
104
105 /* Convert a secret key given as algorithm id and an array of key
106    parameters into our s-expression based format.  Note that
107    PUBKEY_ALGO has an gcrypt algorithm number. */
108 static gpg_error_t
109 convert_secret_key (gcry_sexp_t *r_key, int pubkey_algo, gcry_mpi_t *skey)
110 {
111   gpg_error_t err;
112   gcry_sexp_t s_skey = NULL;
113
114   *r_key = NULL;
115
116   switch (pubkey_algo)
117     {
118     case GCRY_PK_DSA:
119       err = gcry_sexp_build (&s_skey, NULL,
120                              "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
121                              skey[0], skey[1], skey[2], skey[3], skey[4]);
122       break;
123
124     case GCRY_PK_ELG:
125     case GCRY_PK_ELG_E:
126       err = gcry_sexp_build (&s_skey, NULL,
127                              "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
128                              skey[0], skey[1], skey[2], skey[3]);
129       break;
130
131
132     case GCRY_PK_RSA:
133     case GCRY_PK_RSA_E:
134     case GCRY_PK_RSA_S:
135       err = gcry_sexp_build (&s_skey, NULL,
136                              "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
137                              skey[0], skey[1], skey[2], skey[3], skey[4],
138                              skey[5]);
139       break;
140
141     case GCRY_PK_ECDSA:
142     case GCRY_PK_ECDH:
143       /* Although our code would work with "ecc" we explicitly use
144          "ecdh" or "ecdsa" to implicitly set the key capabilities.  */
145       err = gcry_sexp_build (&s_skey, NULL,
146                              "(private-key(%s(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)"
147                              "(d%m)))",
148                              pubkey_algo == GCRY_PK_ECDSA?"ecdsa":"ecdh",
149                              skey[0], skey[1], skey[2], skey[3], skey[4],
150                              skey[5], skey[6]);
151       break;
152
153     default:
154       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
155       break;
156     }
157
158   if (!err)
159     *r_key = s_skey;
160   return err;
161 }
162
163
164 /* Convert a secret key given as algorithm id, an array of key
165    parameters, and an S-expression of the original OpenPGP transfer
166    key into our s-expression based format.  This is a variant of
167    convert_secret_key which is used for the openpgp-native protection
168    mode.  Note that PUBKEY_ALGO has an gcrypt algorithm number. */
169 static gpg_error_t
170 convert_transfer_key (gcry_sexp_t *r_key, int pubkey_algo, gcry_mpi_t *skey,
171                       gcry_sexp_t transfer_key)
172 {
173   gpg_error_t err;
174   gcry_sexp_t s_skey = NULL;
175
176   *r_key = NULL;
177
178   switch (pubkey_algo)
179     {
180     case GCRY_PK_DSA:
181       err = gcry_sexp_build
182         (&s_skey, NULL,
183          "(protected-private-key(dsa(p%m)(q%m)(g%m)(y%m)"
184          "(protected openpgp-native%S)))",
185          skey[0], skey[1], skey[2], skey[3], transfer_key);
186       break;
187
188     case GCRY_PK_ELG:
189     case GCRY_PK_ELG_E:
190       err = gcry_sexp_build
191         (&s_skey, NULL,
192          "(protected-private-key(elg(p%m)(g%m)(y%m)"
193          "(protected openpgp-native%S)))",
194          skey[0], skey[1], skey[2], transfer_key);
195       break;
196
197
198     case GCRY_PK_RSA:
199     case GCRY_PK_RSA_E:
200     case GCRY_PK_RSA_S:
201       err = gcry_sexp_build
202         (&s_skey, NULL,
203          "(protected-private-key(rsa(n%m)(e%m)",
204          "(protected openpgp-native%S)))",
205          skey[0], skey[1], transfer_key );
206       break;
207
208     case GCRY_PK_ECDSA:
209     case GCRY_PK_ECDH:
210       /* Although our code would work with "ecc" we explicitly use
211          "ecdh" or "ecdsa" to implicitly set the key capabilities.  */
212       err = gcry_sexp_build
213         (&s_skey, NULL,
214          "(protected-private-key(%s(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)"
215          "(protected openpgp-native%S)))",
216          pubkey_algo == GCRY_PK_ECDSA?"ecdsa":"ecdh",
217          skey[0], skey[1], skey[2], skey[3], skey[4], skey[5], transfer_key);
218       break;
219
220     default:
221       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
222       break;
223     }
224
225   if (!err)
226     *r_key = s_skey;
227   return err;
228 }
229
230
231 /* Hash the passphrase and set the key. */
232 static gpg_error_t
233 hash_passphrase_and_set_key (const char *passphrase,
234                              gcry_cipher_hd_t hd, int protect_algo,
235                              int s2k_mode, int s2k_algo,
236                              byte *s2k_salt, u32 s2k_count)
237 {
238   gpg_error_t err;
239   unsigned char *key;
240   size_t keylen;
241
242   keylen = gcry_cipher_get_algo_keylen (protect_algo);
243   if (!keylen)
244     return gpg_error (GPG_ERR_INTERNAL);
245
246   key = xtrymalloc_secure (keylen);
247   if (!key)
248     return gpg_error_from_syserror ();
249
250   err = s2k_hash_passphrase (passphrase,
251                              s2k_algo, s2k_mode, s2k_salt, s2k_count,
252                              key, keylen);
253   if (!err)
254     err = gcry_cipher_setkey (hd, key, keylen);
255
256   xfree (key);
257   return err;
258 }
259
260
261 static u16
262 checksum (const unsigned char *p, unsigned int n)
263 {
264   u16 a;
265
266   for (a=0; n; n-- )
267     a += *p++;
268   return a;
269 }
270
271
272 /* Helper for do_unprotect.  PUBKEY_ALOGO is the gcrypt algo number.
273    On success R_NPKEY and R_NSKEY receive the number or parameters for
274    the algorithm PUBKEY_ALGO and R_SKEYLEN the used length of
275    SKEY.  */
276 static int
277 prepare_unprotect (int pubkey_algo, gcry_mpi_t *skey, size_t skeysize,
278                    int s2k_mode,
279                    unsigned int *r_npkey, unsigned int *r_nskey,
280                    unsigned int *r_skeylen)
281 {
282   gpg_error_t err;
283   size_t npkey, nskey, skeylen;
284   int i;
285
286   /* Count the actual number of MPIs is in the array and set the
287      remainder to NULL for easier processing later on.  */
288   for (skeylen = 0; skey[skeylen]; skeylen++)
289     ;
290   for (i=skeylen; i < skeysize; i++)
291     skey[i] = NULL;
292
293   /* Check some args.  */
294   if (s2k_mode == 1001)
295     {
296       /* Stub key.  */
297       log_info (_("secret key parts are not available\n"));
298       return gpg_error (GPG_ERR_UNUSABLE_SECKEY);
299     }
300
301   if (gcry_pk_test_algo (pubkey_algo))
302     {
303       log_info (_("public key algorithm %d (%s) is not supported\n"),
304                 pubkey_algo, gcry_pk_algo_name (pubkey_algo));
305       return gpg_error (GPG_ERR_PUBKEY_ALGO);
306     }
307
308   /* Get properties of the public key algorithm and do some
309      consistency checks.  Note that we need at least NPKEY+1 elements
310      in the SKEY array. */
311   if ( (err = gcry_pk_algo_info (pubkey_algo, GCRYCTL_GET_ALGO_NPKEY,
312                                  NULL, &npkey))
313        || (err = gcry_pk_algo_info (pubkey_algo, GCRYCTL_GET_ALGO_NSKEY,
314                                     NULL, &nskey)))
315     return err;
316   if (!npkey || npkey >= nskey)
317     return gpg_error (GPG_ERR_INTERNAL);
318   if (skeylen <= npkey)
319     return gpg_error (GPG_ERR_MISSING_VALUE);
320   if (nskey+1 >= skeysize)
321     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
322
323   /* Check that the public key parameters are all available and not
324      encrypted.  */
325   for (i=0; i < npkey; i++)
326     {
327       if (!skey[i] || gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_OPAQUE))
328         return gpg_error (GPG_ERR_BAD_SECKEY);
329     }
330
331   if (r_npkey)
332     *r_npkey = npkey;
333   if (r_nskey)
334     *r_nskey = nskey;
335   if (r_skeylen)
336     *r_skeylen = skeylen;
337   return 0;
338 }
339
340
341 /* Note that this function modifies SKEY.  SKEYSIZE is the allocated
342    size of the array including the NULL item; this is used for a
343    bounds check.  On success a converted key is stored at R_KEY.  */
344 static int
345 do_unprotect (const char *passphrase,
346               int pkt_version, int pubkey_algo, int is_protected,
347               gcry_mpi_t *skey, size_t skeysize,
348               int protect_algo, void *protect_iv, size_t protect_ivlen,
349               int s2k_mode, int s2k_algo, byte *s2k_salt, u32 s2k_count,
350               u16 desired_csum, gcry_sexp_t *r_key)
351 {
352   gpg_error_t err;
353   unsigned int npkey, nskey, skeylen;
354   gcry_cipher_hd_t cipher_hd = NULL;
355   u16 actual_csum;
356   size_t nbytes;
357   int i;
358   gcry_mpi_t tmpmpi;
359
360   *r_key = NULL;
361
362   /* Unfortunately, the OpenPGP PK algorithm numbers need to be
363      re-mapped for Libgcrypt.    */
364   pubkey_algo = map_pk_openpgp_to_gcry (pubkey_algo);
365
366   err = prepare_unprotect (pubkey_algo, skey, skeysize, s2k_mode,
367                            &npkey, &nskey, &skeylen);
368   if (err)
369     return err;
370
371   /* Check whether SKEY is at all protected.  If it is not protected
372      merely verify the checksum.  */
373   if (!is_protected)
374     {
375       unsigned char *buffer;
376
377       actual_csum = 0;
378       for (i=npkey; i < nskey; i++)
379         {
380           if (!skey[i] || gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_OPAQUE))
381             return gpg_error (GPG_ERR_BAD_SECKEY);
382
383           err = gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, skey[i]);
384           if (!err)
385             {
386               buffer = (gcry_is_secure (skey[i])?
387                         xtrymalloc_secure (nbytes) : xtrymalloc (nbytes));
388               if (!buffer)
389                 return gpg_error_from_syserror ();
390               err = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes,
391                                     NULL, skey[i]);
392               if (!err)
393                 actual_csum += checksum (buffer, nbytes);
394               xfree (buffer);
395             }
396           if (err)
397             return err;
398         }
399
400       if (actual_csum != desired_csum)
401         return gpg_error (GPG_ERR_CHECKSUM);
402       return 0;
403     }
404
405
406   if (gcry_cipher_test_algo (protect_algo))
407     {
408       /* The algorithm numbers are Libgcrypt numbers but fortunately
409          the OpenPGP algorithm numbers map one-to-one to the Libgcrypt
410          numbers.  */
411       log_info (_("protection algorithm %d (%s) is not supported\n"),
412                 protect_algo, gnupg_cipher_algo_name (protect_algo));
413       return gpg_error (GPG_ERR_CIPHER_ALGO);
414     }
415
416   if (gcry_md_test_algo (s2k_algo))
417     {
418       log_info (_("protection hash algorithm %d (%s) is not supported\n"),
419                 s2k_algo, gcry_md_algo_name (s2k_algo));
420       return gpg_error (GPG_ERR_DIGEST_ALGO);
421     }
422
423   err = gcry_cipher_open (&cipher_hd, protect_algo,
424                           GCRY_CIPHER_MODE_CFB,
425                           (GCRY_CIPHER_SECURE
426                            | (protect_algo >= 100 ?
427                               0 : GCRY_CIPHER_ENABLE_SYNC)));
428   if (err)
429     {
430       log_error ("failed to open cipher_algo %d: %s\n",
431                  protect_algo, gpg_strerror (err));
432       return err;
433     }
434
435   err = hash_passphrase_and_set_key (passphrase, cipher_hd, protect_algo,
436                                      s2k_mode, s2k_algo, s2k_salt, s2k_count);
437   if (err)
438     {
439       gcry_cipher_close (cipher_hd);
440       return err;
441     }
442
443   gcry_cipher_setiv (cipher_hd, protect_iv, protect_ivlen);
444
445   actual_csum = 0;
446   if (pkt_version >= 4)
447     {
448       int ndata;
449       unsigned int ndatabits;
450       unsigned char *p, *data;
451       u16 csum_pgp7 = 0;
452
453       if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE ))
454         {
455           gcry_cipher_close (cipher_hd);
456           return gpg_error (GPG_ERR_BAD_SECKEY);
457         }
458       p = gcry_mpi_get_opaque (skey[npkey], &ndatabits);
459       ndata = (ndatabits+7)/8;
460
461       if (ndata > 1)
462         csum_pgp7 = p[ndata-2] << 8 | p[ndata-1];
463       data = xtrymalloc_secure (ndata);
464       if (!data)
465         {
466           err = gpg_error_from_syserror ();
467           gcry_cipher_close (cipher_hd);
468           return err;
469         }
470       gcry_cipher_decrypt (cipher_hd, data, ndata, p, ndata);
471
472       p = data;
473       if (is_protected == 2)
474         {
475           /* This is the new SHA1 checksum method to detect tampering
476              with the key as used by the Klima/Rosa attack.  */
477           desired_csum = 0;
478           actual_csum = 1;  /* Default to bad checksum.  */
479
480           if (ndata < 20)
481             log_error ("not enough bytes for SHA-1 checksum\n");
482           else
483             {
484               gcry_md_hd_t h;
485
486               if (gcry_md_open (&h, GCRY_MD_SHA1, 1))
487                 BUG(); /* Algo not available. */
488               gcry_md_write (h, data, ndata - 20);
489               gcry_md_final (h);
490               if (!memcmp (gcry_md_read (h, GCRY_MD_SHA1), data+ndata-20, 20))
491                 actual_csum = 0; /* Digest does match.  */
492               gcry_md_close (h);
493             }
494         }
495       else
496         {
497           /* Old 16 bit checksum method.  */
498           if (ndata < 2)
499             {
500               log_error ("not enough bytes for checksum\n");
501               desired_csum = 0;
502               actual_csum = 1;  /* Mark checksum bad.  */
503             }
504           else
505             {
506               desired_csum = (data[ndata-2] << 8 | data[ndata-1]);
507               actual_csum = checksum (data, ndata-2);
508               if (desired_csum != actual_csum)
509                 {
510                   /* This is a PGP 7.0.0 workaround */
511                   desired_csum = csum_pgp7; /* Take the encrypted one.  */
512                 }
513             }
514         }
515
516       /* Better check it here.  Otherwise the gcry_mpi_scan would fail
517          because the length may have an arbitrary value.  */
518       if (desired_csum == actual_csum)
519         {
520           for (i=npkey; i < nskey; i++ )
521             {
522               if (gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_PGP, p, ndata, &nbytes))
523                 {
524                   /* Checksum was okay, but not correctly decrypted.  */
525                   desired_csum = 0;
526                   actual_csum = 1;   /* Mark checksum bad.  */
527                   break;
528                 }
529               gcry_mpi_release (skey[i]);
530               skey[i] = tmpmpi;
531               ndata -= nbytes;
532               p += nbytes;
533             }
534           skey[i] = NULL;
535           skeylen = i;
536           assert (skeylen <= skeysize);
537
538           /* Note: at this point NDATA should be 2 for a simple
539              checksum or 20 for the sha1 digest.  */
540         }
541       xfree(data);
542     }
543   else /* Packet version <= 3.  */
544     {
545       unsigned char *buffer;
546
547       for (i = npkey; i < nskey; i++)
548         {
549           unsigned char *p;
550           size_t ndata;
551           unsigned int ndatabits;
552
553           if (!skey[i] || !gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_OPAQUE))
554             {
555               gcry_cipher_close (cipher_hd);
556               return gpg_error (GPG_ERR_BAD_SECKEY);
557             }
558           p = gcry_mpi_get_opaque (skey[i], &ndatabits);
559           ndata = (ndatabits+7)/8;
560
561           if (!(ndata >= 2) || !(ndata == ((p[0] << 8 | p[1]) + 7)/8 + 2))
562             {
563               gcry_cipher_close (cipher_hd);
564               return gpg_error (GPG_ERR_BAD_SECKEY);
565             }
566
567           buffer = xtrymalloc_secure (ndata);
568           if (!buffer)
569             {
570               err = gpg_error_from_syserror ();
571               gcry_cipher_close (cipher_hd);
572               return err;
573             }
574
575           gcry_cipher_sync (cipher_hd);
576           buffer[0] = p[0];
577           buffer[1] = p[1];
578           gcry_cipher_decrypt (cipher_hd, buffer+2, ndata-2, p+2, ndata-2);
579           actual_csum += checksum (buffer, ndata);
580           err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_PGP, buffer, ndata, &ndata);
581           xfree (buffer);
582           if (err)
583             {
584               /* Checksum was okay, but not correctly decrypted.  */
585               desired_csum = 0;
586               actual_csum = 1;   /* Mark checksum bad.  */
587               break;
588             }
589           gcry_mpi_release (skey[i]);
590           skey[i] = tmpmpi;
591         }
592     }
593   gcry_cipher_close (cipher_hd);
594
595   /* Now let's see whether we have used the correct passphrase. */
596   if (actual_csum != desired_csum)
597     return gpg_error (GPG_ERR_BAD_PASSPHRASE);
598
599   if (nskey != skeylen)
600     err = gpg_error (GPG_ERR_BAD_SECKEY);
601   else
602     err = convert_secret_key (r_key, pubkey_algo, skey);
603   if (err)
604     return err;
605
606   /* The checksum may fail, thus we also check the key itself.  */
607   err = gcry_pk_testkey (*r_key);
608   if (err)
609     {
610       gcry_sexp_release (*r_key);
611       *r_key = NULL;
612       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
613     }
614
615   return 0;
616 }
617
618
619 /* Callback function to try the unprotection from the passphrase query
620    code.  */
621 static int
622 try_do_unprotect_cb (struct pin_entry_info_s *pi)
623 {
624   gpg_error_t err;
625   struct try_do_unprotect_arg_s *arg = pi->check_cb_arg;
626
627   err = do_unprotect (pi->pin,
628                       arg->is_v4? 4:3,
629                       arg->pubkey_algo, arg->is_protected,
630                       arg->skey, arg->skeysize,
631                       arg->protect_algo, arg->iv, arg->ivlen,
632                       arg->s2k_mode, arg->s2k_algo,
633                       arg->s2k_salt, arg->s2k_count,
634                       arg->desired_csum, arg->r_key);
635   /* SKEY may be modified now, thus we need to re-compute SKEYIDX.  */
636   for (arg->skeyidx = 0; (arg->skeyidx < arg->skeysize
637                           && arg->skey[arg->skeyidx]); arg->skeyidx++)
638     ;
639   return err;
640 }
641
642
643 /* See convert_from_openpgp for the core of the description.  This
644    function adds an optional PASSPHRASE argument and uses this to
645    silently decrypt the key; CACHE_NONCE and R_PASSPHRASE must both be
646    NULL in this mode.  */
647 static gpg_error_t
648 convert_from_openpgp_main (ctrl_t ctrl, gcry_sexp_t s_pgp,
649                            unsigned char *grip, const char *prompt,
650                            const char *cache_nonce, const char *passphrase,
651                            unsigned char **r_key, char **r_passphrase)
652 {
653   gpg_error_t err;
654   int unattended;
655   int from_native;
656   gcry_sexp_t top_list;
657   gcry_sexp_t list = NULL;
658   const char *value;
659   size_t valuelen;
660   char *string;
661   int  idx;
662   int  is_v4, is_protected;
663   int  pubkey_algo;
664   int  protect_algo = 0;
665   char iv[16];
666   int  ivlen = 0;
667   int  s2k_mode = 0;
668   int  s2k_algo = 0;
669   byte s2k_salt[8];
670   u32  s2k_count = 0;
671   size_t npkey, nskey;
672   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
673   u16 desired_csum;
674   int skeyidx = 0;
675   gcry_sexp_t s_skey = NULL;
676
677   *r_key = NULL;
678   if (r_passphrase)
679     *r_passphrase = NULL;
680   unattended = !r_passphrase;
681   from_native = (!cache_nonce && passphrase && !r_passphrase);
682
683   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
684   if (!top_list)
685     goto bad_seckey;
686
687   list = gcry_sexp_find_token (top_list, "version", 0);
688   if (!list)
689     goto bad_seckey;
690   value = gcry_sexp_nth_data (list, 1, &valuelen);
691   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
692     goto bad_seckey;
693   is_v4 = (value[0] == '4');
694
695   gcry_sexp_release (list);
696   list = gcry_sexp_find_token (top_list, "protection", 0);
697   if (!list)
698     goto bad_seckey;
699   value = gcry_sexp_nth_data (list, 1, &valuelen);
700   if (!value)
701     goto bad_seckey;
702   if (valuelen == 4 && !memcmp (value, "sha1", 4))
703     is_protected = 2;
704   else if (valuelen == 3 && !memcmp (value, "sum", 3))
705     is_protected = 1;
706   else if (valuelen == 4 && !memcmp (value, "none", 4))
707     is_protected = 0;
708   else
709     goto bad_seckey;
710
711   if (is_protected)
712     {
713       string = gcry_sexp_nth_string (list, 2);
714       if (!string)
715         goto bad_seckey;
716       protect_algo = gcry_cipher_map_name (string);
717       if (!protect_algo && !!strcmp (string, "IDEA"))
718         protect_algo = GCRY_CIPHER_IDEA;
719       xfree (string);
720
721       value = gcry_sexp_nth_data (list, 3, &valuelen);
722       if (!value || !valuelen || valuelen > sizeof iv)
723         goto bad_seckey;
724       memcpy (iv, value, valuelen);
725       ivlen = valuelen;
726
727       string = gcry_sexp_nth_string (list, 4);
728       if (!string)
729         goto bad_seckey;
730       s2k_mode = strtol (string, NULL, 10);
731       xfree (string);
732
733       string = gcry_sexp_nth_string (list, 5);
734       if (!string)
735         goto bad_seckey;
736       s2k_algo = gcry_md_map_name (string);
737       xfree (string);
738
739       value = gcry_sexp_nth_data (list, 6, &valuelen);
740       if (!value || !valuelen || valuelen > sizeof s2k_salt)
741         goto bad_seckey;
742       memcpy (s2k_salt, value, valuelen);
743
744       string = gcry_sexp_nth_string (list, 7);
745       if (!string)
746         goto bad_seckey;
747       s2k_count = strtoul (string, NULL, 10);
748       xfree (string);
749     }
750
751   gcry_sexp_release (list);
752   list = gcry_sexp_find_token (top_list, "algo", 0);
753   if (!list)
754     goto bad_seckey;
755   string = gcry_sexp_nth_string (list, 1);
756   if (!string)
757     goto bad_seckey;
758   pubkey_algo = gcry_pk_map_name (string);
759   xfree (string);
760
761   if (gcry_pk_algo_info (pubkey_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
762       || gcry_pk_algo_info (pubkey_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
763       || !npkey || npkey >= nskey)
764     goto bad_seckey;
765
766   gcry_sexp_release (list);
767   list = gcry_sexp_find_token (top_list, "skey", 0);
768   if (!list)
769     goto bad_seckey;
770   for (idx=0;;)
771     {
772       int is_enc;
773
774       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
775       if (!value && skeyidx >= npkey)
776         break;  /* Ready.  */
777
778       /* Check for too many parameters.  Note that depending on the
779          protection mode and version number we may see less than NSKEY
780          (but at least NPKEY+1) parameters.  */
781       if (idx >= 2*nskey)
782         goto bad_seckey;
783       if (skeyidx >= DIM (skey)-1)
784         goto bad_seckey;
785
786       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
787         goto bad_seckey;
788       is_enc = (value[0] == 'e');
789       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
790       if (!value || !valuelen)
791         goto bad_seckey;
792       if (is_enc)
793         {
794           void *p = xtrymalloc (valuelen);
795           if (!p)
796             goto outofmem;
797           memcpy (p, value, valuelen);
798           skey[skeyidx] = gcry_mpi_set_opaque (NULL, p, valuelen*8);
799           if (!skey[skeyidx])
800             goto outofmem;
801         }
802       else
803         {
804           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
805                              value, valuelen, NULL))
806             goto bad_seckey;
807         }
808       skeyidx++;
809     }
810   skey[skeyidx++] = NULL;
811
812   gcry_sexp_release (list);
813   list = gcry_sexp_find_token (top_list, "csum", 0);
814   if (list)
815     {
816       string = gcry_sexp_nth_string (list, 1);
817       if (!string)
818         goto bad_seckey;
819       desired_csum = strtoul (string, NULL, 10);
820       xfree (string);
821     }
822   else
823     desired_csum = 0;
824
825
826   gcry_sexp_release (list); list = NULL;
827   gcry_sexp_release (top_list); top_list = NULL;
828
829   /* log_debug ("XXX is_v4=%d\n", is_v4); */
830   /* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
831   /* log_debug ("XXX is_protected=%d\n", is_protected); */
832   /* log_debug ("XXX protect_algo=%d\n", protect_algo); */
833   /* log_printhex ("XXX iv", iv, ivlen); */
834   /* log_debug ("XXX ivlen=%d\n", ivlen); */
835   /* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
836   /* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
837   /* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
838   /* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
839   /* for (idx=0; skey[idx]; idx++) */
840   /*   { */
841   /*     int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
842   /*     log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
843   /*     if (is_enc) */
844   /*       { */
845   /*         void *p; */
846   /*         unsigned int nbits; */
847   /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
848   /*         log_printhex (NULL, p, (nbits+7)/8); */
849   /*       } */
850   /*     else */
851   /*       gcry_mpi_dump (skey[idx]); */
852   /*     log_printf ("\n"); */
853   /*   } */
854
855   err = get_keygrip (pubkey_algo, skey, grip);
856   if (err)
857     goto leave;
858
859   if (!from_native && !agent_key_available (grip))
860     {
861       err = gpg_error (GPG_ERR_EEXIST);
862       goto leave;
863     }
864
865   if (unattended && !from_native)
866     {
867       int pubkey_g_algo = map_pk_openpgp_to_gcry (pubkey_algo);
868
869       err = prepare_unprotect (pubkey_g_algo, skey, DIM(skey), s2k_mode,
870                                NULL, NULL, NULL);
871       if (err)
872         goto leave;
873
874       err = convert_transfer_key (&s_skey, pubkey_g_algo, skey, s_pgp);
875       if (err)
876         goto leave;
877     }
878   else
879     {
880       struct pin_entry_info_s *pi;
881       struct try_do_unprotect_arg_s pi_arg;
882
883       pi = xtrycalloc_secure (1, sizeof (*pi) + 100);
884       if (!pi)
885         return gpg_error_from_syserror ();
886       pi->max_length = 100;
887       pi->min_digits = 0;  /* We want a real passphrase.  */
888       pi->max_digits = 16;
889       pi->max_tries = 3;
890       pi->check_cb = try_do_unprotect_cb;
891       pi->check_cb_arg = &pi_arg;
892       pi_arg.is_v4 = is_v4;
893       pi_arg.is_protected = is_protected;
894       pi_arg.pubkey_algo = pubkey_algo;
895       pi_arg.protect_algo = protect_algo;
896       pi_arg.iv = iv;
897       pi_arg.ivlen = ivlen;
898       pi_arg.s2k_mode = s2k_mode;
899       pi_arg.s2k_algo = s2k_algo;
900       pi_arg.s2k_salt = s2k_salt;
901       pi_arg.s2k_count = s2k_count;
902       pi_arg.desired_csum = desired_csum;
903       pi_arg.skey = skey;
904       pi_arg.skeysize = DIM (skey);
905       pi_arg.skeyidx = skeyidx;
906       pi_arg.r_key = &s_skey;
907
908       err = gpg_error (GPG_ERR_BAD_PASSPHRASE);
909       if (cache_nonce)
910         {
911           char *cache_value;
912
913           cache_value = agent_get_cache (cache_nonce, CACHE_MODE_NONCE);
914           if (cache_value)
915             {
916               if (strlen (cache_value) < pi->max_length)
917                 strcpy (pi->pin, cache_value);
918               xfree (cache_value);
919             }
920           if (*pi->pin)
921             err = try_do_unprotect_cb (pi);
922         }
923       else if (from_native)
924         {
925           if (strlen (passphrase) < pi->max_length)
926             strcpy (pi->pin, passphrase);
927           err = try_do_unprotect_cb (pi);
928         }
929       if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE && !from_native)
930         err = agent_askpin (ctrl, prompt, NULL, NULL, pi);
931       skeyidx = pi_arg.skeyidx;
932       if (!err && r_passphrase)
933         {
934           *r_passphrase = xtrystrdup (pi->pin);
935           if (!*r_passphrase)
936             err = gpg_error_from_syserror ();
937         }
938       xfree (pi);
939       if (err)
940         goto leave;
941     }
942
943   /* Save some memory and get rid of the SKEY array now.  */
944   for (idx=0; idx < skeyidx; idx++)
945     gcry_mpi_release (skey[idx]);
946   skeyidx = 0;
947
948   /* Note that the padding is not required - we use it only because
949      that function allows us to create the result in secure memory.  */
950   err = make_canon_sexp_pad (s_skey, 1, r_key, NULL);
951
952  leave:
953   gcry_sexp_release (s_skey);
954   gcry_sexp_release (list);
955   gcry_sexp_release (top_list);
956   for (idx=0; idx < skeyidx; idx++)
957     gcry_mpi_release (skey[idx]);
958   if (err && r_passphrase)
959     {
960       xfree (*r_passphrase);
961       *r_passphrase = NULL;
962     }
963   return err;
964
965  bad_seckey:
966   err = gpg_error (GPG_ERR_BAD_SECKEY);
967   goto leave;
968
969  outofmem:
970   err = gpg_error (GPG_ERR_ENOMEM);
971   goto leave;
972
973 }
974
975
976 /* Convert an OpenPGP transfer key into our internal format.  Before
977    asking for a passphrase we check whether the key already exists in
978    our key storage.  S_PGP is the OpenPGP key in transfer format.  If
979    CACHE_NONCE is given the passphrase will be looked up in the cache.
980    On success R_KEY will receive a canonical encoded S-expression with
981    the unprotected key in our internal format; the caller needs to
982    release that memory.  The passphrase used to decrypt the OpenPGP
983    key will be returned at R_PASSPHRASE; the caller must release this
984    passphrase.  If R_PASSPHRASE is NULL the unattended conversion mode
985    will be used which uses the openpgp-native protection format for
986    the key.  The keygrip will be stored at the 20 byte buffer pointed
987    to by GRIP.  On error NULL is stored at all return arguments.  */
988 gpg_error_t
989 convert_from_openpgp (ctrl_t ctrl, gcry_sexp_t s_pgp,
990                       unsigned char *grip, const char *prompt,
991                       const char *cache_nonce,
992                       unsigned char **r_key, char **r_passphrase)
993 {
994   return convert_from_openpgp_main (ctrl, s_pgp, grip, prompt,
995                                     cache_nonce, NULL,
996                                     r_key, r_passphrase);
997 }
998
999 /* This function is called by agent_unprotect to re-protect an
1000    openpgp-native protected private-key into the standard private-key
1001    protection format.  */
1002 gpg_error_t
1003 convert_from_openpgp_native (ctrl_t ctrl,
1004                              gcry_sexp_t s_pgp, const char *passphrase,
1005                              unsigned char **r_key)
1006 {
1007   gpg_error_t err;
1008   unsigned char grip[20];
1009
1010   if (!passphrase)
1011     return gpg_error (GPG_ERR_INTERNAL);
1012
1013   err = convert_from_openpgp_main (ctrl, s_pgp, grip, NULL,
1014                                    NULL, passphrase,
1015                                    r_key, NULL);
1016
1017   /* On success try to re-write the key.  */
1018   if (!err)
1019     {
1020       unsigned char *protectedkey = NULL;
1021       size_t protectedkeylen;
1022
1023       if (!agent_protect (*r_key, passphrase, &protectedkey, &protectedkeylen,
1024                           ctrl->s2k_count))
1025         agent_write_private_key (grip, protectedkey, protectedkeylen, 1);
1026       xfree (protectedkey);
1027     }
1028
1029   return err;
1030 }
1031
1032
1033 \f
1034 static gpg_error_t
1035 key_from_sexp (gcry_sexp_t sexp, const char *elems, gcry_mpi_t *array)
1036 {
1037   gpg_error_t err = 0;
1038   gcry_sexp_t l2;
1039   int idx;
1040
1041   for (idx=0; *elems; elems++, idx++)
1042     {
1043       l2 = gcry_sexp_find_token (sexp, elems, 1);
1044       if (!l2)
1045         {
1046           err = gpg_error (GPG_ERR_NO_OBJ); /* Required parameter not found.  */
1047           goto leave;
1048         }
1049       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1050       gcry_sexp_release (l2);
1051       if (!array[idx])
1052         {
1053           err = gpg_error (GPG_ERR_INV_OBJ); /* Required parameter invalid.  */
1054           goto leave;
1055         }
1056     }
1057
1058  leave:
1059   if (err)
1060     {
1061       int i;
1062
1063       for (i=0; i < idx; i++)
1064         {
1065           gcry_mpi_release (array[i]);
1066           array[i] = NULL;
1067         }
1068     }
1069   return err;
1070 }
1071
1072
1073 /* Given an ARRAY of mpis with the key parameters, protect the secret
1074    parameters in that array and replace them by one opaque encoded
1075    mpi.  NPKEY is the number of public key parameters and NSKEY is
1076    the number of secret key parameters (including the public ones).
1077    On success the array will have NPKEY+1 elements.  */
1078 static gpg_error_t
1079 apply_protection (gcry_mpi_t *array, int npkey, int nskey,
1080                   const char *passphrase,
1081                   int protect_algo, void *protect_iv, size_t protect_ivlen,
1082                   int s2k_mode, int s2k_algo, byte *s2k_salt, u32 s2k_count)
1083 {
1084   gpg_error_t err;
1085   int i, j;
1086   gcry_cipher_hd_t cipherhd;
1087   unsigned char *bufarr[10];
1088   size_t narr[10];
1089   unsigned int nbits[10];
1090   int ndata;
1091   unsigned char *p, *data;
1092
1093   assert (npkey < nskey);
1094   assert (nskey < DIM (bufarr));
1095
1096   /* Collect only the secret key parameters into BUFARR et al and
1097      compute the required size of the data buffer.  */
1098   ndata = 20; /* Space for the SHA-1 checksum.  */
1099   for (i = npkey, j = 0; i < nskey; i++, j++ )
1100     {
1101       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, bufarr+j, narr+j, array[i]);
1102       if (err)
1103         {
1104           err = gpg_error_from_syserror ();
1105           for (i = 0; i < j; i++)
1106             xfree (bufarr[i]);
1107           return err;
1108         }
1109       nbits[j] = gcry_mpi_get_nbits (array[i]);
1110       ndata += 2 + narr[j];
1111     }
1112
1113   /* Allocate data buffer and stuff it with the secret key parameters.  */
1114   data = xtrymalloc_secure (ndata);
1115   if (!data)
1116     {
1117       err = gpg_error_from_syserror ();
1118       for (i = 0; i < (nskey-npkey); i++ )
1119         xfree (bufarr[i]);
1120       return err;
1121     }
1122   p = data;
1123   for (i = 0; i < (nskey-npkey); i++ )
1124     {
1125       *p++ = nbits[i] >> 8 ;
1126       *p++ = nbits[i];
1127       memcpy (p, bufarr[i], narr[i]);
1128       p += narr[i];
1129       xfree (bufarr[i]);
1130       bufarr[i] = NULL;
1131     }
1132   assert (p == data + ndata - 20);
1133
1134   /* Append a hash of the secret key parameters.  */
1135   gcry_md_hash_buffer (GCRY_MD_SHA1, p, data, ndata - 20);
1136
1137   /* Encrypt it.  */
1138   err = gcry_cipher_open (&cipherhd, protect_algo,
1139                           GCRY_CIPHER_MODE_CFB, GCRY_CIPHER_SECURE);
1140   if (!err)
1141     err = hash_passphrase_and_set_key (passphrase, cipherhd, protect_algo,
1142                                        s2k_mode, s2k_algo, s2k_salt, s2k_count);
1143   if (!err)
1144     err = gcry_cipher_setiv (cipherhd, protect_iv, protect_ivlen);
1145   if (!err)
1146     err = gcry_cipher_encrypt (cipherhd, data, ndata, NULL, 0);
1147   gcry_cipher_close (cipherhd);
1148   if (err)
1149     {
1150       xfree (data);
1151       return err;
1152     }
1153
1154   /* Replace the secret key parameters in the array by one opaque value.  */
1155   for (i = npkey; i < nskey; i++ )
1156     {
1157       gcry_mpi_release (array[i]);
1158       array[i] = NULL;
1159     }
1160   array[npkey] = gcry_mpi_set_opaque (NULL, data, ndata*8);
1161   return 0;
1162 }
1163
1164
1165 /* Convert our key S_KEY into an OpenPGP key transfer format.  On
1166    success a canonical encoded S-expression is stored at R_TRANSFERKEY
1167    and its length at R_TRANSFERKEYLEN; this S-expression is also
1168    padded to a multiple of 64 bits.  */
1169 gpg_error_t
1170 convert_to_openpgp (ctrl_t ctrl, gcry_sexp_t s_key, const char *passphrase,
1171                     unsigned char **r_transferkey, size_t *r_transferkeylen)
1172 {
1173   gpg_error_t err;
1174   gcry_sexp_t list, l2;
1175   char *name;
1176   int algo;
1177   const char *algoname;
1178   const char *elems;
1179   int npkey, nskey;
1180   gcry_mpi_t array[10];
1181   char protect_iv[16];
1182   char salt[8];
1183   unsigned long s2k_count;
1184   int i, j;
1185
1186   (void)ctrl;
1187
1188   *r_transferkey = NULL;
1189
1190   for (i=0; i < DIM (array); i++)
1191     array[i] = NULL;
1192
1193   list = gcry_sexp_find_token (s_key, "private-key", 0);
1194   if (!list)
1195     return gpg_error (GPG_ERR_NO_OBJ); /* Does not contain a key object.  */
1196   l2 = gcry_sexp_cadr (list);
1197   gcry_sexp_release (list);
1198   list = l2;
1199   name = gcry_sexp_nth_string (list, 0);
1200   if (!name)
1201     {
1202       gcry_sexp_release (list);
1203       return gpg_error (GPG_ERR_INV_OBJ); /* Invalid structure of object. */
1204     }
1205
1206   algo = gcry_pk_map_name (name);
1207   xfree (name);
1208
1209   switch (algo)
1210     {
1211     case GCRY_PK_RSA:   algoname = "rsa";   npkey = 2; elems = "nedpqu";  break;
1212     case GCRY_PK_ELG:   algoname = "elg";   npkey = 3; elems = "pgyx";    break;
1213     case GCRY_PK_ELG_E: algoname = "elg";   npkey = 3; elems = "pgyx";    break;
1214     case GCRY_PK_DSA:   algoname = "dsa";   npkey = 4; elems = "pqgyx";   break;
1215     case GCRY_PK_ECDSA: algoname = "ecdsa"; npkey = 6; elems = "pabgnqd"; break;
1216     case GCRY_PK_ECDH:  algoname = "ecdh";  npkey = 6; elems = "pabgnqd"; break;
1217     default:            algoname = "";      npkey = 0; elems = NULL;      break;
1218     }
1219   assert (!elems || strlen (elems) < DIM (array) );
1220   nskey = elems? strlen (elems) : 0;
1221
1222   if (!elems)
1223     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1224   else
1225     err = key_from_sexp (list, elems, array);
1226   gcry_sexp_release (list);
1227   if (err)
1228     return err;
1229
1230   gcry_create_nonce (protect_iv, sizeof protect_iv);
1231   gcry_create_nonce (salt, sizeof salt);
1232   /* We need to use the encoded S2k count.  It is not possible to
1233      encode it after it has been used because the encoding procedure
1234      may round the value up.  */
1235   s2k_count = get_standard_s2k_count_rfc4880 ();
1236   err = apply_protection (array, npkey, nskey, passphrase,
1237                           GCRY_CIPHER_AES, protect_iv, sizeof protect_iv,
1238                           3, GCRY_MD_SHA1, salt, s2k_count);
1239   /* Turn it into the transfer key S-expression.  Note that we always
1240      return a protected key.  */
1241   if (!err)
1242     {
1243       char countbuf[35];
1244       membuf_t mbuf;
1245       void *format_args_buf_ptr[1];
1246       int   format_args_buf_int[1];
1247       void *format_args[10+2];
1248       unsigned int n;
1249       gcry_sexp_t tmpkey, tmpsexp = NULL;
1250
1251       snprintf (countbuf, sizeof countbuf, "%lu", s2k_count);
1252
1253       init_membuf (&mbuf, 50);
1254       put_membuf_str (&mbuf, "(skey");
1255       for (i=j=0; i < npkey; i++)
1256         {
1257           put_membuf_str (&mbuf, " _ %m");
1258           format_args[j++] = array + i;
1259         }
1260       put_membuf_str (&mbuf, " e %b");
1261       format_args_buf_ptr[0] = gcry_mpi_get_opaque (array[npkey], &n);
1262       format_args_buf_int[0] = (n+7)/8;
1263       format_args[j++] = format_args_buf_int;
1264       format_args[j++] = format_args_buf_ptr;
1265       put_membuf_str (&mbuf, ")\n");
1266       put_membuf (&mbuf, "", 1);
1267
1268       tmpkey = NULL;
1269       {
1270         char *format = get_membuf (&mbuf, NULL);
1271         if (!format)
1272           err = gpg_error_from_syserror ();
1273         else
1274           err = gcry_sexp_build_array (&tmpkey, NULL, format, format_args);
1275         xfree (format);
1276       }
1277       if (!err)
1278         err = gcry_sexp_build (&tmpsexp, NULL,
1279                                "(openpgp-private-key\n"
1280                                " (version 1:4)\n"
1281                                " (algo %s)\n"
1282                                " %S\n"
1283                                " (protection sha1 aes %b 1:3 sha1 %b %s))\n",
1284                                algoname,
1285                                tmpkey,
1286                                (int)sizeof protect_iv, protect_iv,
1287                                (int)sizeof salt, salt,
1288                                countbuf);
1289       gcry_sexp_release (tmpkey);
1290       if (!err)
1291         err = make_canon_sexp_pad (tmpsexp, 0, r_transferkey, r_transferkeylen);
1292       gcry_sexp_release (tmpsexp);
1293     }
1294
1295   for (i=0; i < DIM (array); i++)
1296     gcry_mpi_release (array[i]);
1297
1298   return err;
1299 }