gpg: Make export of ECC keys work again.
[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, 2014 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   const char *curve;
40   int  protect_algo;
41   char *iv;
42   int  ivlen;
43   int  s2k_mode;
44   int  s2k_algo;
45   byte *s2k_salt;
46   u32  s2k_count;
47   u16 desired_csum;
48   gcry_mpi_t *skey;
49   size_t skeysize;
50   int skeyidx;
51   gcry_sexp_t *r_key;
52 };
53
54
55
56 /* Compute the keygrip from the public key and store it at GRIP.  */
57 static gpg_error_t
58 get_keygrip (int pubkey_algo, const char *curve, gcry_mpi_t *pkey,
59              unsigned char *grip)
60 {
61   gpg_error_t err;
62   gcry_sexp_t s_pkey = NULL;
63
64   switch (pubkey_algo)
65     {
66     case GCRY_PK_DSA:
67       err = gcry_sexp_build (&s_pkey, NULL,
68                              "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
69                              pkey[0], pkey[1], pkey[2], pkey[3]);
70       break;
71
72     case GCRY_PK_ELG:
73       err = gcry_sexp_build (&s_pkey, NULL,
74                              "(public-key(elg(p%m)(g%m)(y%m)))",
75                              pkey[0], pkey[1], pkey[2]);
76       break;
77
78     case GCRY_PK_RSA:
79       err = gcry_sexp_build (&s_pkey, NULL,
80                              "(public-key(rsa(n%m)(e%m)))", pkey[0], pkey[1]);
81       break;
82
83     case GCRY_PK_ECC:
84       err = gcry_sexp_build (&s_pkey, NULL,
85                              "(public-key(ecc(curve %s)(q%m)))",
86                              curve, pkey[0]);
87       break;
88
89     default:
90       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
91       break;
92     }
93
94   if (!err && !gcry_pk_get_keygrip (s_pkey, grip))
95     err = gpg_error (GPG_ERR_INTERNAL);
96
97   gcry_sexp_release (s_pkey);
98   return err;
99 }
100
101
102 /* Convert a secret key given as algorithm id and an array of key
103    parameters into our s-expression based format.  Note that
104    PUBKEY_ALGO has an gcrypt algorithm number. */
105 static gpg_error_t
106 convert_secret_key (gcry_sexp_t *r_key, int pubkey_algo, gcry_mpi_t *skey,
107                     const char *curve)
108 {
109   gpg_error_t err;
110   gcry_sexp_t s_skey = NULL;
111
112   *r_key = NULL;
113
114   switch (pubkey_algo)
115     {
116     case GCRY_PK_DSA:
117       err = gcry_sexp_build (&s_skey, NULL,
118                              "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
119                              skey[0], skey[1], skey[2], skey[3], skey[4]);
120       break;
121
122     case GCRY_PK_ELG:
123     case GCRY_PK_ELG_E:
124       err = gcry_sexp_build (&s_skey, NULL,
125                              "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
126                              skey[0], skey[1], skey[2], skey[3]);
127       break;
128
129
130     case GCRY_PK_RSA:
131     case GCRY_PK_RSA_E:
132     case GCRY_PK_RSA_S:
133       err = gcry_sexp_build (&s_skey, NULL,
134                              "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
135                              skey[0], skey[1], skey[2], skey[3], skey[4],
136                              skey[5]);
137       break;
138
139     case GCRY_PK_ECC:
140       if (!curve)
141         err = gpg_error (GPG_ERR_BAD_SECKEY);
142       else
143         err = gcry_sexp_build (&s_skey, NULL,
144                                "(private-key(ecc(curve%s)(q%m)(d%m)))",
145                                curve, skey[0], skey[1]);
146       break;
147
148     default:
149       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
150       break;
151     }
152
153   if (!err)
154     *r_key = s_skey;
155   return err;
156 }
157
158
159 /* Convert a secret key given as algorithm id, an array of key
160    parameters, and an S-expression of the original OpenPGP transfer
161    key into our s-expression based format.  This is a variant of
162    convert_secret_key which is used for the openpgp-native protection
163    mode.  Note that PUBKEY_ALGO has an gcrypt algorithm number. */
164 static gpg_error_t
165 convert_transfer_key (gcry_sexp_t *r_key, int pubkey_algo, gcry_mpi_t *skey,
166                       const char *curve, gcry_sexp_t transfer_key)
167 {
168   gpg_error_t err;
169   gcry_sexp_t s_skey = NULL;
170
171   *r_key = NULL;
172
173   switch (pubkey_algo)
174     {
175     case GCRY_PK_DSA:
176       err = gcry_sexp_build
177         (&s_skey, NULL,
178          "(protected-private-key(dsa(p%m)(q%m)(g%m)(y%m)"
179          "(protected openpgp-native%S)))",
180          skey[0], skey[1], skey[2], skey[3], transfer_key);
181       break;
182
183     case GCRY_PK_ELG:
184       err = gcry_sexp_build
185         (&s_skey, NULL,
186          "(protected-private-key(elg(p%m)(g%m)(y%m)"
187          "(protected openpgp-native%S)))",
188          skey[0], skey[1], skey[2], transfer_key);
189       break;
190
191
192     case GCRY_PK_RSA:
193       err = gcry_sexp_build
194         (&s_skey, NULL,
195          "(protected-private-key(rsa(n%m)(e%m)",
196          "(protected openpgp-native%S)))",
197          skey[0], skey[1], transfer_key );
198       break;
199
200     case GCRY_PK_ECC:
201       err = gcry_sexp_build
202         (&s_skey, NULL,
203          "(protected-private-key(ecc(curve%s)(q%m)"
204          "(protected openpgp-native%S)))",
205          curve, skey[0], transfer_key);
206       break;
207
208     default:
209       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
210       break;
211     }
212
213   if (!err)
214     *r_key = s_skey;
215   return err;
216 }
217
218
219 /* Hash the passphrase and set the key. */
220 static gpg_error_t
221 hash_passphrase_and_set_key (const char *passphrase,
222                              gcry_cipher_hd_t hd, int protect_algo,
223                              int s2k_mode, int s2k_algo,
224                              byte *s2k_salt, u32 s2k_count)
225 {
226   gpg_error_t err;
227   unsigned char *key;
228   size_t keylen;
229
230   keylen = gcry_cipher_get_algo_keylen (protect_algo);
231   if (!keylen)
232     return gpg_error (GPG_ERR_INTERNAL);
233
234   key = xtrymalloc_secure (keylen);
235   if (!key)
236     return gpg_error_from_syserror ();
237
238   err = s2k_hash_passphrase (passphrase,
239                              s2k_algo, s2k_mode, s2k_salt, s2k_count,
240                              key, keylen);
241   if (!err)
242     err = gcry_cipher_setkey (hd, key, keylen);
243
244   xfree (key);
245   return err;
246 }
247
248
249 static u16
250 checksum (const unsigned char *p, unsigned int n)
251 {
252   u16 a;
253
254   for (a=0; n; n-- )
255     a += *p++;
256   return a;
257 }
258
259
260 /* Return the number of expected key parameters.  */
261 static void
262 get_npkey_nskey (int pubkey_algo, size_t *npkey, size_t *nskey)
263 {
264   switch (pubkey_algo)
265     {
266     case GCRY_PK_RSA:   *npkey = 2; *nskey = 6; break;
267     case GCRY_PK_ELG:   *npkey = 3; *nskey = 4; break;
268     case GCRY_PK_ELG_E: *npkey = 3; *nskey = 4; break;
269     case GCRY_PK_DSA:   *npkey = 4; *nskey = 5; break;
270     case GCRY_PK_ECC:   *npkey = 1; *nskey = 2; break;
271     default:            *npkey = 0; *nskey = 0; break;
272     }
273 }
274
275
276 /* Helper for do_unprotect.  PUBKEY_ALOGO is the gcrypt algo number.
277    On success R_NPKEY and R_NSKEY receive the number or parameters for
278    the algorithm PUBKEY_ALGO and R_SKEYLEN the used length of
279    SKEY.  */
280 static int
281 prepare_unprotect (int pubkey_algo, gcry_mpi_t *skey, size_t skeysize,
282                    int s2k_mode,
283                    unsigned int *r_npkey, unsigned int *r_nskey,
284                    unsigned int *r_skeylen)
285 {
286   size_t npkey, nskey, skeylen;
287   int i;
288
289   /* Count the actual number of MPIs is in the array and set the
290      remainder to NULL for easier processing later on.  */
291   for (skeylen = 0; skey[skeylen]; skeylen++)
292     ;
293   for (i=skeylen; i < skeysize; i++)
294     skey[i] = NULL;
295
296   /* Check some args.  */
297   if (s2k_mode == 1001)
298     {
299       /* Stub key.  */
300       log_info (_("secret key parts are not available\n"));
301       return gpg_error (GPG_ERR_UNUSABLE_SECKEY);
302     }
303
304   if (gcry_pk_test_algo (pubkey_algo))
305     {
306       log_info (_("public key algorithm %d (%s) is not supported\n"),
307                 pubkey_algo, gcry_pk_algo_name (pubkey_algo));
308       return gpg_error (GPG_ERR_PUBKEY_ALGO);
309     }
310
311   /* Get properties of the public key algorithm and do some
312      consistency checks.  Note that we need at least NPKEY+1 elements
313      in the SKEY array. */
314   get_npkey_nskey (pubkey_algo, &npkey, &nskey);
315   if (!npkey || !nskey || npkey >= nskey)
316     return gpg_error (GPG_ERR_INTERNAL);
317   if (skeylen <= npkey)
318     return gpg_error (GPG_ERR_MISSING_VALUE);
319   if (nskey+1 >= skeysize)
320     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
321
322   /* Check that the public key parameters are all available and not
323      encrypted.  */
324   for (i=0; i < npkey; i++)
325     {
326       if (!skey[i] || gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_USER1))
327         return gpg_error (GPG_ERR_BAD_SECKEY);
328     }
329
330   if (r_npkey)
331     *r_npkey = npkey;
332   if (r_nskey)
333     *r_nskey = nskey;
334   if (r_skeylen)
335     *r_skeylen = skeylen;
336   return 0;
337 }
338
339
340 /* Note that this function modifies SKEY.  SKEYSIZE is the allocated
341    size of the array including the NULL item; this is used for a
342    bounds check.  On success a converted key is stored at R_KEY.  */
343 static int
344 do_unprotect (const char *passphrase,
345               int pkt_version, int pubkey_algo, int is_protected,
346               const char *curve, gcry_mpi_t *skey, size_t skeysize,
347               int protect_algo, void *protect_iv, size_t protect_ivlen,
348               int s2k_mode, int s2k_algo, byte *s2k_salt, u32 s2k_count,
349               u16 desired_csum, gcry_sexp_t *r_key)
350 {
351   gpg_error_t err;
352   unsigned int npkey, nskey, skeylen;
353   gcry_cipher_hd_t cipher_hd = NULL;
354   u16 actual_csum;
355   size_t nbytes;
356   int i;
357   gcry_mpi_t tmpmpi;
358
359   *r_key = NULL;
360
361   err = prepare_unprotect (pubkey_algo, skey, skeysize, s2k_mode,
362                            &npkey, &nskey, &skeylen);
363   if (err)
364     return err;
365
366   /* Check whether SKEY is at all protected.  If it is not protected
367      merely verify the checksum.  */
368   if (!is_protected)
369     {
370       actual_csum = 0;
371       for (i=npkey; i < nskey; i++)
372         {
373           if (!skey[i] || gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_USER1))
374             return gpg_error (GPG_ERR_BAD_SECKEY);
375
376           if (gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_USER1))
377             {
378               unsigned int nbits;
379               const unsigned char *buffer;
380               buffer = gcry_mpi_get_opaque (skey[i], &nbits);
381               nbytes = (nbits+7)/8;
382               actual_csum += checksum (buffer, nbytes);
383             }
384           else
385             {
386               unsigned char *buffer;
387
388               err = gcry_mpi_aprint (GCRYMPI_FMT_PGP, &buffer, &nbytes,
389                                      skey[i]);
390               if (!err)
391                 actual_csum += checksum (buffer, nbytes);
392               xfree (buffer);
393             }
394           if (err)
395             return err;
396         }
397
398       if (actual_csum != desired_csum)
399         return gpg_error (GPG_ERR_CHECKSUM);
400
401       goto do_convert;
402     }
403
404
405   if (gcry_cipher_test_algo (protect_algo))
406     {
407       /* The algorithm numbers are Libgcrypt numbers but fortunately
408          the OpenPGP algorithm numbers map one-to-one to the Libgcrypt
409          numbers.  */
410       log_info (_("protection algorithm %d (%s) is not supported\n"),
411                 protect_algo, gnupg_cipher_algo_name (protect_algo));
412       return gpg_error (GPG_ERR_CIPHER_ALGO);
413     }
414
415   if (gcry_md_test_algo (s2k_algo))
416     {
417       log_info (_("protection hash algorithm %d (%s) is not supported\n"),
418                 s2k_algo, gcry_md_algo_name (s2k_algo));
419       return gpg_error (GPG_ERR_DIGEST_ALGO);
420     }
421
422   err = gcry_cipher_open (&cipher_hd, protect_algo,
423                           GCRY_CIPHER_MODE_CFB,
424                           (GCRY_CIPHER_SECURE
425                            | (protect_algo >= 100 ?
426                               0 : GCRY_CIPHER_ENABLE_SYNC)));
427   if (err)
428     {
429       log_error ("failed to open cipher_algo %d: %s\n",
430                  protect_algo, gpg_strerror (err));
431       return err;
432     }
433
434   err = hash_passphrase_and_set_key (passphrase, cipher_hd, protect_algo,
435                                      s2k_mode, s2k_algo, s2k_salt, s2k_count);
436   if (err)
437     {
438       gcry_cipher_close (cipher_hd);
439       return err;
440     }
441
442   gcry_cipher_setiv (cipher_hd, protect_iv, protect_ivlen);
443
444   actual_csum = 0;
445   if (pkt_version >= 4)
446     {
447       int ndata;
448       unsigned int ndatabits;
449       const unsigned char *p;
450       unsigned char *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           const 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  do_convert:
600   if (nskey != skeylen)
601     err = gpg_error (GPG_ERR_BAD_SECKEY);
602   else
603     err = convert_secret_key (r_key, pubkey_algo, skey, curve);
604   if (err)
605     return err;
606
607   /* The checksum may fail, thus we also check the key itself.  */
608   err = gcry_pk_testkey (*r_key);
609   if (err)
610     {
611       gcry_sexp_release (*r_key);
612       *r_key = NULL;
613       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
614     }
615
616   return 0;
617 }
618
619
620 /* Callback function to try the unprotection from the passphrase query
621    code.  */
622 static int
623 try_do_unprotect_cb (struct pin_entry_info_s *pi)
624 {
625   gpg_error_t err;
626   struct try_do_unprotect_arg_s *arg = pi->check_cb_arg;
627
628   err = do_unprotect (pi->pin,
629                       arg->is_v4? 4:3,
630                       arg->pubkey_algo, arg->is_protected,
631                       arg->curve,
632                       arg->skey, arg->skeysize,
633                       arg->protect_algo, arg->iv, arg->ivlen,
634                       arg->s2k_mode, arg->s2k_algo,
635                       arg->s2k_salt, arg->s2k_count,
636                       arg->desired_csum, arg->r_key);
637   /* SKEY may be modified now, thus we need to re-compute SKEYIDX.  */
638   for (arg->skeyidx = 0; (arg->skeyidx < arg->skeysize
639                           && arg->skey[arg->skeyidx]); arg->skeyidx++)
640     ;
641   return err;
642 }
643
644
645 /* See convert_from_openpgp for the core of the description.  This
646    function adds an optional PASSPHRASE argument and uses this to
647    silently decrypt the key; CACHE_NONCE and R_PASSPHRASE must both be
648    NULL in this mode.  */
649 static gpg_error_t
650 convert_from_openpgp_main (ctrl_t ctrl, gcry_sexp_t s_pgp,
651                            unsigned char *grip, const char *prompt,
652                            const char *cache_nonce, const char *passphrase,
653                            unsigned char **r_key, char **r_passphrase)
654 {
655   gpg_error_t err;
656   int unattended;
657   int from_native;
658   gcry_sexp_t top_list;
659   gcry_sexp_t list = NULL;
660   const char *value;
661   size_t valuelen;
662   char *string;
663   int  idx;
664   int  is_v4, is_protected;
665   int  pubkey_algo;
666   int  protect_algo = 0;
667   char iv[16];
668   int  ivlen = 0;
669   int  s2k_mode = 0;
670   int  s2k_algo = 0;
671   byte s2k_salt[8];
672   u32  s2k_count = 0;
673   size_t npkey, nskey;
674   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
675   char *curve = NULL;
676   u16 desired_csum;
677   int skeyidx = 0;
678   gcry_sexp_t s_skey = NULL;
679
680   *r_key = NULL;
681   if (r_passphrase)
682     *r_passphrase = NULL;
683   unattended = !r_passphrase;
684   from_native = (!cache_nonce && passphrase && !r_passphrase);
685
686   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
687   if (!top_list)
688     goto bad_seckey;
689
690   list = gcry_sexp_find_token (top_list, "version", 0);
691   if (!list)
692     goto bad_seckey;
693   value = gcry_sexp_nth_data (list, 1, &valuelen);
694   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
695     goto bad_seckey;
696   is_v4 = (value[0] == '4');
697
698   gcry_sexp_release (list);
699   list = gcry_sexp_find_token (top_list, "protection", 0);
700   if (!list)
701     goto bad_seckey;
702   value = gcry_sexp_nth_data (list, 1, &valuelen);
703   if (!value)
704     goto bad_seckey;
705   if (valuelen == 4 && !memcmp (value, "sha1", 4))
706     is_protected = 2;
707   else if (valuelen == 3 && !memcmp (value, "sum", 3))
708     is_protected = 1;
709   else if (valuelen == 4 && !memcmp (value, "none", 4))
710     is_protected = 0;
711   else
712     goto bad_seckey;
713
714   if (is_protected)
715     {
716       string = gcry_sexp_nth_string (list, 2);
717       if (!string)
718         goto bad_seckey;
719       protect_algo = gcry_cipher_map_name (string);
720       xfree (string);
721
722       value = gcry_sexp_nth_data (list, 3, &valuelen);
723       if (!value || !valuelen || valuelen > sizeof iv)
724         goto bad_seckey;
725       memcpy (iv, value, valuelen);
726       ivlen = valuelen;
727
728       string = gcry_sexp_nth_string (list, 4);
729       if (!string)
730         goto bad_seckey;
731       s2k_mode = strtol (string, NULL, 10);
732       xfree (string);
733
734       string = gcry_sexp_nth_string (list, 5);
735       if (!string)
736         goto bad_seckey;
737       s2k_algo = gcry_md_map_name (string);
738       xfree (string);
739
740       value = gcry_sexp_nth_data (list, 6, &valuelen);
741       if (!value || !valuelen || valuelen > sizeof s2k_salt)
742         goto bad_seckey;
743       memcpy (s2k_salt, value, valuelen);
744
745       string = gcry_sexp_nth_string (list, 7);
746       if (!string)
747         goto bad_seckey;
748       s2k_count = strtoul (string, NULL, 10);
749       xfree (string);
750     }
751
752   gcry_sexp_release (list);
753   list = gcry_sexp_find_token (top_list, "algo", 0);
754   if (!list)
755     goto bad_seckey;
756   string = gcry_sexp_nth_string (list, 1);
757   if (!string)
758     goto bad_seckey;
759   pubkey_algo = gcry_pk_map_name (string);
760   xfree (string);
761
762   get_npkey_nskey (pubkey_algo, &npkey, &nskey);
763   if (!npkey || !nskey || npkey >= nskey)
764     goto bad_seckey;
765
766   if (npkey == 1) /* This is ECC */
767     {
768       gcry_sexp_release (list);
769       list = gcry_sexp_find_token (top_list, "curve", 0);
770       if (!list)
771         goto bad_seckey;
772       curve = gcry_sexp_nth_string (list, 1);
773       if (!curve)
774         goto bad_seckey;
775     }
776
777   gcry_sexp_release (list);
778   list = gcry_sexp_find_token (top_list, "skey", 0);
779   if (!list)
780     goto bad_seckey;
781   for (idx=0;;)
782     {
783       int is_enc;
784
785       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
786       if (!value && skeyidx >= npkey)
787         break;  /* Ready.  */
788
789       /* Check for too many parameters.  Note that depending on the
790          protection mode and version number we may see less than NSKEY
791          (but at least NPKEY+1) parameters.  */
792       if (idx >= 2*nskey)
793         goto bad_seckey;
794       if (skeyidx >= DIM (skey)-1)
795         goto bad_seckey;
796
797       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
798         goto bad_seckey;
799       is_enc = (value[0] == 'e');
800       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
801       if (!value || !valuelen)
802         goto bad_seckey;
803       if (is_enc || curve)
804         {
805           /* Encrypted parameters and ECC parameters need or can be
806              stored as opaque.  */
807           skey[skeyidx] = gcry_mpi_set_opaque_copy (NULL, value, valuelen*8);
808           if (!skey[skeyidx])
809             goto outofmem;
810           if (is_enc)
811             gcry_mpi_set_flag (skey[skeyidx], GCRYMPI_FLAG_USER1);
812         }
813       else
814         {
815           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
816                              value, valuelen, NULL))
817             goto bad_seckey;
818         }
819       skeyidx++;
820     }
821   skey[skeyidx++] = NULL;
822
823   gcry_sexp_release (list);
824   list = gcry_sexp_find_token (top_list, "csum", 0);
825   if (list)
826     {
827       string = gcry_sexp_nth_string (list, 1);
828       if (!string)
829         goto bad_seckey;
830       desired_csum = strtoul (string, NULL, 10);
831       xfree (string);
832     }
833   else
834     desired_csum = 0;
835
836
837   gcry_sexp_release (list); list = NULL;
838   gcry_sexp_release (top_list); top_list = NULL;
839
840 #if 0
841   log_debug ("XXX is_v4=%d\n", is_v4);
842   log_debug ("XXX pubkey_algo=%d\n", pubkey_algo);
843   log_debug ("XXX is_protected=%d\n", is_protected);
844   log_debug ("XXX protect_algo=%d\n", protect_algo);
845   log_printhex ("XXX iv", iv, ivlen);
846   log_debug ("XXX ivlen=%d\n", ivlen);
847   log_debug ("XXX s2k_mode=%d\n", s2k_mode);
848   log_debug ("XXX s2k_algo=%d\n", s2k_algo);
849   log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt);
850   log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count);
851   log_debug ("XXX curve='%s'\n", curve);
852   for (idx=0; skey[idx]; idx++)
853     gcry_log_debugmpi (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_USER1)
854                        ? "skey(e)" : "skey(_)", skey[idx]);
855 #endif /*0*/
856
857   err = get_keygrip (pubkey_algo, curve, skey, grip);
858   if (err)
859     goto leave;
860
861   if (!from_native && !agent_key_available (grip))
862     {
863       err = gpg_error (GPG_ERR_EEXIST);
864       goto leave;
865     }
866
867   if (unattended && !from_native)
868     {
869       err = prepare_unprotect (pubkey_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_algo, skey, curve, 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.curve = curve;
896       pi_arg.protect_algo = protect_algo;
897       pi_arg.iv = iv;
898       pi_arg.ivlen = ivlen;
899       pi_arg.s2k_mode = s2k_mode;
900       pi_arg.s2k_algo = s2k_algo;
901       pi_arg.s2k_salt = s2k_salt;
902       pi_arg.s2k_count = s2k_count;
903       pi_arg.desired_csum = desired_csum;
904       pi_arg.skey = skey;
905       pi_arg.skeysize = DIM (skey);
906       pi_arg.skeyidx = skeyidx;
907       pi_arg.r_key = &s_skey;
908
909       err = gpg_error (GPG_ERR_BAD_PASSPHRASE);
910       if (!is_protected)
911         {
912           err = try_do_unprotect_cb (pi);
913         }
914       else if (cache_nonce)
915         {
916           char *cache_value;
917
918           cache_value = agent_get_cache (cache_nonce, CACHE_MODE_NONCE);
919           if (cache_value)
920             {
921               if (strlen (cache_value) < pi->max_length)
922                 strcpy (pi->pin, cache_value);
923               xfree (cache_value);
924             }
925           if (*pi->pin)
926             err = try_do_unprotect_cb (pi);
927         }
928       else if (from_native)
929         {
930           if (strlen (passphrase) < pi->max_length)
931             strcpy (pi->pin, passphrase);
932           err = try_do_unprotect_cb (pi);
933         }
934       if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE && !from_native)
935         err = agent_askpin (ctrl, prompt, NULL, NULL, pi);
936       skeyidx = pi_arg.skeyidx;
937       if (!err && r_passphrase && is_protected)
938         {
939           *r_passphrase = xtrystrdup (pi->pin);
940           if (!*r_passphrase)
941             err = gpg_error_from_syserror ();
942         }
943       xfree (pi);
944       if (err)
945         goto leave;
946     }
947
948   /* Save some memory and get rid of the SKEY array now.  */
949   for (idx=0; idx < skeyidx; idx++)
950     gcry_mpi_release (skey[idx]);
951   skeyidx = 0;
952
953   /* Note that the padding is not required - we use it only because
954      that function allows us to create the result in secure memory.  */
955   err = make_canon_sexp_pad (s_skey, 1, r_key, NULL);
956
957  leave:
958   xfree (curve);
959   gcry_sexp_release (s_skey);
960   gcry_sexp_release (list);
961   gcry_sexp_release (top_list);
962   for (idx=0; idx < skeyidx; idx++)
963     gcry_mpi_release (skey[idx]);
964   if (err && r_passphrase)
965     {
966       xfree (*r_passphrase);
967       *r_passphrase = NULL;
968     }
969   return err;
970
971  bad_seckey:
972   err = gpg_error (GPG_ERR_BAD_SECKEY);
973   goto leave;
974
975  outofmem:
976   err = gpg_error (GPG_ERR_ENOMEM);
977   goto leave;
978
979 }
980
981
982 /* Convert an OpenPGP transfer key into our internal format.  Before
983    asking for a passphrase we check whether the key already exists in
984    our key storage.  S_PGP is the OpenPGP key in transfer format.  If
985    CACHE_NONCE is given the passphrase will be looked up in the cache.
986    On success R_KEY will receive a canonical encoded S-expression with
987    the unprotected key in our internal format; the caller needs to
988    release that memory.  The passphrase used to decrypt the OpenPGP
989    key will be returned at R_PASSPHRASE; the caller must release this
990    passphrase.  If R_PASSPHRASE is NULL the unattended conversion mode
991    will be used which uses the openpgp-native protection format for
992    the key.  The keygrip will be stored at the 20 byte buffer pointed
993    to by GRIP.  On error NULL is stored at all return arguments.  */
994 gpg_error_t
995 convert_from_openpgp (ctrl_t ctrl, gcry_sexp_t s_pgp,
996                       unsigned char *grip, const char *prompt,
997                       const char *cache_nonce,
998                       unsigned char **r_key, char **r_passphrase)
999 {
1000   return convert_from_openpgp_main (ctrl, s_pgp, grip, prompt,
1001                                     cache_nonce, NULL,
1002                                     r_key, r_passphrase);
1003 }
1004
1005 /* This function is called by agent_unprotect to re-protect an
1006    openpgp-native protected private-key into the standard private-key
1007    protection format.  */
1008 gpg_error_t
1009 convert_from_openpgp_native (ctrl_t ctrl,
1010                              gcry_sexp_t s_pgp, const char *passphrase,
1011                              unsigned char **r_key)
1012 {
1013   gpg_error_t err;
1014   unsigned char grip[20];
1015
1016   if (!passphrase)
1017     return gpg_error (GPG_ERR_INTERNAL);
1018
1019   err = convert_from_openpgp_main (ctrl, s_pgp, grip, NULL,
1020                                    NULL, passphrase,
1021                                    r_key, NULL);
1022
1023   /* On success try to re-write the key.  */
1024   if (!err)
1025     {
1026       unsigned char *protectedkey = NULL;
1027       size_t protectedkeylen;
1028
1029       if (!agent_protect (*r_key, passphrase, &protectedkey, &protectedkeylen,
1030                           ctrl->s2k_count))
1031         agent_write_private_key (grip, protectedkey, protectedkeylen, 1);
1032       xfree (protectedkey);
1033     }
1034
1035   return err;
1036 }
1037
1038
1039 /* Given an ARRAY of mpis with the key parameters, protect the secret
1040    parameters in that array and replace them by one opaque encoded
1041    mpi.  NPKEY is the number of public key parameters and NSKEY is
1042    the number of secret key parameters (including the public ones).
1043    On success the array will have NPKEY+1 elements.  */
1044 static gpg_error_t
1045 apply_protection (gcry_mpi_t *array, int npkey, int nskey,
1046                   const char *passphrase,
1047                   int protect_algo, void *protect_iv, size_t protect_ivlen,
1048                   int s2k_mode, int s2k_algo, byte *s2k_salt, u32 s2k_count)
1049 {
1050   gpg_error_t err;
1051   int i, j;
1052   gcry_cipher_hd_t cipherhd;
1053   unsigned char *bufarr[10];
1054   size_t narr[10];
1055   unsigned int nbits[10];
1056   int ndata;
1057   unsigned char *p, *data;
1058
1059   assert (npkey < nskey);
1060   assert (nskey < DIM (bufarr));
1061
1062   /* Collect only the secret key parameters into BUFARR et al and
1063      compute the required size of the data buffer.  */
1064   ndata = 20; /* Space for the SHA-1 checksum.  */
1065   for (i = npkey, j = 0; i < nskey; i++, j++ )
1066     {
1067       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, bufarr+j, narr+j, array[i]);
1068       if (err)
1069         {
1070           err = gpg_error_from_syserror ();
1071           for (i = 0; i < j; i++)
1072             xfree (bufarr[i]);
1073           return err;
1074         }
1075       nbits[j] = gcry_mpi_get_nbits (array[i]);
1076       ndata += 2 + narr[j];
1077     }
1078
1079   /* Allocate data buffer and stuff it with the secret key parameters.  */
1080   data = xtrymalloc_secure (ndata);
1081   if (!data)
1082     {
1083       err = gpg_error_from_syserror ();
1084       for (i = 0; i < (nskey-npkey); i++ )
1085         xfree (bufarr[i]);
1086       return err;
1087     }
1088   p = data;
1089   for (i = 0; i < (nskey-npkey); i++ )
1090     {
1091       *p++ = nbits[i] >> 8 ;
1092       *p++ = nbits[i];
1093       memcpy (p, bufarr[i], narr[i]);
1094       p += narr[i];
1095       xfree (bufarr[i]);
1096       bufarr[i] = NULL;
1097     }
1098   assert (p == data + ndata - 20);
1099
1100   /* Append a hash of the secret key parameters.  */
1101   gcry_md_hash_buffer (GCRY_MD_SHA1, p, data, ndata - 20);
1102
1103   /* Encrypt it.  */
1104   err = gcry_cipher_open (&cipherhd, protect_algo,
1105                           GCRY_CIPHER_MODE_CFB, GCRY_CIPHER_SECURE);
1106   if (!err)
1107     err = hash_passphrase_and_set_key (passphrase, cipherhd, protect_algo,
1108                                        s2k_mode, s2k_algo, s2k_salt, s2k_count);
1109   if (!err)
1110     err = gcry_cipher_setiv (cipherhd, protect_iv, protect_ivlen);
1111   if (!err)
1112     err = gcry_cipher_encrypt (cipherhd, data, ndata, NULL, 0);
1113   gcry_cipher_close (cipherhd);
1114   if (err)
1115     {
1116       xfree (data);
1117       return err;
1118     }
1119
1120   /* Replace the secret key parameters in the array by one opaque value.  */
1121   for (i = npkey; i < nskey; i++ )
1122     {
1123       gcry_mpi_release (array[i]);
1124       array[i] = NULL;
1125     }
1126   array[npkey] = gcry_mpi_set_opaque (NULL, data, ndata*8);
1127   return 0;
1128 }
1129
1130
1131 /* Convert our key S_KEY into an OpenPGP key transfer format.  On
1132    success a canonical encoded S-expression is stored at R_TRANSFERKEY
1133    and its length at R_TRANSFERKEYLEN; this S-expression is also
1134    padded to a multiple of 64 bits.  */
1135 gpg_error_t
1136 convert_to_openpgp (ctrl_t ctrl, gcry_sexp_t s_key, const char *passphrase,
1137                     unsigned char **r_transferkey, size_t *r_transferkeylen)
1138 {
1139   gpg_error_t err;
1140   gcry_sexp_t list, l2;
1141   char *name;
1142   const char *algoname;
1143   int npkey, nskey;
1144   gcry_mpi_t array[10];
1145   gcry_sexp_t curve = NULL;
1146   char protect_iv[16];
1147   char salt[8];
1148   unsigned long s2k_count;
1149   int i, j;
1150
1151   (void)ctrl;
1152
1153   *r_transferkey = NULL;
1154
1155   for (i=0; i < DIM (array); i++)
1156     array[i] = NULL;
1157
1158   list = gcry_sexp_find_token (s_key, "private-key", 0);
1159   if (!list)
1160     return gpg_error (GPG_ERR_NO_OBJ); /* Does not contain a key object.  */
1161   l2 = gcry_sexp_cadr (list);
1162   gcry_sexp_release (list);
1163   list = l2;
1164   name = gcry_sexp_nth_string (list, 0);
1165   if (!name)
1166     {
1167       gcry_sexp_release (list);
1168       return gpg_error (GPG_ERR_INV_OBJ); /* Invalid structure of object. */
1169     }
1170
1171   /* Map NAME to a name as used by Libgcrypt.  We do not use the
1172      Libgcrypt function here because we need a lowercase name and
1173      require special treatment for some algorithms.  */
1174   strlwr (name);
1175   if (!strcmp (name, "rsa"))
1176     {
1177       algoname = "rsa";
1178       npkey = 2;
1179       nskey = 6;
1180       err = gcry_sexp_extract_param (list, NULL, "nedpqu",
1181                                      array+0, array+1, array+2, array+3,
1182                                      array+4, array+5, NULL);
1183     }
1184   else if (!strcmp (name, "elg"))
1185     {
1186       algoname = "elg";
1187       npkey = 3;
1188       nskey = 4;
1189       err = gcry_sexp_extract_param (list, NULL, "pgyx",
1190                                      array+0, array+1, array+2, array+3,
1191                                      NULL);
1192     }
1193   else if (!strcmp (name, "dsa"))
1194     {
1195       algoname = "dsa";
1196       npkey = 4;
1197       nskey = 5;
1198       err = gcry_sexp_extract_param (list, NULL, "pqgyx",
1199                                      array+0, array+1, array+2, array+3,
1200                                      array+4, NULL);
1201     }
1202   else if (!strcmp (name, "ecc"))
1203     {
1204       gcry_buffer_t iob;
1205       char iobbuf[32];
1206
1207       algoname = "ecc"; /* Decide later by checking the usage.  */
1208       npkey = 1;
1209       nskey = 2;
1210       iob.data = iobbuf;
1211       iob.size = sizeof iobbuf - 1;
1212       iob.off = 0;
1213       iob.len = 0;
1214       err = gcry_sexp_extract_param (list, NULL, "&'curve'/qd",
1215                                      &iob, array+0, array+1, NULL);
1216       if (!err)
1217         {
1218           assert (iob.len < sizeof iobbuf -1);
1219           iobbuf[iob.len] = 0;
1220           err = gcry_sexp_build (&curve, NULL, "(curve %s)", iobbuf);
1221
1222           gcry_log_debugsxp ("at 1", curve);
1223         }
1224     }
1225   else if (!strcmp (name, "ecdsa"))
1226     {
1227       algoname = "ecdsa";
1228       npkey = 6;
1229       nskey = 7;
1230       err = gcry_sexp_extract_param (list, NULL, "pabgnqd",
1231                                      array+0, array+1, array+2, array+3,
1232                                      array+4, array+5, array+6, NULL);
1233     }
1234   else if (!strcmp (name, "ecdh"))
1235     {
1236       algoname = "ecdh";
1237       npkey = 6;
1238       nskey= 7;
1239       err = gcry_sexp_extract_param (list, NULL, "pabgnqd",
1240                                      array+0, array+1, array+2, array+3,
1241                                      array+4, array+5, array+6, NULL);
1242     }
1243   else
1244     {
1245       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1246     }
1247   xfree (name);
1248   gcry_sexp_release (list); list = NULL;
1249   if (err)
1250     {
1251       gcry_sexp_release (curve);
1252       return err;
1253     }
1254
1255   gcry_create_nonce (protect_iv, sizeof protect_iv);
1256   gcry_create_nonce (salt, sizeof salt);
1257   /* We need to use the encoded S2k count.  It is not possible to
1258      encode it after it has been used because the encoding procedure
1259      may round the value up.  */
1260   s2k_count = get_standard_s2k_count_rfc4880 ();
1261   err = apply_protection (array, npkey, nskey, passphrase,
1262                           GCRY_CIPHER_AES, protect_iv, sizeof protect_iv,
1263                           3, GCRY_MD_SHA1, salt, s2k_count);
1264   /* Turn it into the transfer key S-expression.  Note that we always
1265      return a protected key.  */
1266   if (!err)
1267     {
1268       char countbuf[35];
1269       membuf_t mbuf;
1270       void *format_args[10+2];
1271       gcry_sexp_t tmpkey;
1272       gcry_sexp_t tmpsexp = NULL;
1273
1274       snprintf (countbuf, sizeof countbuf, "%lu", s2k_count);
1275
1276       init_membuf (&mbuf, 50);
1277       put_membuf_str (&mbuf, "(skey");
1278       for (i=j=0; i < npkey; i++)
1279         {
1280           put_membuf_str (&mbuf, " _ %m");
1281           format_args[j++] = array + i;
1282         }
1283       put_membuf_str (&mbuf, " e %m");
1284       format_args[j++] = array + npkey;
1285       put_membuf_str (&mbuf, ")\n");
1286       put_membuf (&mbuf, "", 1);
1287
1288       tmpkey = NULL;
1289       {
1290         char *format = get_membuf (&mbuf, NULL);
1291         if (!format)
1292           err = gpg_error_from_syserror ();
1293         else
1294           err = gcry_sexp_build_array (&tmpkey, NULL, format, format_args);
1295         xfree (format);
1296       }
1297       if (!err)
1298         err = gcry_sexp_build (&tmpsexp, NULL,
1299                                "(openpgp-private-key\n"
1300                                " (version 1:4)\n"
1301                                " (algo %s)\n"
1302                                " %S%S\n"
1303                                " (protection sha1 aes %b 1:3 sha1 %b %s))\n",
1304                                algoname,
1305                                curve,
1306                                tmpkey,
1307                                (int)sizeof protect_iv, protect_iv,
1308                                (int)sizeof salt, salt,
1309                                countbuf);
1310       gcry_sexp_release (tmpkey);
1311       if (!err)
1312         err = make_canon_sexp_pad (tmpsexp, 0, r_transferkey, r_transferkeylen);
1313       gcry_sexp_release (tmpsexp);
1314     }
1315
1316   for (i=0; i < DIM (array); i++)
1317     gcry_mpi_release (array[i]);
1318   gcry_sexp_release (curve);
1319
1320   return err;
1321 }