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