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