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