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