Curve25519 support.
[gnupg.git] / agent / cvt-openpgp.c
1 /* cvt-openpgp.c - Convert an OpenPGP key to our internal format.
2  * Copyright (C) 1998-2002, 2006, 2009, 2010 Free Software Foundation, Inc.
3  * Copyright (C) 2013, 2014 Werner Koch
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 "agent.h"
28 #include "i18n.h"
29 #include "cvt-openpgp.h"
30 #include "host2net.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       if (!curve)
85         err = gpg_error (GPG_ERR_BAD_SECKEY);
86       else
87         {
88           const char *format;
89
90           if (!strcmp (curve, openpgp_curve_to_oid ("Ed25519", NULL)))
91             {
92               format = "(public-key(ecc(curve %s)(flags eddsa)(q%m)))";
93               curve = "Ed25519";
94             }
95           else if (!strcmp (curve, openpgp_curve_to_oid ("Curve25519", NULL)))
96             {
97               format = "(public-key(ecc(curve %s)(flags djb-tweak)(q%m)))";
98               curve = "Curve25519";
99             }
100           else
101             format = "(public-key(ecc(curve %s)(q%m)))";
102
103           err = gcry_sexp_build (&s_pkey, NULL, format, curve, pkey[0]);
104         }
105       break;
106
107     default:
108       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
109       break;
110     }
111
112   if (!err && !gcry_pk_get_keygrip (s_pkey, grip))
113     err = gpg_error (GPG_ERR_INTERNAL);
114
115   gcry_sexp_release (s_pkey);
116   return err;
117 }
118
119
120 /* Convert a secret key given as algorithm id and an array of key
121    parameters into our s-expression based format.  Note that
122    PUBKEY_ALGO has an gcrypt algorithm number. */
123 static gpg_error_t
124 convert_secret_key (gcry_sexp_t *r_key, int pubkey_algo, gcry_mpi_t *skey,
125                     const char *curve)
126 {
127   gpg_error_t err;
128   gcry_sexp_t s_skey = NULL;
129
130   *r_key = NULL;
131
132   switch (pubkey_algo)
133     {
134     case GCRY_PK_DSA:
135       err = gcry_sexp_build (&s_skey, NULL,
136                              "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
137                              skey[0], skey[1], skey[2], skey[3], skey[4]);
138       break;
139
140     case GCRY_PK_ELG:
141     case GCRY_PK_ELG_E:
142       err = gcry_sexp_build (&s_skey, NULL,
143                              "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
144                              skey[0], skey[1], skey[2], skey[3]);
145       break;
146
147
148     case GCRY_PK_RSA:
149     case GCRY_PK_RSA_E:
150     case GCRY_PK_RSA_S:
151       err = gcry_sexp_build (&s_skey, NULL,
152                              "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
153                              skey[0], skey[1], skey[2], skey[3], skey[4],
154                              skey[5]);
155       break;
156
157     case GCRY_PK_ECC:
158       if (!curve)
159         err = gpg_error (GPG_ERR_BAD_SECKEY);
160       else
161         {
162           const char *format;
163
164           if (!strcmp (curve, openpgp_curve_to_oid ("Ed25519", NULL)))
165             {
166               /* Do not store the OID as name but the real name and the
167                  EdDSA flag.  */
168               format = "(private-key(ecc(curve %s)(flags eddsa)(q%m)(d%m)))";
169               curve = "Ed25519";
170             }
171           else if (!strcmp (curve, openpgp_curve_to_oid ("Curve25519", NULL)))
172             {
173               format = "(private-key(ecc(curve %s)(flags djb-tweak)(q%m)(d%m)))";
174               curve = "Curve25519";
175             }
176           else
177             format = "(private-key(ecc(curve %s)(q%m)(d%m)))";
178
179           err = gcry_sexp_build (&s_skey, NULL, format, curve, skey[0], skey[1]);
180         }
181       break;
182
183     default:
184       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
185       break;
186     }
187
188   if (!err)
189     *r_key = s_skey;
190   return err;
191 }
192
193
194 /* Convert a secret key given as algorithm id, an array of key
195    parameters, and an S-expression of the original OpenPGP transfer
196    key into our s-expression based format.  This is a variant of
197    convert_secret_key which is used for the openpgp-native protection
198    mode.  Note that PUBKEY_ALGO has an gcrypt algorithm number. */
199 static gpg_error_t
200 convert_transfer_key (gcry_sexp_t *r_key, int pubkey_algo, gcry_mpi_t *skey,
201                       const char *curve, gcry_sexp_t transfer_key)
202 {
203   gpg_error_t err;
204   gcry_sexp_t s_skey = NULL;
205
206   *r_key = NULL;
207
208   switch (pubkey_algo)
209     {
210     case GCRY_PK_DSA:
211       err = gcry_sexp_build
212         (&s_skey, NULL,
213          "(protected-private-key(dsa(p%m)(q%m)(g%m)(y%m)"
214          "(protected openpgp-native%S)))",
215          skey[0], skey[1], skey[2], skey[3], transfer_key);
216       break;
217
218     case GCRY_PK_ELG:
219       err = gcry_sexp_build
220         (&s_skey, NULL,
221          "(protected-private-key(elg(p%m)(g%m)(y%m)"
222          "(protected openpgp-native%S)))",
223          skey[0], skey[1], skey[2], transfer_key);
224       break;
225
226
227     case GCRY_PK_RSA:
228       err = gcry_sexp_build
229         (&s_skey, NULL,
230          "(protected-private-key(rsa(n%m)(e%m)"
231          "(protected openpgp-native%S)))",
232          skey[0], skey[1], transfer_key );
233       break;
234
235     case GCRY_PK_ECC:
236       if (!curve)
237         err = gpg_error (GPG_ERR_BAD_SECKEY);
238       else
239         {
240           const char *format;
241
242           if (!strcmp (curve, openpgp_curve_to_oid ("Ed25519", NULL)))
243             {
244               /* Do not store the OID as name but the real name and the
245                  EdDSA flag.  */
246               format = "(protected-private-key(ecc(curve %s)(flags eddsa)(q%m)"
247                 "(protected openpgp-native%S)))";
248               curve = "Ed25519";
249             }
250           else if (!strcmp (curve, openpgp_curve_to_oid ("Curve25519", NULL)))
251             {
252               format = "(protected-private-key(ecc(curve %s)(flags djb-tweak)(q%m)"
253                 "(protected openpgp-native%S)))";
254               curve = "Curve25519";
255             }
256           else
257               format = "(protected-private-key(ecc(curve %s)(q%m)"
258                 "(protected openpgp-native%S)))";
259
260           err = gcry_sexp_build (&s_skey, NULL, format, curve, skey[0], transfer_key);
261         }
262       break;
263
264     default:
265       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
266       break;
267     }
268
269   if (!err)
270     *r_key = s_skey;
271   return err;
272 }
273
274
275 /* Hash the passphrase and set the key. */
276 static gpg_error_t
277 hash_passphrase_and_set_key (const char *passphrase,
278                              gcry_cipher_hd_t hd, int protect_algo,
279                              int s2k_mode, int s2k_algo,
280                              byte *s2k_salt, u32 s2k_count)
281 {
282   gpg_error_t err;
283   unsigned char *key;
284   size_t keylen;
285
286   keylen = gcry_cipher_get_algo_keylen (protect_algo);
287   if (!keylen)
288     return gpg_error (GPG_ERR_INTERNAL);
289
290   key = xtrymalloc_secure (keylen);
291   if (!key)
292     return gpg_error_from_syserror ();
293
294   err = s2k_hash_passphrase (passphrase,
295                              s2k_algo, s2k_mode, s2k_salt, s2k_count,
296                              key, keylen);
297   if (!err)
298     err = gcry_cipher_setkey (hd, key, keylen);
299
300   xfree (key);
301   return err;
302 }
303
304
305 static u16
306 checksum (const unsigned char *p, unsigned int n)
307 {
308   u16 a;
309
310   for (a=0; n; n-- )
311     a += *p++;
312   return a;
313 }
314
315
316 /* Return the number of expected key parameters.  */
317 static void
318 get_npkey_nskey (int pubkey_algo, size_t *npkey, size_t *nskey)
319 {
320   switch (pubkey_algo)
321     {
322     case GCRY_PK_RSA:   *npkey = 2; *nskey = 6; break;
323     case GCRY_PK_ELG:   *npkey = 3; *nskey = 4; break;
324     case GCRY_PK_ELG_E: *npkey = 3; *nskey = 4; break;
325     case GCRY_PK_DSA:   *npkey = 4; *nskey = 5; break;
326     case GCRY_PK_ECC:   *npkey = 1; *nskey = 2; break;
327     default:            *npkey = 0; *nskey = 0; break;
328     }
329 }
330
331
332 /* Helper for do_unprotect.  PUBKEY_ALOGO is the gcrypt algo number.
333    On success R_NPKEY and R_NSKEY receive the number or parameters for
334    the algorithm PUBKEY_ALGO and R_SKEYLEN the used length of
335    SKEY.  */
336 static int
337 prepare_unprotect (int pubkey_algo, gcry_mpi_t *skey, size_t skeysize,
338                    int s2k_mode,
339                    unsigned int *r_npkey, unsigned int *r_nskey,
340                    unsigned int *r_skeylen)
341 {
342   size_t npkey, nskey, skeylen;
343   int i;
344
345   /* Count the actual number of MPIs is in the array and set the
346      remainder to NULL for easier processing later on.  */
347   for (skeylen = 0; skey[skeylen]; skeylen++)
348     ;
349   for (i=skeylen; i < skeysize; i++)
350     skey[i] = NULL;
351
352   /* Check some args.  */
353   if (s2k_mode == 1001)
354     {
355       /* Stub key.  */
356       log_info (_("secret key parts are not available\n"));
357       return gpg_error (GPG_ERR_UNUSABLE_SECKEY);
358     }
359
360   if (gcry_pk_test_algo (pubkey_algo))
361     {
362       log_info (_("public key algorithm %d (%s) is not supported\n"),
363                 pubkey_algo, gcry_pk_algo_name (pubkey_algo));
364       return gpg_error (GPG_ERR_PUBKEY_ALGO);
365     }
366
367   /* Get properties of the public key algorithm and do some
368      consistency checks.  Note that we need at least NPKEY+1 elements
369      in the SKEY array. */
370   get_npkey_nskey (pubkey_algo, &npkey, &nskey);
371   if (!npkey || !nskey || npkey >= nskey)
372     return gpg_error (GPG_ERR_INTERNAL);
373   if (skeylen <= npkey)
374     return gpg_error (GPG_ERR_MISSING_VALUE);
375   if (nskey+1 >= skeysize)
376     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
377
378   /* Check that the public key parameters are all available and not
379      encrypted.  */
380   for (i=0; i < npkey; i++)
381     {
382       if (!skey[i] || gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_USER1))
383         return gpg_error (GPG_ERR_BAD_SECKEY);
384     }
385
386   if (r_npkey)
387     *r_npkey = npkey;
388   if (r_nskey)
389     *r_nskey = nskey;
390   if (r_skeylen)
391     *r_skeylen = skeylen;
392   return 0;
393 }
394
395
396 /* Note that this function modifies SKEY.  SKEYSIZE is the allocated
397    size of the array including the NULL item; this is used for a
398    bounds check.  On success a converted key is stored at R_KEY.  */
399 static int
400 do_unprotect (const char *passphrase,
401               int pkt_version, int pubkey_algo, int is_protected,
402               const char *curve, gcry_mpi_t *skey, size_t skeysize,
403               int protect_algo, void *protect_iv, size_t protect_ivlen,
404               int s2k_mode, int s2k_algo, byte *s2k_salt, u32 s2k_count,
405               u16 desired_csum, gcry_sexp_t *r_key)
406 {
407   gpg_error_t err;
408   unsigned int npkey, nskey, skeylen;
409   gcry_cipher_hd_t cipher_hd = NULL;
410   u16 actual_csum;
411   size_t nbytes;
412   int i;
413   gcry_mpi_t tmpmpi;
414
415   *r_key = NULL;
416
417   err = prepare_unprotect (pubkey_algo, skey, skeysize, s2k_mode,
418                            &npkey, &nskey, &skeylen);
419   if (err)
420     return err;
421
422   /* Check whether SKEY is at all protected.  If it is not protected
423      merely verify the checksum.  */
424   if (!is_protected)
425     {
426       actual_csum = 0;
427       for (i=npkey; i < nskey; i++)
428         {
429           if (!skey[i] || gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_USER1))
430             return gpg_error (GPG_ERR_BAD_SECKEY);
431
432           if (gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_OPAQUE))
433             {
434               unsigned int nbits;
435               const unsigned char *buffer;
436               buffer = gcry_mpi_get_opaque (skey[i], &nbits);
437               nbytes = (nbits+7)/8;
438               actual_csum += checksum (buffer, nbytes);
439             }
440           else
441             {
442               unsigned char *buffer;
443
444               err = gcry_mpi_aprint (GCRYMPI_FMT_PGP, &buffer, &nbytes,
445                                      skey[i]);
446               if (!err)
447                 actual_csum += checksum (buffer, nbytes);
448               xfree (buffer);
449             }
450           if (err)
451             return err;
452         }
453
454       if (actual_csum != desired_csum)
455         return gpg_error (GPG_ERR_CHECKSUM);
456
457       goto do_convert;
458     }
459
460
461   if (gcry_cipher_test_algo (protect_algo))
462     {
463       /* The algorithm numbers are Libgcrypt numbers but fortunately
464          the OpenPGP algorithm numbers map one-to-one to the Libgcrypt
465          numbers.  */
466       log_info (_("protection algorithm %d (%s) is not supported\n"),
467                 protect_algo, gnupg_cipher_algo_name (protect_algo));
468       return gpg_error (GPG_ERR_CIPHER_ALGO);
469     }
470
471   if (gcry_md_test_algo (s2k_algo))
472     {
473       log_info (_("protection hash algorithm %d (%s) is not supported\n"),
474                 s2k_algo, gcry_md_algo_name (s2k_algo));
475       return gpg_error (GPG_ERR_DIGEST_ALGO);
476     }
477
478   err = gcry_cipher_open (&cipher_hd, protect_algo,
479                           GCRY_CIPHER_MODE_CFB,
480                           (GCRY_CIPHER_SECURE
481                            | (protect_algo >= 100 ?
482                               0 : GCRY_CIPHER_ENABLE_SYNC)));
483   if (err)
484     {
485       log_error ("failed to open cipher_algo %d: %s\n",
486                  protect_algo, gpg_strerror (err));
487       return err;
488     }
489
490   err = hash_passphrase_and_set_key (passphrase, cipher_hd, protect_algo,
491                                      s2k_mode, s2k_algo, s2k_salt, s2k_count);
492   if (err)
493     {
494       gcry_cipher_close (cipher_hd);
495       return err;
496     }
497
498   gcry_cipher_setiv (cipher_hd, protect_iv, protect_ivlen);
499
500   actual_csum = 0;
501   if (pkt_version >= 4)
502     {
503       int ndata;
504       unsigned int ndatabits;
505       const unsigned char *p;
506       unsigned char *data;
507       u16 csum_pgp7 = 0;
508
509       if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE ))
510         {
511           gcry_cipher_close (cipher_hd);
512           return gpg_error (GPG_ERR_BAD_SECKEY);
513         }
514       p = gcry_mpi_get_opaque (skey[npkey], &ndatabits);
515       ndata = (ndatabits+7)/8;
516
517       if (ndata > 1)
518         csum_pgp7 = buf16_to_u16 (p+ndata-2);
519       data = xtrymalloc_secure (ndata);
520       if (!data)
521         {
522           err = gpg_error_from_syserror ();
523           gcry_cipher_close (cipher_hd);
524           return err;
525         }
526       gcry_cipher_decrypt (cipher_hd, data, ndata, p, ndata);
527
528       p = data;
529       if (is_protected == 2)
530         {
531           /* This is the new SHA1 checksum method to detect tampering
532              with the key as used by the Klima/Rosa attack.  */
533           desired_csum = 0;
534           actual_csum = 1;  /* Default to bad checksum.  */
535
536           if (ndata < 20)
537             log_error ("not enough bytes for SHA-1 checksum\n");
538           else
539             {
540               gcry_md_hd_t h;
541
542               if (gcry_md_open (&h, GCRY_MD_SHA1, 1))
543                 BUG(); /* Algo not available. */
544               gcry_md_write (h, data, ndata - 20);
545               gcry_md_final (h);
546               if (!memcmp (gcry_md_read (h, GCRY_MD_SHA1), data+ndata-20, 20))
547                 actual_csum = 0; /* Digest does match.  */
548               gcry_md_close (h);
549             }
550         }
551       else
552         {
553           /* Old 16 bit checksum method.  */
554           if (ndata < 2)
555             {
556               log_error ("not enough bytes for checksum\n");
557               desired_csum = 0;
558               actual_csum = 1;  /* Mark checksum bad.  */
559             }
560           else
561             {
562               desired_csum = buf16_to_u16 (data+ndata-2);
563               actual_csum = checksum (data, ndata-2);
564               if (desired_csum != actual_csum)
565                 {
566                   /* This is a PGP 7.0.0 workaround */
567                   desired_csum = csum_pgp7; /* Take the encrypted one.  */
568                 }
569             }
570         }
571
572       /* Better check it here.  Otherwise the gcry_mpi_scan would fail
573          because the length may have an arbitrary value.  */
574       if (desired_csum == actual_csum)
575         {
576           for (i=npkey; i < nskey; i++ )
577             {
578               if (gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_PGP, p, ndata, &nbytes))
579                 {
580                   /* Checksum was okay, but not correctly decrypted.  */
581                   desired_csum = 0;
582                   actual_csum = 1;   /* Mark checksum bad.  */
583                   break;
584                 }
585               gcry_mpi_release (skey[i]);
586               skey[i] = tmpmpi;
587               ndata -= nbytes;
588               p += nbytes;
589             }
590           skey[i] = NULL;
591           skeylen = i;
592           assert (skeylen <= skeysize);
593
594           /* Note: at this point NDATA should be 2 for a simple
595              checksum or 20 for the sha1 digest.  */
596         }
597       xfree(data);
598     }
599   else /* Packet version <= 3.  */
600     {
601       unsigned char *buffer;
602
603       for (i = npkey; i < nskey; i++)
604         {
605           const unsigned char *p;
606           size_t ndata;
607           unsigned int ndatabits;
608
609           if (!skey[i] || !gcry_mpi_get_flag (skey[i], GCRYMPI_FLAG_OPAQUE))
610             {
611               gcry_cipher_close (cipher_hd);
612               return gpg_error (GPG_ERR_BAD_SECKEY);
613             }
614           p = gcry_mpi_get_opaque (skey[i], &ndatabits);
615           ndata = (ndatabits+7)/8;
616
617           if (!(ndata >= 2) || !(ndata == (buf16_to_ushort (p) + 7)/8 + 2))
618             {
619               gcry_cipher_close (cipher_hd);
620               return gpg_error (GPG_ERR_BAD_SECKEY);
621             }
622
623           buffer = xtrymalloc_secure (ndata);
624           if (!buffer)
625             {
626               err = gpg_error_from_syserror ();
627               gcry_cipher_close (cipher_hd);
628               return err;
629             }
630
631           gcry_cipher_sync (cipher_hd);
632           buffer[0] = p[0];
633           buffer[1] = p[1];
634           gcry_cipher_decrypt (cipher_hd, buffer+2, ndata-2, p+2, ndata-2);
635           actual_csum += checksum (buffer, ndata);
636           err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_PGP, buffer, ndata, &ndata);
637           xfree (buffer);
638           if (err)
639             {
640               /* Checksum was okay, but not correctly decrypted.  */
641               desired_csum = 0;
642               actual_csum = 1;   /* Mark checksum bad.  */
643               break;
644             }
645           gcry_mpi_release (skey[i]);
646           skey[i] = tmpmpi;
647         }
648     }
649   gcry_cipher_close (cipher_hd);
650
651   /* Now let's see whether we have used the correct passphrase. */
652   if (actual_csum != desired_csum)
653     return gpg_error (GPG_ERR_BAD_PASSPHRASE);
654
655  do_convert:
656   if (nskey != skeylen)
657     err = gpg_error (GPG_ERR_BAD_SECKEY);
658   else
659     err = convert_secret_key (r_key, pubkey_algo, skey, curve);
660   if (err)
661     return err;
662
663   /* The checksum may fail, thus we also check the key itself.  */
664   err = gcry_pk_testkey (*r_key);
665   if (err)
666     {
667       gcry_sexp_release (*r_key);
668       *r_key = NULL;
669       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
670     }
671
672   return 0;
673 }
674
675
676 /* Callback function to try the unprotection from the passphrase query
677    code.  */
678 static int
679 try_do_unprotect_cb (struct pin_entry_info_s *pi)
680 {
681   gpg_error_t err;
682   struct try_do_unprotect_arg_s *arg = pi->check_cb_arg;
683
684   err = do_unprotect (pi->pin,
685                       arg->is_v4? 4:3,
686                       arg->pubkey_algo, arg->is_protected,
687                       arg->curve,
688                       arg->skey, arg->skeysize,
689                       arg->protect_algo, arg->iv, arg->ivlen,
690                       arg->s2k_mode, arg->s2k_algo,
691                       arg->s2k_salt, arg->s2k_count,
692                       arg->desired_csum, arg->r_key);
693   /* SKEY may be modified now, thus we need to re-compute SKEYIDX.  */
694   for (arg->skeyidx = 0; (arg->skeyidx < arg->skeysize
695                           && arg->skey[arg->skeyidx]); arg->skeyidx++)
696     ;
697   return err;
698 }
699
700
701 /* See convert_from_openpgp for the core of the description.  This
702    function adds an optional PASSPHRASE argument and uses this to
703    silently decrypt the key; CACHE_NONCE and R_PASSPHRASE must both be
704    NULL in this mode.  */
705 static gpg_error_t
706 convert_from_openpgp_main (ctrl_t ctrl, gcry_sexp_t s_pgp,
707                            unsigned char *grip, const char *prompt,
708                            const char *cache_nonce, const char *passphrase,
709                            unsigned char **r_key, char **r_passphrase)
710 {
711   gpg_error_t err;
712   int unattended;
713   int from_native;
714   gcry_sexp_t top_list;
715   gcry_sexp_t list = NULL;
716   const char *value;
717   size_t valuelen;
718   char *string;
719   int  idx;
720   int  is_v4, is_protected;
721   int  pubkey_algo;
722   int  protect_algo = 0;
723   char iv[16];
724   int  ivlen = 0;
725   int  s2k_mode = 0;
726   int  s2k_algo = 0;
727   byte s2k_salt[8];
728   u32  s2k_count = 0;
729   size_t npkey, nskey;
730   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
731   char *curve = NULL;
732   u16 desired_csum;
733   int skeyidx = 0;
734   gcry_sexp_t s_skey = NULL;
735
736   *r_key = NULL;
737   if (r_passphrase)
738     *r_passphrase = NULL;
739   unattended = !r_passphrase;
740   from_native = (!cache_nonce && passphrase && !r_passphrase);
741
742   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
743   if (!top_list)
744     goto bad_seckey;
745
746   list = gcry_sexp_find_token (top_list, "version", 0);
747   if (!list)
748     goto bad_seckey;
749   value = gcry_sexp_nth_data (list, 1, &valuelen);
750   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
751     goto bad_seckey;
752   is_v4 = (value[0] == '4');
753
754   gcry_sexp_release (list);
755   list = gcry_sexp_find_token (top_list, "protection", 0);
756   if (!list)
757     goto bad_seckey;
758   value = gcry_sexp_nth_data (list, 1, &valuelen);
759   if (!value)
760     goto bad_seckey;
761   if (valuelen == 4 && !memcmp (value, "sha1", 4))
762     is_protected = 2;
763   else if (valuelen == 3 && !memcmp (value, "sum", 3))
764     is_protected = 1;
765   else if (valuelen == 4 && !memcmp (value, "none", 4))
766     is_protected = 0;
767   else
768     goto bad_seckey;
769
770   if (is_protected)
771     {
772       string = gcry_sexp_nth_string (list, 2);
773       if (!string)
774         goto bad_seckey;
775       protect_algo = gcry_cipher_map_name (string);
776       xfree (string);
777
778       value = gcry_sexp_nth_data (list, 3, &valuelen);
779       if (!value || !valuelen || valuelen > sizeof iv)
780         goto bad_seckey;
781       memcpy (iv, value, valuelen);
782       ivlen = valuelen;
783
784       string = gcry_sexp_nth_string (list, 4);
785       if (!string)
786         goto bad_seckey;
787       s2k_mode = strtol (string, NULL, 10);
788       xfree (string);
789
790       string = gcry_sexp_nth_string (list, 5);
791       if (!string)
792         goto bad_seckey;
793       s2k_algo = gcry_md_map_name (string);
794       xfree (string);
795
796       value = gcry_sexp_nth_data (list, 6, &valuelen);
797       if (!value || !valuelen || valuelen > sizeof s2k_salt)
798         goto bad_seckey;
799       memcpy (s2k_salt, value, valuelen);
800
801       string = gcry_sexp_nth_string (list, 7);
802       if (!string)
803         goto bad_seckey;
804       s2k_count = strtoul (string, NULL, 10);
805       xfree (string);
806     }
807
808   gcry_sexp_release (list);
809   list = gcry_sexp_find_token (top_list, "algo", 0);
810   if (!list)
811     goto bad_seckey;
812   string = gcry_sexp_nth_string (list, 1);
813   if (!string)
814     goto bad_seckey;
815   pubkey_algo = gcry_pk_map_name (string);
816   xfree (string);
817
818   get_npkey_nskey (pubkey_algo, &npkey, &nskey);
819   if (!npkey || !nskey || npkey >= nskey)
820     goto bad_seckey;
821
822   if (npkey == 1) /* This is ECC */
823     {
824       gcry_sexp_release (list);
825       list = gcry_sexp_find_token (top_list, "curve", 0);
826       if (!list)
827         goto bad_seckey;
828       curve = gcry_sexp_nth_string (list, 1);
829       if (!curve)
830         goto bad_seckey;
831     }
832
833   gcry_sexp_release (list);
834   list = gcry_sexp_find_token (top_list, "skey", 0);
835   if (!list)
836     goto bad_seckey;
837   for (idx=0;;)
838     {
839       int is_enc;
840
841       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
842       if (!value && skeyidx >= npkey)
843         break;  /* Ready.  */
844
845       /* Check for too many parameters.  Note that depending on the
846          protection mode and version number we may see less than NSKEY
847          (but at least NPKEY+1) parameters.  */
848       if (idx >= 2*nskey)
849         goto bad_seckey;
850       if (skeyidx >= DIM (skey)-1)
851         goto bad_seckey;
852
853       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
854         goto bad_seckey;
855       is_enc = (value[0] == 'e');
856       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
857       if (!value || !valuelen)
858         goto bad_seckey;
859       if (is_enc || curve)
860         {
861           /* Encrypted parameters and ECC parameters need or can be
862              stored as opaque.  */
863           skey[skeyidx] = gcry_mpi_set_opaque_copy (NULL, value, valuelen*8);
864           if (!skey[skeyidx])
865             goto outofmem;
866           if (is_enc)
867             gcry_mpi_set_flag (skey[skeyidx], GCRYMPI_FLAG_USER1);
868         }
869       else
870         {
871           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
872                              value, valuelen, NULL))
873             goto bad_seckey;
874         }
875       skeyidx++;
876     }
877   skey[skeyidx++] = NULL;
878
879   gcry_sexp_release (list);
880   list = gcry_sexp_find_token (top_list, "csum", 0);
881   if (list)
882     {
883       string = gcry_sexp_nth_string (list, 1);
884       if (!string)
885         goto bad_seckey;
886       desired_csum = strtoul (string, NULL, 10);
887       xfree (string);
888     }
889   else
890     desired_csum = 0;
891
892
893   gcry_sexp_release (list); list = NULL;
894   gcry_sexp_release (top_list); top_list = NULL;
895
896 #if 0
897   log_debug ("XXX is_v4=%d\n", is_v4);
898   log_debug ("XXX pubkey_algo=%d\n", pubkey_algo);
899   log_debug ("XXX is_protected=%d\n", is_protected);
900   log_debug ("XXX protect_algo=%d\n", protect_algo);
901   log_printhex ("XXX iv", iv, ivlen);
902   log_debug ("XXX ivlen=%d\n", ivlen);
903   log_debug ("XXX s2k_mode=%d\n", s2k_mode);
904   log_debug ("XXX s2k_algo=%d\n", s2k_algo);
905   log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt);
906   log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count);
907   log_debug ("XXX curve='%s'\n", curve);
908   for (idx=0; skey[idx]; idx++)
909     gcry_log_debugmpi (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_USER1)
910                        ? "skey(e)" : "skey(_)", skey[idx]);
911 #endif /*0*/
912
913   err = get_keygrip (pubkey_algo, curve, skey, grip);
914   if (err)
915     goto leave;
916
917   if (!from_native && !agent_key_available (grip))
918     {
919       err = gpg_error (GPG_ERR_EEXIST);
920       goto leave;
921     }
922
923   if (unattended && !from_native)
924     {
925       err = prepare_unprotect (pubkey_algo, skey, DIM(skey), s2k_mode,
926                                NULL, NULL, NULL);
927       if (err)
928         goto leave;
929
930       err = convert_transfer_key (&s_skey, pubkey_algo, skey, curve, s_pgp);
931       if (err)
932         goto leave;
933     }
934   else
935     {
936       struct pin_entry_info_s *pi;
937       struct try_do_unprotect_arg_s pi_arg;
938
939       pi = xtrycalloc_secure (1, sizeof (*pi) + 100);
940       if (!pi)
941         return gpg_error_from_syserror ();
942       pi->max_length = 100;
943       pi->min_digits = 0;  /* We want a real passphrase.  */
944       pi->max_digits = 16;
945       pi->max_tries = 3;
946       pi->check_cb = try_do_unprotect_cb;
947       pi->check_cb_arg = &pi_arg;
948       pi_arg.is_v4 = is_v4;
949       pi_arg.is_protected = is_protected;
950       pi_arg.pubkey_algo = pubkey_algo;
951       pi_arg.curve = curve;
952       pi_arg.protect_algo = protect_algo;
953       pi_arg.iv = iv;
954       pi_arg.ivlen = ivlen;
955       pi_arg.s2k_mode = s2k_mode;
956       pi_arg.s2k_algo = s2k_algo;
957       pi_arg.s2k_salt = s2k_salt;
958       pi_arg.s2k_count = s2k_count;
959       pi_arg.desired_csum = desired_csum;
960       pi_arg.skey = skey;
961       pi_arg.skeysize = DIM (skey);
962       pi_arg.skeyidx = skeyidx;
963       pi_arg.r_key = &s_skey;
964
965       err = gpg_error (GPG_ERR_BAD_PASSPHRASE);
966       if (!is_protected)
967         {
968           err = try_do_unprotect_cb (pi);
969         }
970       else if (cache_nonce)
971         {
972           char *cache_value;
973
974           cache_value = agent_get_cache (cache_nonce, CACHE_MODE_NONCE);
975           if (cache_value)
976             {
977               if (strlen (cache_value) < pi->max_length)
978                 strcpy (pi->pin, cache_value);
979               xfree (cache_value);
980             }
981           if (*pi->pin)
982             err = try_do_unprotect_cb (pi);
983         }
984       else if (from_native)
985         {
986           if (strlen (passphrase) < pi->max_length)
987             strcpy (pi->pin, passphrase);
988           err = try_do_unprotect_cb (pi);
989         }
990       if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE && !from_native)
991         err = agent_askpin (ctrl, prompt, NULL, NULL, pi, NULL, 0);
992       skeyidx = pi_arg.skeyidx;
993       if (!err && r_passphrase && is_protected)
994         {
995           *r_passphrase = xtrystrdup (pi->pin);
996           if (!*r_passphrase)
997             err = gpg_error_from_syserror ();
998         }
999       xfree (pi);
1000       if (err)
1001         goto leave;
1002     }
1003
1004   /* Save some memory and get rid of the SKEY array now.  */
1005   for (idx=0; idx < skeyidx; idx++)
1006     gcry_mpi_release (skey[idx]);
1007   skeyidx = 0;
1008
1009   /* Note that the padding is not required - we use it only because
1010      that function allows us to create the result in secure memory.  */
1011   err = make_canon_sexp_pad (s_skey, 1, r_key, NULL);
1012
1013  leave:
1014   xfree (curve);
1015   gcry_sexp_release (s_skey);
1016   gcry_sexp_release (list);
1017   gcry_sexp_release (top_list);
1018   for (idx=0; idx < skeyidx; idx++)
1019     gcry_mpi_release (skey[idx]);
1020   if (err && r_passphrase)
1021     {
1022       xfree (*r_passphrase);
1023       *r_passphrase = NULL;
1024     }
1025   return err;
1026
1027  bad_seckey:
1028   err = gpg_error (GPG_ERR_BAD_SECKEY);
1029   goto leave;
1030
1031  outofmem:
1032   err = gpg_error (GPG_ERR_ENOMEM);
1033   goto leave;
1034
1035 }
1036
1037
1038 /* Convert an OpenPGP transfer key into our internal format.  Before
1039    asking for a passphrase we check whether the key already exists in
1040    our key storage.  S_PGP is the OpenPGP key in transfer format.  If
1041    CACHE_NONCE is given the passphrase will be looked up in the cache.
1042    On success R_KEY will receive a canonical encoded S-expression with
1043    the unprotected key in our internal format; the caller needs to
1044    release that memory.  The passphrase used to decrypt the OpenPGP
1045    key will be returned at R_PASSPHRASE; the caller must release this
1046    passphrase.  If R_PASSPHRASE is NULL the unattended conversion mode
1047    will be used which uses the openpgp-native protection format for
1048    the key.  The keygrip will be stored at the 20 byte buffer pointed
1049    to by GRIP.  On error NULL is stored at all return arguments.  */
1050 gpg_error_t
1051 convert_from_openpgp (ctrl_t ctrl, gcry_sexp_t s_pgp,
1052                       unsigned char *grip, const char *prompt,
1053                       const char *cache_nonce,
1054                       unsigned char **r_key, char **r_passphrase)
1055 {
1056   return convert_from_openpgp_main (ctrl, s_pgp, grip, prompt,
1057                                     cache_nonce, NULL,
1058                                     r_key, r_passphrase);
1059 }
1060
1061 /* This function is called by agent_unprotect to re-protect an
1062    openpgp-native protected private-key into the standard private-key
1063    protection format.  */
1064 gpg_error_t
1065 convert_from_openpgp_native (ctrl_t ctrl,
1066                              gcry_sexp_t s_pgp, const char *passphrase,
1067                              unsigned char **r_key)
1068 {
1069   gpg_error_t err;
1070   unsigned char grip[20];
1071
1072   if (!passphrase)
1073     return gpg_error (GPG_ERR_INTERNAL);
1074
1075   err = convert_from_openpgp_main (ctrl, s_pgp, grip, NULL,
1076                                    NULL, passphrase,
1077                                    r_key, NULL);
1078
1079   /* On success try to re-write the key.  */
1080   if (!err)
1081     {
1082       if (*passphrase)
1083         {
1084           unsigned char *protectedkey = NULL;
1085           size_t protectedkeylen;
1086
1087           if (!agent_protect (*r_key, passphrase,
1088                               &protectedkey, &protectedkeylen,
1089                               ctrl->s2k_count))
1090             agent_write_private_key (grip, protectedkey, protectedkeylen, 1);
1091           xfree (protectedkey);
1092         }
1093       else
1094         {
1095           /* Empty passphrase: write key without protection.  */
1096           agent_write_private_key (grip,
1097                                    *r_key,
1098                                    gcry_sexp_canon_len (*r_key, 0, NULL,NULL),
1099                                    1);
1100         }
1101     }
1102
1103   return err;
1104 }
1105
1106
1107 /* Given an ARRAY of mpis with the key parameters, protect the secret
1108    parameters in that array and replace them by one opaque encoded
1109    mpi.  NPKEY is the number of public key parameters and NSKEY is
1110    the number of secret key parameters (including the public ones).
1111    On success the array will have NPKEY+1 elements.  */
1112 static gpg_error_t
1113 apply_protection (gcry_mpi_t *array, int npkey, int nskey,
1114                   const char *passphrase,
1115                   int protect_algo, void *protect_iv, size_t protect_ivlen,
1116                   int s2k_mode, int s2k_algo, byte *s2k_salt, u32 s2k_count)
1117 {
1118   gpg_error_t err;
1119   int i, j;
1120   gcry_cipher_hd_t cipherhd;
1121   unsigned char *bufarr[10];
1122   size_t narr[10];
1123   unsigned int nbits[10];
1124   int ndata;
1125   unsigned char *p, *data;
1126
1127   assert (npkey < nskey);
1128   assert (nskey < DIM (bufarr));
1129
1130   /* Collect only the secret key parameters into BUFARR et al and
1131      compute the required size of the data buffer.  */
1132   ndata = 20; /* Space for the SHA-1 checksum.  */
1133   for (i = npkey, j = 0; i < nskey; i++, j++ )
1134     {
1135       if (gcry_mpi_get_flag (array[i], GCRYMPI_FLAG_OPAQUE))
1136         {
1137           const unsigned char *s;
1138           unsigned int n;
1139
1140           s = gcry_mpi_get_opaque (array[i], &n);
1141           if (!s)
1142             {
1143               s = "";
1144               n = 0;
1145             }
1146           /* Strip leading zero bits.  */
1147           for (; n >= 8 && !*s; s++, n -= 8)
1148             ;
1149           if (n >= 8 && !(*s & 0x80))
1150             if (--n >= 7 && !(*s & 0x40))
1151               if (--n >= 6 && !(*s & 0x20))
1152                 if (--n >= 5 && !(*s & 0x10))
1153                   if (--n >= 4 && !(*s & 0x08))
1154                     if (--n >= 3 && !(*s & 0x04))
1155                       if (--n >= 2 && !(*s & 0x02))
1156                         if (--n >= 1 && !(*s & 0x01))
1157                           --n;
1158
1159           nbits[j] = n;
1160           n = (n+7)/8;
1161           narr[j] = n;
1162           bufarr[j] = (gcry_is_secure (s)? xtrymalloc_secure (n?n:1)
1163                        /* */             : xtrymalloc (n?n:1));
1164           if (!bufarr[j])
1165             {
1166               err = gpg_error_from_syserror ();
1167               for (i = 0; i < j; i++)
1168                 xfree (bufarr[i]);
1169               return err;
1170             }
1171           memcpy (bufarr[j], s, n);
1172         }
1173       else
1174         {
1175           err = gcry_mpi_aprint (GCRYMPI_FMT_USG, bufarr+j, narr+j, array[i]);
1176           if (err)
1177             {
1178               for (i = 0; i < j; i++)
1179                 xfree (bufarr[i]);
1180               return err;
1181             }
1182           nbits[j] = gcry_mpi_get_nbits (array[i]);
1183         }
1184       ndata += 2 + narr[j];
1185     }
1186
1187   /* Allocate data buffer and stuff it with the secret key parameters.  */
1188   data = xtrymalloc_secure (ndata);
1189   if (!data)
1190     {
1191       err = gpg_error_from_syserror ();
1192       for (i = 0; i < (nskey-npkey); i++ )
1193         xfree (bufarr[i]);
1194       return err;
1195     }
1196   p = data;
1197   for (i = 0; i < (nskey-npkey); i++ )
1198     {
1199       *p++ = nbits[i] >> 8 ;
1200       *p++ = nbits[i];
1201       memcpy (p, bufarr[i], narr[i]);
1202       p += narr[i];
1203       xfree (bufarr[i]);
1204       bufarr[i] = NULL;
1205     }
1206   assert (p == data + ndata - 20);
1207
1208   /* Append a hash of the secret key parameters.  */
1209   gcry_md_hash_buffer (GCRY_MD_SHA1, p, data, ndata - 20);
1210
1211   /* Encrypt it.  */
1212   err = gcry_cipher_open (&cipherhd, protect_algo,
1213                           GCRY_CIPHER_MODE_CFB, GCRY_CIPHER_SECURE);
1214   if (!err)
1215     err = hash_passphrase_and_set_key (passphrase, cipherhd, protect_algo,
1216                                        s2k_mode, s2k_algo, s2k_salt, s2k_count);
1217   if (!err)
1218     err = gcry_cipher_setiv (cipherhd, protect_iv, protect_ivlen);
1219   if (!err)
1220     err = gcry_cipher_encrypt (cipherhd, data, ndata, NULL, 0);
1221   gcry_cipher_close (cipherhd);
1222   if (err)
1223     {
1224       xfree (data);
1225       return err;
1226     }
1227
1228   /* Replace the secret key parameters in the array by one opaque value.  */
1229   for (i = npkey; i < nskey; i++ )
1230     {
1231       gcry_mpi_release (array[i]);
1232       array[i] = NULL;
1233     }
1234   array[npkey] = gcry_mpi_set_opaque (NULL, data, ndata*8);
1235   return 0;
1236 }
1237
1238
1239 /*
1240  * Examining S_KEY in S-Expression and extract data.
1241  * When REQ_PRIVATE_KEY_DATA == 1, S_KEY's CAR should be 'private-key',
1242  * but it also allows shadowed or protected versions.
1243  * On success, it returns 0, otherwise error number.
1244  * R_ALGONAME is static string which is no need to free by caller.
1245  * R_NPKEY is pointer to number of public key data.
1246  * R_NSKEY is pointer to number of private key data.
1247  * R_ELEMS is static string which is no need to free by caller.
1248  * ARRAY contains public and private key data.
1249  * ARRAYSIZE is the allocated size of the array for cross-checking.
1250  * R_CURVE is pointer to S-Expression of the curve (can be NULL).
1251  * R_FLAGS is pointer to S-Expression of the flags (can be NULL).
1252  */
1253 gpg_error_t
1254 extract_private_key (gcry_sexp_t s_key, int req_private_key_data,
1255                      const char **r_algoname, int *r_npkey, int *r_nskey,
1256                      const char **r_elems,
1257                      gcry_mpi_t *array, int arraysize,
1258                      gcry_sexp_t *r_curve, gcry_sexp_t *r_flags)
1259 {
1260   gpg_error_t err;
1261   gcry_sexp_t list, l2;
1262   char *name;
1263   const char *algoname, *format;
1264   int npkey, nskey;
1265   gcry_sexp_t curve = NULL;
1266   gcry_sexp_t flags = NULL;
1267
1268   *r_curve = NULL;
1269   *r_flags = NULL;
1270
1271   if (!req_private_key_data)
1272     {
1273       list = gcry_sexp_find_token (s_key, "shadowed-private-key", 0 );
1274       if (!list)
1275         list = gcry_sexp_find_token (s_key, "protected-private-key", 0 );
1276       if (!list)
1277         list = gcry_sexp_find_token (s_key, "private-key", 0 );
1278     }
1279   else
1280     list = gcry_sexp_find_token (s_key, "private-key", 0);
1281
1282   if (!list)
1283     {
1284       log_error ("invalid private key format\n");
1285       return gpg_error (GPG_ERR_BAD_SECKEY);
1286     }
1287
1288   l2 = gcry_sexp_cadr (list);
1289   gcry_sexp_release (list);
1290   list = l2;
1291   name = gcry_sexp_nth_string (list, 0);
1292   if (!name)
1293     {
1294       gcry_sexp_release (list);
1295       return gpg_error (GPG_ERR_INV_OBJ); /* Invalid structure of object. */
1296     }
1297
1298   if (arraysize < 7)
1299     BUG ();
1300
1301   /* Map NAME to a name as used by Libgcrypt.  We do not use the
1302      Libgcrypt function here because we need a lowercase name and
1303      require special treatment for some algorithms.  */
1304   strlwr (name);
1305   if (!strcmp (name, "rsa"))
1306     {
1307       algoname = "rsa";
1308       format = "ned?p?q?u?";
1309       npkey = 2;
1310       nskey = 6;
1311       err = gcry_sexp_extract_param (list, NULL, format,
1312                                      array+0, array+1, array+2, array+3,
1313                                      array+4, array+5, NULL);
1314     }
1315   else if (!strcmp (name, "elg"))
1316     {
1317       algoname = "elg";
1318       format = "pgyx?";
1319       npkey = 3;
1320       nskey = 4;
1321       err = gcry_sexp_extract_param (list, NULL, format,
1322                                      array+0, array+1, array+2, array+3,
1323                                      NULL);
1324     }
1325   else if (!strcmp (name, "dsa"))
1326     {
1327       algoname = "dsa";
1328       format = "pqgyx?";
1329       npkey = 4;
1330       nskey = 5;
1331       err = gcry_sexp_extract_param (list, NULL, format,
1332                                      array+0, array+1, array+2, array+3,
1333                                      array+4, NULL);
1334     }
1335   else if (!strcmp (name, "ecc"))
1336     {
1337       algoname = "ecc";
1338       format = "/qd?";
1339       npkey = 1;
1340       nskey = 2;
1341       curve = gcry_sexp_find_token (list, "curve", 0);
1342       flags = gcry_sexp_find_token (list, "flags", 0);
1343       err = gcry_sexp_extract_param (list, NULL, format,
1344                                      array+0, array+1, NULL);
1345       if (flags)
1346         {
1347           gcry_sexp_t param = gcry_sexp_find_token (flags, "param", 0);
1348           if (param)
1349             {
1350               gcry_sexp_release (param);
1351               array[6] = array[0];
1352               array[7] = array[1];
1353               err = gcry_sexp_extract_param (list, NULL, "pabgnh?",
1354                                              array+0, array+1, array+2, array+3,
1355                                              array+4, array+5, NULL);
1356               if (array[5] == NULL)
1357                 {
1358                   array[5] = GCRYMPI_CONST_ONE;
1359                   npkey += 6;
1360                   nskey += 6;
1361                 }
1362               format = "pabgnhqd?";
1363             }
1364         }
1365     }
1366   else if (!strcmp (name, "ecdsa"))
1367     {
1368       algoname = "ecdsa";
1369       format = "pabgnqd?";
1370       npkey = 6;
1371       nskey = 7;
1372       err = gcry_sexp_extract_param (list, NULL, format,
1373                                      array+0, array+1, array+2, array+3,
1374                                      array+4, array+5, array+6, NULL);
1375     }
1376   else if (!strcmp (name, "ecdh"))
1377     {
1378       algoname = "ecdh";
1379       format = "pabgnqd?";
1380       npkey = 6;
1381       nskey= 7;
1382       err = gcry_sexp_extract_param (list, NULL, format,
1383                                      array+0, array+1, array+2, array+3,
1384                                      array+4, array+5, array+6, NULL);
1385     }
1386   else
1387     {
1388       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1389     }
1390   xfree (name);
1391   gcry_sexp_release (list);
1392   if (err)
1393     {
1394       gcry_sexp_release (curve);
1395       gcry_sexp_release (flags);
1396       return err;
1397     }
1398   else
1399     {
1400       *r_algoname = algoname;
1401       if (r_elems)
1402         {
1403           if (format[0] == '/') /* It is opaque data qualifier, skip it.  */
1404             *r_elems = format+1;
1405           else
1406             *r_elems = format;
1407         }
1408       *r_npkey = npkey;
1409       if (r_nskey)
1410         *r_nskey = nskey;
1411       *r_curve = curve;
1412       *r_flags = flags;
1413
1414       return 0;
1415     }
1416 }
1417
1418 /* Convert our key S_KEY into an OpenPGP key transfer format.  On
1419    success a canonical encoded S-expression is stored at R_TRANSFERKEY
1420    and its length at R_TRANSFERKEYLEN; this S-expression is also
1421    padded to a multiple of 64 bits.  */
1422 gpg_error_t
1423 convert_to_openpgp (ctrl_t ctrl, gcry_sexp_t s_key, const char *passphrase,
1424                     unsigned char **r_transferkey, size_t *r_transferkeylen)
1425 {
1426   gpg_error_t err;
1427   const char *algoname;
1428   int npkey, nskey;
1429   gcry_mpi_t array[10];
1430   gcry_sexp_t curve = NULL;
1431   gcry_sexp_t flags = NULL;
1432   char protect_iv[16];
1433   char salt[8];
1434   unsigned long s2k_count;
1435   int i, j;
1436
1437   (void)ctrl;
1438
1439   *r_transferkey = NULL;
1440
1441   for (i=0; i < DIM (array); i++)
1442     array[i] = NULL;
1443
1444   err = extract_private_key (s_key, 1, &algoname, &npkey, &nskey, NULL,
1445                              array, DIM (array), &curve, &flags);
1446   if (err)
1447     return err;
1448
1449   gcry_create_nonce (protect_iv, sizeof protect_iv);
1450   gcry_create_nonce (salt, sizeof salt);
1451   /* We need to use the encoded S2k count.  It is not possible to
1452      encode it after it has been used because the encoding procedure
1453      may round the value up.  */
1454   s2k_count = get_standard_s2k_count_rfc4880 ();
1455   err = apply_protection (array, npkey, nskey, passphrase,
1456                           GCRY_CIPHER_AES, protect_iv, sizeof protect_iv,
1457                           3, GCRY_MD_SHA1, salt, s2k_count);
1458   /* Turn it into the transfer key S-expression.  Note that we always
1459      return a protected key.  */
1460   if (!err)
1461     {
1462       char countbuf[35];
1463       membuf_t mbuf;
1464       void *format_args[10+2];
1465       gcry_sexp_t tmpkey;
1466       gcry_sexp_t tmpsexp = NULL;
1467
1468       snprintf (countbuf, sizeof countbuf, "%lu", s2k_count);
1469
1470       init_membuf (&mbuf, 50);
1471       put_membuf_str (&mbuf, "(skey");
1472       for (i=j=0; i < npkey; i++)
1473         {
1474           put_membuf_str (&mbuf, " _ %m");
1475           format_args[j++] = array + i;
1476         }
1477       put_membuf_str (&mbuf, " e %m");
1478       format_args[j++] = array + npkey;
1479       put_membuf_str (&mbuf, ")\n");
1480       put_membuf (&mbuf, "", 1);
1481
1482       tmpkey = NULL;
1483       {
1484         char *format = get_membuf (&mbuf, NULL);
1485         if (!format)
1486           err = gpg_error_from_syserror ();
1487         else
1488           err = gcry_sexp_build_array (&tmpkey, NULL, format, format_args);
1489         xfree (format);
1490       }
1491       if (!err)
1492         err = gcry_sexp_build (&tmpsexp, NULL,
1493                                "(openpgp-private-key\n"
1494                                " (version 1:4)\n"
1495                                " (algo %s)\n"
1496                                " %S%S\n"
1497                                " (protection sha1 aes %b 1:3 sha1 %b %s))\n",
1498                                algoname,
1499                                curve,
1500                                tmpkey,
1501                                (int)sizeof protect_iv, protect_iv,
1502                                (int)sizeof salt, salt,
1503                                countbuf);
1504       gcry_sexp_release (tmpkey);
1505       if (!err)
1506         err = make_canon_sexp_pad (tmpsexp, 0, r_transferkey, r_transferkeylen);
1507       gcry_sexp_release (tmpsexp);
1508     }
1509
1510   for (i=0; i < DIM (array); i++)
1511     gcry_mpi_release (array[i]);
1512   gcry_sexp_release (curve);
1513   gcry_sexp_release (flags);
1514
1515   return err;
1516 }