Exporting secret keys via gpg-agent is now basically supported.
[gnupg.git] / g10 / export.c
1 /* export.c - Export keys in the OpenPGP defined format.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "keydb.h"
33 #include "util.h"
34 #include "main.h"
35 #include "i18n.h"
36 #include "trustdb.h"
37 #include "call-agent.h"
38
39 /* An object to keep track of subkeys. */
40 struct subkey_list_s
41 {
42   struct subkey_list_s *next;
43   u32 kid[2];
44 };
45 typedef struct subkey_list_s *subkey_list_t;
46
47
48 static int do_export (ctrl_t ctrl,
49                       strlist_t users, int secret, unsigned int options );
50 static int do_export_stream (ctrl_t ctrl, iobuf_t out,
51                              strlist_t users, int secret,
52                              kbnode_t *keyblock_out, unsigned int options,
53                              int *any);
54 static int build_sexp (iobuf_t out, PACKET *pkt, int *indent);
55
56
57 int
58 parse_export_options(char *str,unsigned int *options,int noisy)
59 {
60   struct parse_options export_opts[]=
61     {
62       {"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
63        N_("export signatures that are marked as local-only")},
64       {"export-attributes",EXPORT_ATTRIBUTES,NULL,
65        N_("export attribute user IDs (generally photo IDs)")},
66       {"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
67        N_("export revocation keys marked as \"sensitive\"")},
68       {"export-clean",EXPORT_CLEAN,NULL,
69        N_("remove unusable parts from key during export")},
70       {"export-minimal",EXPORT_MINIMAL|EXPORT_CLEAN,NULL,
71        N_("remove as much as possible from key during export")},
72       {"export-sexp-format",EXPORT_SEXP_FORMAT, NULL,
73        N_("export keys in an S-expression based format")},
74       /* Aliases for backward compatibility */
75       {"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
76       {"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
77       {"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
78       /* dummy */
79       {"export-unusable-sigs",0,NULL,NULL},
80       {"export-clean-sigs",0,NULL,NULL},
81       {"export-clean-uids",0,NULL,NULL},
82       {NULL,0,NULL,NULL}
83       /* add tags for include revoked and disabled? */
84     };
85
86   return parse_options(str,options,export_opts,noisy);
87 }
88
89
90 /****************
91  * Export the public keys (to standard out or --output).
92  * Depending on opt.armor the output is armored.
93  * options are defined in main.h.
94  * If USERS is NULL, the complete ring will be exported.  */
95 int
96 export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options )
97 {
98   return do_export (ctrl, users, 0, options );
99 }
100
101 /****************
102  * Export to an already opened stream; return -1 if no keys have
103  * been exported
104  */
105 int
106 export_pubkeys_stream (ctrl_t ctrl, iobuf_t out, strlist_t users,
107                        kbnode_t *keyblock_out, unsigned int options )
108 {
109   int any, rc;
110   
111   rc = do_export_stream (ctrl, out, users, 0, keyblock_out, options, &any);
112   if (!rc && !any)
113     rc = -1;
114   return rc;
115 }
116
117 int
118 export_seckeys (ctrl_t ctrl, strlist_t users )
119 {
120   /* Use only relevant options for the secret key. */
121   unsigned int options = (opt.export_options & EXPORT_SEXP_FORMAT);
122   return do_export (ctrl, users, 1, options);
123 }
124
125 int
126 export_secsubkeys (ctrl_t ctrl, strlist_t users )
127 {
128   /* Use only relevant options for the secret key. */
129   unsigned int options = (opt.export_options & EXPORT_SEXP_FORMAT);
130   return do_export (ctrl, users, 2, options);
131 }
132
133
134 /* Export the keys identified by the list of strings in USERS.  If
135    Secret is false public keys will be exported.  With secret true
136    secret keys will be exported; in this case 1 means the entire
137    secret keyblock and 2 only the subkeys.  OPTIONS are the export
138    options to apply.  */
139 static int
140 do_export (ctrl_t ctrl, strlist_t users, int secret, unsigned int options )
141 {
142   IOBUF out = NULL;
143   int any, rc;
144   armor_filter_context_t *afx = NULL;
145   compress_filter_context_t zfx;
146   
147   memset( &zfx, 0, sizeof zfx);
148   
149   rc = open_outfile (GNUPG_INVALID_FD, NULL, 0, &out );
150   if (rc)
151     return rc;
152
153   if (!(options & EXPORT_SEXP_FORMAT))
154     {
155       if ( opt.armor )
156         {
157           afx = new_armor_context ();
158           afx->what = secret? 5 : 1;
159           push_armor_filter (afx, out);
160         }
161       if ( opt.compress_keys )
162         push_compress_filter (out,&zfx,default_compress_algo());
163     }
164
165   rc = do_export_stream (ctrl, out, users, secret, NULL, options, &any );
166
167   if ( rc || !any )
168     iobuf_cancel (out);
169   else
170     iobuf_close (out);
171   release_armor_context (afx);
172   return rc;
173 }
174
175
176
177 /* Release an entire subkey list. */
178 static void
179 release_subkey_list (subkey_list_t list)
180 {
181   while (list)
182     {
183       subkey_list_t tmp = list->next;;
184       xfree (list);
185       list = tmp;
186     }
187 }
188
189
190 /* Returns true if NODE is a subkey and contained in LIST. */
191 static int
192 subkey_in_list_p (subkey_list_t list, KBNODE node)
193 {
194   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
195       || node->pkt->pkttype == PKT_SECRET_SUBKEY )
196     {
197       u32 kid[2];
198
199       keyid_from_pk (node->pkt->pkt.public_key, kid);
200       
201       for (; list; list = list->next)
202         if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
203           return 1;
204     }
205   return 0;
206 }
207
208 /* Allocate a new subkey list item from NODE. */
209 static subkey_list_t
210 new_subkey_list_item (KBNODE node)
211 {
212   subkey_list_t list = xcalloc (1, sizeof *list);
213
214   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
215       || node->pkt->pkttype == PKT_SECRET_SUBKEY)
216     keyid_from_pk (node->pkt->pkt.public_key, list->kid);
217
218   return list;
219 }
220
221
222 /* Helper function to check whether the subkey at NODE actually
223    matches the description at DESC.  The function returns true if the
224    key under question has been specified by an exact specification
225    (keyID or fingerprint) and does match the one at NODE.  It is
226    assumed that the packet at NODE is either a public or secret
227    subkey. */
228 static int
229 exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, KBNODE node)
230 {
231   u32 kid[2];
232   byte fpr[MAX_FINGERPRINT_LEN];
233   size_t fprlen;
234   int result = 0;
235
236   switch(desc->mode)
237     {
238     case KEYDB_SEARCH_MODE_SHORT_KID:
239     case KEYDB_SEARCH_MODE_LONG_KID:
240       keyid_from_pk (node->pkt->pkt.public_key, kid);
241       break;
242       
243     case KEYDB_SEARCH_MODE_FPR16:
244     case KEYDB_SEARCH_MODE_FPR20:
245     case KEYDB_SEARCH_MODE_FPR:
246       fingerprint_from_pk (node->pkt->pkt.public_key, fpr,&fprlen);
247       break;
248       
249     default:
250       break;
251     }
252   
253   switch(desc->mode)
254     {
255     case KEYDB_SEARCH_MODE_SHORT_KID:
256       if (desc->u.kid[1] == kid[1])
257         result = 1;
258       break;
259
260     case KEYDB_SEARCH_MODE_LONG_KID:
261       if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
262         result = 1;
263       break;
264
265     case KEYDB_SEARCH_MODE_FPR16:
266       if (!memcmp (desc->u.fpr, fpr, 16))
267         result = 1;
268       break;
269
270     case KEYDB_SEARCH_MODE_FPR20:
271     case KEYDB_SEARCH_MODE_FPR:
272       if (!memcmp (desc->u.fpr, fpr, 20))
273         result = 1;
274       break;
275
276     default:
277       break;
278     }
279
280   return result;
281 }
282
283
284 /* Return a canonicalized public key algoithms.  This is used to
285    compare different flavors of algorithms (e.g. ELG and ELG_E are
286    considered the same).  */
287 static int
288 canon_pubkey_algo (int algo)
289 {
290   switch (algo)
291     {
292     case GCRY_PK_RSA:
293     case GCRY_PK_RSA_E:
294     case GCRY_PK_RSA_S: return GCRY_PK_RSA;
295     case GCRY_PK_ELG:   
296     case GCRY_PK_ELG_E: return GCRY_PK_ELG;
297     default: return algo;
298     }
299 }
300
301
302 /* Use the key transfer format given in S_PGP to create the secinfo
303    structure in PK and chnage the parameter array in PK to include the
304    secret parameters.  */
305 static gpg_error_t
306 transfer_format_to_openpgp (gcry_sexp_t s_pgp, PKT_public_key *pk)
307 {
308   gpg_error_t err;
309   gcry_sexp_t top_list;
310   gcry_sexp_t list = NULL;
311   const char *value;
312   size_t valuelen;
313   char *string;
314   int  idx;
315   int  is_v4, is_protected;
316   int  pubkey_algo;
317   int  protect_algo = 0;
318   char iv[16];
319   int  ivlen = 0;
320   int  s2k_mode = 0;
321   int  s2k_algo = 0;
322   byte s2k_salt[8];
323   u32  s2k_count = 0;
324   size_t npkey, nskey;
325   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
326   u16 desired_csum;
327   int skeyidx = 0;
328   struct seckey_info *ski;
329
330   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
331   if (!top_list)
332     goto bad_seckey;
333
334   list = gcry_sexp_find_token (top_list, "version", 0);
335   if (!list)
336     goto bad_seckey;
337   value = gcry_sexp_nth_data (list, 1, &valuelen);
338   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
339     goto bad_seckey;
340   is_v4 = (value[0] == '4');
341
342   gcry_sexp_release (list);
343   list = gcry_sexp_find_token (top_list, "protection", 0);
344   if (!list)
345     goto bad_seckey;
346   value = gcry_sexp_nth_data (list, 1, &valuelen);
347   if (!value)
348     goto bad_seckey;
349   if (valuelen == 4 && !memcmp (value, "sha1", 4))
350     is_protected = 2;
351   else if (valuelen == 3 && !memcmp (value, "sum", 3))
352     is_protected = 1;
353   else if (valuelen == 4 && !memcmp (value, "none", 4))
354     is_protected = 0;
355   else
356     goto bad_seckey;
357   if (is_protected)
358     {
359       string = gcry_sexp_nth_string (list, 2);
360       if (!string)
361         goto bad_seckey;
362       protect_algo = gcry_cipher_map_name (string);
363       xfree (string);
364       
365       value = gcry_sexp_nth_data (list, 3, &valuelen);
366       if (!value || !valuelen || valuelen > sizeof iv)
367         goto bad_seckey;
368       memcpy (iv, value, valuelen);
369       ivlen = valuelen;
370
371       string = gcry_sexp_nth_string (list, 4);
372       if (!string)
373         goto bad_seckey;
374       s2k_mode = strtol (string, NULL, 10);
375       xfree (string);
376
377       string = gcry_sexp_nth_string (list, 5);
378       if (!string)
379         goto bad_seckey;
380       s2k_algo = gcry_md_map_name (string);
381       xfree (string);
382
383       value = gcry_sexp_nth_data (list, 6, &valuelen);
384       if (!value || !valuelen || valuelen > sizeof s2k_salt)
385         goto bad_seckey;
386       memcpy (s2k_salt, value, valuelen);
387
388       string = gcry_sexp_nth_string (list, 7);
389       if (!string)
390         goto bad_seckey;
391       s2k_count = strtoul (string, NULL, 10);
392       xfree (string);
393     }
394
395   gcry_sexp_release (list);
396   list = gcry_sexp_find_token (top_list, "algo", 0);
397   if (!list)
398     goto bad_seckey;
399   string = gcry_sexp_nth_string (list, 1);
400   if (!string)
401     goto bad_seckey;
402   pubkey_algo = gcry_pk_map_name (string);
403   xfree (string);
404
405   if (gcry_pk_algo_info (pubkey_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
406       || gcry_pk_algo_info (pubkey_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
407       || !npkey || npkey >= nskey || nskey > PUBKEY_MAX_NSKEY)
408     goto bad_seckey;
409
410   gcry_sexp_release (list);
411   list = gcry_sexp_find_token (top_list, "skey", 0);
412   if (!list)
413     goto bad_seckey;
414   for (idx=0;;)
415     {
416       int is_enc;
417
418       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
419       if (!value && skeyidx >= npkey)
420         break;  /* Ready.  */
421
422       /* Check for too many parameters.  Note that depending on the
423          protection mode and version number we may see less than NSKEY
424          (but at least NPKEY+1) parameters.  */
425       if (idx >= 2*nskey)
426         goto bad_seckey;
427       if (skeyidx >= DIM (skey)-1)
428         goto bad_seckey;
429
430       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
431         goto bad_seckey;
432       is_enc = (value[0] == 'e');
433       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
434       if (!value || !valuelen)
435         goto bad_seckey;
436       if (is_enc)
437         {
438           void *p = xtrymalloc (valuelen);
439           if (!p)
440             goto outofmem;
441           memcpy (p, value, valuelen);
442           skey[skeyidx] = gcry_mpi_set_opaque (NULL, p, valuelen*8);
443           if (!skey[skeyidx])
444             goto outofmem;
445         }
446       else
447         {
448           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
449                              value, valuelen, NULL))
450             goto bad_seckey;
451         }
452       skeyidx++;
453     }
454   skey[skeyidx++] = NULL;
455
456   gcry_sexp_release (list);
457   list = gcry_sexp_find_token (top_list, "csum", 0);
458   if (list)
459     {
460       string = gcry_sexp_nth_string (list, 1);
461       if (!string)
462         goto bad_seckey;
463       desired_csum = strtoul (string, NULL, 10);
464       xfree (string);
465     }
466   else
467     desired_csum = 0;
468
469
470   gcry_sexp_release (list); list = NULL;
471   gcry_sexp_release (top_list); top_list = NULL;
472
473   /* log_debug ("XXX is_v4=%d\n", is_v4); */
474   /* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
475   /* log_debug ("XXX is_protected=%d\n", is_protected); */
476   /* log_debug ("XXX protect_algo=%d\n", protect_algo); */
477   /* log_printhex ("XXX iv", iv, ivlen); */
478   /* log_debug ("XXX ivlen=%d\n", ivlen); */
479   /* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
480   /* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
481   /* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
482   /* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
483   /* for (idx=0; skey[idx]; idx++) */
484   /*   { */
485   /*     int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
486   /*     log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
487   /*     if (is_enc) */
488   /*       { */
489   /*         void *p; */
490   /*         unsigned int nbits; */
491   /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
492   /*         log_printhex (NULL, p, (nbits+7)/8); */
493   /*       } */
494   /*     else */
495   /*       gcry_mpi_dump (skey[idx]); */
496   /*     log_printf ("\n"); */
497   /*   } */
498
499   if (!is_v4 || is_protected != 2 )
500     {
501       /* We only support the v4 format and a SHA-1 checksum.  */
502       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
503       goto leave;
504     }
505
506   /* Do some sanity checks.  */
507   if (s2k_count <= 1024)
508     {
509       /* The count must be larger so that encode_s2k_iterations does
510          not fall into a backward compatibility mode.  */
511       err = gpg_error (GPG_ERR_INV_DATA);
512       goto leave;
513     }
514   if (canon_pubkey_algo (pubkey_algo) != canon_pubkey_algo (pk->pubkey_algo))
515     {
516       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
517       goto leave;
518     }
519   err = openpgp_cipher_test_algo (protect_algo);
520   if (err)
521     goto leave;
522   err = openpgp_md_test_algo (s2k_algo);
523   if (err)
524     goto leave;
525   
526   /* Check that the public key parameters match.  */
527   for (idx=0; idx < npkey; idx++)
528     if (gcry_mpi_get_flag (pk->pkey[idx], GCRYMPI_FLAG_OPAQUE)
529         || gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE)
530         || gcry_mpi_cmp (pk->pkey[idx], skey[idx]))
531       {
532         err = gpg_error (GPG_ERR_BAD_PUBKEY);
533         goto leave;
534       }
535
536   /* Check that the first secret key parameter in SKEY is encrypted
537      and that there are no more secret key parameters.  The latter is
538      guaranteed by the v4 packet format.  */
539   if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE))
540     goto bad_seckey;
541   if (npkey+1 < DIM (skey) && skey[npkey+1])
542     goto bad_seckey;
543
544   /* Check that the secret key parameters in PK are all set to NULL. */
545   for (idx=npkey; idx < nskey; idx++)
546     if (pk->pkey[idx])
547       goto bad_seckey;
548
549   /* Now build the protection info. */
550   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
551   if (!ski)
552     {
553       err = gpg_error_from_syserror ();
554       goto leave;
555     }
556   
557   ski->is_protected = 1;
558   ski->sha1chk = 1;
559   ski->algo = protect_algo;
560   ski->s2k.mode = s2k_mode;
561   ski->s2k.hash_algo = s2k_algo;
562   assert (sizeof ski->s2k.salt == sizeof s2k_salt);
563   memcpy (ski->s2k.salt, s2k_salt, sizeof s2k_salt);
564   ski->s2k.count = encode_s2k_iterations (s2k_count);
565   assert (ivlen <= sizeof ski->iv);
566   memcpy (ski->iv, iv, ivlen);
567   ski->ivlen = ivlen;
568
569   /* Store the protected secret key parameter.  */
570   pk->pkey[npkey] = skey[npkey];
571   skey[npkey] = NULL;
572
573   /* That's it.  */
574
575  leave:
576   gcry_sexp_release (list);
577   gcry_sexp_release (top_list);
578   for (idx=0; idx < skeyidx; idx++)
579     gcry_mpi_release (skey[idx]);
580   return err;
581
582  bad_seckey:
583   err = gpg_error (GPG_ERR_BAD_SECKEY);
584   goto leave;
585   
586  outofmem:
587   err = gpg_error (GPG_ERR_ENOMEM);
588   goto leave;
589 }
590
591 /* Export the keys identified by the list of strings in USERS to the
592    stream OUT.  If Secret is false public keys will be exported.  With
593    secret true secret keys will be exported; in this case 1 means the
594    entire secret keyblock and 2 only the subkeys.  OPTIONS are the
595    export options to apply.  If KEYBLOCK_OUT is not NULL, AND the exit
596    code is zero, a pointer to the first keyblock found and exported
597    will be stored at this address; no other keyblocks are exported in
598    this case.  The caller must free it the returned keyblock.  If any
599    key has been exported true is stored at ANY. */
600 static int
601 do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
602                   kbnode_t *keyblock_out, unsigned int options, int *any)
603 {
604   gpg_error_t err = 0;
605   PACKET pkt;
606   KBNODE keyblock = NULL;
607   KBNODE kbctx, node;
608   size_t ndesc, descindex;
609   KEYDB_SEARCH_DESC *desc = NULL;
610   subkey_list_t subkey_list = NULL;  /* Track already processed subkeys. */
611   KEYDB_HANDLE kdbhd;
612   strlist_t sl;
613   int indent = 0;
614   gcry_cipher_hd_t cipherhd = NULL;
615
616   *any = 0;
617   init_packet (&pkt);
618   kdbhd = keydb_new ();
619
620   if (!users) 
621     {
622       ndesc = 1;
623       desc = xcalloc (ndesc, sizeof *desc);
624       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
625     }
626   else
627     {
628       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++) 
629         ;
630       desc = xmalloc ( ndesc * sizeof *desc);
631         
632       for (ndesc=0, sl=users; sl; sl = sl->next)
633         {
634           if (!(err=classify_user_id (sl->d, desc+ndesc)))
635             ndesc++;
636           else
637             log_error (_("key \"%s\" not found: %s\n"),
638                        sl->d, gpg_strerror (err));
639         }
640
641       /* It would be nice to see which of the given users did actually
642          match one in the keyring.  To implement this we need to have
643          a found flag for each entry in desc.  To set this flag we
644          must check all those entries after a match to mark all
645          matched one - currently we stop at the first match.  To do
646          this we need an extra flag to enable this feature.  */
647     }
648
649 #ifdef ENABLE_SELINUX_HACKS
650   if (secret)
651     {
652       log_error (_("exporting secret keys not allowed\n"));
653       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
654       goto leave;
655     }
656 #endif
657   
658   /* For secret key export we need to setup a decryption context.  */
659   if (secret)
660     {
661       void *kek = NULL;
662       size_t keklen;
663
664       err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
665       if (err)
666         {
667           log_error ("error getting the KEK: %s\n", gpg_strerror (err));
668           goto leave;
669         }
670       
671       /* Prepare a cipher context.  */
672       err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
673                               GCRY_CIPHER_MODE_AESWRAP, 0);
674       if (!err)
675         err = gcry_cipher_setkey (cipherhd, kek, keklen);
676       if (err)
677         {
678           log_error ("error setting up an encryption context: %s\n",
679                      gpg_strerror (err));
680           goto leave;
681         }
682       xfree (kek);
683       kek = NULL;
684     }
685
686   while (!(err = keydb_search2 (kdbhd, desc, ndesc, &descindex))) 
687     {
688       int skip_until_subkey = 0;
689       u32 keyid[2];
690       PKT_public_key *pk;
691
692       if (!users) 
693         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
694
695       /* Read the keyblock. */
696       release_kbnode (keyblock);
697       keyblock = NULL;
698       err = keydb_get_keyblock (kdbhd, &keyblock);
699       if (err) 
700         {
701           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
702           goto leave;
703         }
704
705       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
706       if (!node)
707         {
708           log_error ("public key packet not found in keyblock - skipped\n");
709           continue;
710         }
711       pk = node->pkt->pkt.public_key;
712       keyid_from_pk (pk, keyid);
713
714       /* If a secret key export is required we need to check whether
715          we have a secret key at all and if so create the seckey_info
716          structure.  */
717       if (secret)
718         {
719           if (agent_probe_any_secret_key (ctrl, keyblock))
720             continue;  /* No secret key (neither primary nor subkey).  */
721
722           /* No v3 keys with GNU mode 1001. */
723           if (secret == 2 && pk->version == 3)
724             {
725               log_info (_("key %s: PGP 2.x style key - skipped\n"),
726                         keystr (keyid));
727               continue;
728             }
729
730           /* The agent does not yet allow to export v3 packets.  It is
731              actually questionable whether we should allow them at
732              all.  */
733           if (pk->version == 3)
734             {
735               log_info ("key %s: PGP 2.x style key (v3) export "
736                         "not yet supported - skipped\n", keystr (keyid));
737               continue;
738             }
739         }
740
741       /* Always do the cleaning on the public key part if requested.
742          Note that we don't yet set this option if we are exporting
743          secret keys.  Note that both export-clean and export-minimal
744          only apply to UID sigs (0x10, 0x11, 0x12, and 0x13).  A
745          designated revocation is never stripped, even with
746          export-minimal set.  */
747       if ((options & EXPORT_CLEAN))
748         clean_key (keyblock, opt.verbose, (options&EXPORT_MINIMAL), NULL, NULL);
749
750       /* And write it. */
751       for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); ) 
752         {
753           if (skip_until_subkey)
754             {
755               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
756                 skip_until_subkey = 0;
757               else
758                 continue;
759             }
760
761           /* We used to use comment packets, but not any longer.  In
762              case we still have comments on a key, strip them here
763              before we call build_packet(). */
764           if (node->pkt->pkttype == PKT_COMMENT)
765             continue;
766
767           /* Make sure that ring_trust packets never get exported. */
768           if (node->pkt->pkttype == PKT_RING_TRUST)
769             continue;
770
771           /* If exact is set, then we only export what was requested
772              (plus the primary key, if the user didn't specifically
773              request it). */
774           if (desc[descindex].exact
775               && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
776             {
777               if (!exact_subkey_match_p (desc+descindex, node))
778                 {
779                   /* Before skipping this subkey, check whether any
780                      other description wants an exact match on a
781                      subkey and include that subkey into the output
782                      too.  Need to add this subkey to a list so that
783                      it won't get processed a second time.
784                    
785                      So the first step here is to check that list and
786                      skip in any case if the key is in that list.
787
788                      We need this whole mess because the import
789                      function of GnuPG < 2.1 is not able to merge
790                      secret keys and thus it is useless to output them
791                      as two separate keys and have import merge them.  */
792                   if (subkey_in_list_p (subkey_list, node))  
793                     skip_until_subkey = 1; /* Already processed this one. */
794                   else
795                     {
796                       size_t j;
797
798                       for (j=0; j < ndesc; j++)
799                         if (j != descindex && desc[j].exact
800                             && exact_subkey_match_p (desc+j, node))
801                           break;
802                       if (!(j < ndesc))
803                         skip_until_subkey = 1; /* No other one matching. */ 
804                     }
805                 }
806
807               if(skip_until_subkey)
808                 continue;
809
810               /* Mark this one as processed. */
811               {
812                 subkey_list_t tmp = new_subkey_list_item (node);
813                 tmp->next = subkey_list;
814                 subkey_list = tmp;
815               }
816             }
817
818           if (node->pkt->pkttype == PKT_SIGNATURE)
819             {
820               /* Do not export packets which are marked as not
821                  exportable.  */
822               if (!(options&EXPORT_LOCAL_SIGS)
823                   && !node->pkt->pkt.signature->flags.exportable)
824                 continue; /* not exportable */
825
826               /* Do not export packets with a "sensitive" revocation
827                  key unless the user wants us to.  Note that we do
828                  export these when issuing the actual revocation
829                  (see revoke.c). */
830               if (!(options&EXPORT_SENSITIVE_REVKEYS)
831                   && node->pkt->pkt.signature->revkey)
832                 {
833                   int i;
834                   
835                   for (i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
836                     if ( (node->pkt->pkt.signature->revkey[i]->class & 0x40))
837                       break;
838
839                   if (i < node->pkt->pkt.signature->numrevkeys)
840                     continue;
841                 }
842             }
843
844           /* Don't export attribs? */
845           if (!(options&EXPORT_ATTRIBUTES)
846               && node->pkt->pkttype == PKT_USER_ID
847               && node->pkt->pkt.user_id->attrib_data )
848             {
849               /* Skip until we get to something that is not an attrib
850                  or a signature on an attrib */
851               while (kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE)
852                 kbctx = kbctx->next;
853  
854               continue;
855             }
856
857           if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
858                          || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
859             {
860               u32 subkidbuf[2], *subkid;
861               char *hexgrip, *serialno;
862               
863               pk = node->pkt->pkt.public_key;
864               if (node->pkt->pkttype == PKT_PUBLIC_KEY)
865                 subkid = NULL;
866               else
867                 {
868                   keyid_from_pk (pk, subkidbuf);
869                   subkid = subkidbuf;
870                 }
871
872               if (pk->seckey_info)
873                 {
874                   log_error ("key %s: oops: seckey_info already set"
875                              " - skipped\n", keystr_with_sub (keyid, subkid));
876                   skip_until_subkey = 1;
877                   continue;
878                 }
879               
880               err = hexkeygrip_from_pk (pk, &hexgrip);
881               if (err)
882                 {
883                   log_error ("key %s: error computing keygrip: %s"
884                              " - skipped\n", keystr_with_sub (keyid, subkid),
885                              gpg_strerror (err));
886                   skip_until_subkey = 1;
887                   err = 0;
888                   continue;
889                 }
890
891               if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
892                 {
893                   /* We are asked not to export the secret parts of
894                      the primary key.  Make up an error code to create
895                      the stub.  */
896                   err = GPG_ERR_NOT_FOUND;
897                   serialno = NULL;
898                 }
899               else
900                 err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
901
902               if ((!err && serialno)
903                   && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
904                 {
905                   /* It does not make sense to export a key with its
906                      primary key on card using a non-key stub.  Thus
907                      we skip those keys when used with
908                      --export-secret-subkeys. */
909                   log_info (_("key %s: key material on-card - skipped\n"),
910                             keystr_with_sub (keyid, subkid));
911                   skip_until_subkey = 1;
912                 }
913               else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
914                        || (!err && serialno))
915                 {
916                   /* Create a key stub.  */
917                   struct seckey_info *ski;
918                   const char *s;
919                   
920                   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
921                   if (!ski)
922                     {
923                       err = gpg_error_from_syserror ();
924                       xfree (hexgrip);
925                       goto leave;
926                     }
927
928                   ski->is_protected = 1;
929                   if (err)
930                     ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
931                   else
932                     {
933                       ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
934                       for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
935                            ski->ivlen++, s += 2)
936                         ski->iv[ski->ivlen] = xtoi_2 (s);
937                     }
938                   
939                   if ((options&EXPORT_SEXP_FORMAT))
940                     err = build_sexp (out, node->pkt, &indent);
941                   else
942                     err = build_packet (out, node->pkt);
943                 }
944               else if (!err)
945                 {
946                   /* FIXME: Move this spaghetti code into a separate
947                      function.  */
948                   unsigned char *wrappedkey = NULL;
949                   size_t wrappedkeylen;
950                   unsigned char *key = NULL;
951                   size_t keylen, realkeylen;
952                   gcry_sexp_t s_skey;
953
954                   if (opt.verbose)
955                     log_info ("key %s: asking agent for the secret parts\n",
956                               keystr_with_sub (keyid, subkid));
957
958                   err = agent_export_key (ctrl, hexgrip, "Key foo", NULL,
959                                           &wrappedkey, &wrappedkeylen);
960                   if (err)
961                     goto unwraperror;
962                   if (wrappedkeylen < 24)
963                     {
964                       err = gpg_error (GPG_ERR_INV_LENGTH);
965                       goto unwraperror;
966                     }
967                   keylen = wrappedkeylen - 8;
968                   key = xtrymalloc_secure (keylen);
969                   if (!key)
970                     {
971                       err = gpg_error_from_syserror ();
972                       goto unwraperror;
973                     }
974                   err = gcry_cipher_decrypt (cipherhd, key, keylen,
975                                              wrappedkey, wrappedkeylen);
976                   if (err)
977                     goto unwraperror;
978                   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
979                   if (!realkeylen)
980                     goto unwraperror; /* Invalid csexp.  */
981                   
982                   err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
983                   xfree (key);
984                   key = NULL;
985                   if (err)
986                     goto unwraperror;
987                   err = transfer_format_to_openpgp (s_skey, pk);
988                   gcry_sexp_release (s_skey);
989                   if (err)
990                     goto unwraperror;
991
992                   if ((options&EXPORT_SEXP_FORMAT))
993                     err = build_sexp (out, node->pkt, &indent);
994                   else
995                     err = build_packet (out, node->pkt);
996                   goto unwraperror_leave;
997
998                 unwraperror:
999                   xfree (wrappedkey);
1000                   xfree (key);
1001                   if (err)
1002                     {
1003                       log_error ("key %s: error receiving key from agent:"
1004                                  " %s%s\n",
1005                                  keystr_with_sub (keyid, subkid),
1006                                  gpg_strerror (err),
1007                                  gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
1008                                  "":_(" - skipped"));
1009                       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1010                         goto leave;
1011                       skip_until_subkey = 1;
1012                       err = 0;
1013                     }
1014                 unwraperror_leave:
1015                   ;
1016                 }
1017               else
1018                 {
1019                   log_error ("key %s: error getting keyinfo from agent: %s"
1020                              " - skipped\n", keystr_with_sub (keyid, subkid),
1021                              gpg_strerror (err));
1022                   skip_until_subkey = 1;
1023                   err = 0;
1024                 }
1025
1026               xfree (pk->seckey_info);
1027               pk->seckey_info = NULL;
1028               xfree (hexgrip);
1029             }
1030           else
1031             {
1032               if ((options&EXPORT_SEXP_FORMAT))
1033                 err = build_sexp (out, node->pkt, &indent);
1034               else
1035                 err = build_packet (out, node->pkt);
1036             }
1037
1038           if (err)
1039             {
1040               log_error ("build_packet(%d) failed: %s\n",
1041                          node->pkt->pkttype, gpg_strerror (err));
1042               goto leave;
1043             }
1044
1045           if (!skip_until_subkey)
1046             *any = 1;
1047         }
1048
1049       if ((options&EXPORT_SEXP_FORMAT) && indent)
1050         {
1051           for (; indent; indent--)
1052             iobuf_put (out, ')');
1053           iobuf_put (out, '\n');
1054         }
1055
1056       if (keyblock_out)
1057         {
1058           *keyblock_out = keyblock;
1059           break;
1060         }
1061     }
1062   if ((options&EXPORT_SEXP_FORMAT) && indent)
1063     {
1064       for (; indent; indent--)
1065         iobuf_put (out, ')');
1066       iobuf_put (out, '\n');
1067     }
1068   if (err == -1)
1069     err = 0;
1070
1071  leave:
1072   gcry_cipher_close (cipherhd);
1073   release_subkey_list (subkey_list);
1074   xfree(desc);
1075   keydb_release (kdbhd);
1076   if (err || !keyblock_out)
1077     release_kbnode( keyblock );
1078   if( !*any )
1079     log_info(_("WARNING: nothing exported\n"));
1080   return err;
1081 }
1082
1083
1084
1085 /* static int */
1086 /* write_sexp_line (iobuf_t out, int *indent, const char *text) */
1087 /* { */
1088 /*   int i; */
1089
1090 /*   for (i=0; i < *indent; i++) */
1091 /*     iobuf_put (out, ' '); */
1092 /*   iobuf_writestr (out, text); */
1093 /*   return 0; */
1094 /* } */
1095
1096 /* static int */
1097 /* write_sexp_keyparm (iobuf_t out, int *indent, const char *name, gcry_mpi_t a) */
1098 /* { */
1099 /*   int rc; */
1100 /*   unsigned char *buffer; */
1101
1102 /*   write_sexp_line (out, indent, "("); */
1103 /*   iobuf_writestr (out, name); */
1104 /*   iobuf_writestr (out, " #"); */
1105
1106 /*   rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a); */
1107 /*   assert (!rc); */
1108 /*   iobuf_writestr (out, buffer); */
1109 /*   iobuf_writestr (out, "#)"); */
1110 /*   gcry_free (buffer); */
1111 /*   return 0; */
1112 /* } */
1113
1114 static int
1115 build_sexp_seckey (iobuf_t out, PACKET *pkt, int *indent)
1116 {
1117   (void)out;
1118   (void)pkt;
1119   (void)indent;
1120
1121   /* FIXME: Not yet implemented.  */
1122   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1123   /* PKT_secret_key *sk = pkt->pkt.secret_key; */
1124   /* char tmpbuf[100]; */
1125
1126   /* if (pkt->pkttype == PKT_SECRET_KEY) */
1127   /*   { */
1128   /*     iobuf_writestr (out, "(openpgp-key\n"); */
1129   /*     (*indent)++; */
1130   /*   } */
1131   /* else */
1132   /*   { */
1133   /*     iobuf_writestr (out, " (subkey\n"); */
1134   /*     (*indent)++; */
1135   /*   } */
1136   /* (*indent)++; */
1137   /* write_sexp_line (out, indent, "(private-key\n"); */
1138   /* (*indent)++; */
1139   /* if (is_RSA (sk->pubkey_algo) && !sk->is_protected) */
1140   /*   { */
1141   /*     write_sexp_line (out, indent, "(rsa\n"); */
1142   /*     (*indent)++; */
1143   /*     write_sexp_keyparm (out, indent, "n", sk->skey[0]); iobuf_put (out,'\n'); */
1144   /*     write_sexp_keyparm (out, indent, "e", sk->skey[1]); iobuf_put (out,'\n'); */
1145   /*     write_sexp_keyparm (out, indent, "d", sk->skey[2]); iobuf_put (out,'\n'); */
1146   /*     write_sexp_keyparm (out, indent, "p", sk->skey[3]); iobuf_put (out,'\n'); */
1147   /*     write_sexp_keyparm (out, indent, "q", sk->skey[4]); iobuf_put (out,'\n'); */
1148   /*     write_sexp_keyparm (out, indent, "u", sk->skey[5]);  */
1149   /*     iobuf_put (out,')'); iobuf_put (out,'\n'); */
1150   /*     (*indent)--; */
1151   /*   } */
1152   /* else if (sk->pubkey_algo == PUBKEY_ALGO_DSA && !sk->is_protected) */
1153   /*   { */
1154   /*     write_sexp_line (out, indent, "(dsa\n"); */
1155   /*     (*indent)++; */
1156   /*     write_sexp_keyparm (out, indent, "p", sk->skey[0]); iobuf_put (out,'\n'); */
1157   /*     write_sexp_keyparm (out, indent, "q", sk->skey[1]); iobuf_put (out,'\n'); */
1158   /*     write_sexp_keyparm (out, indent, "g", sk->skey[2]); iobuf_put (out,'\n'); */
1159   /*     write_sexp_keyparm (out, indent, "y", sk->skey[3]); iobuf_put (out,'\n'); */
1160   /*     write_sexp_keyparm (out, indent, "x", sk->skey[4]); */
1161   /*     iobuf_put (out,')'); iobuf_put (out,'\n'); */
1162   /*     (*indent)--; */
1163   /*   } */
1164   /* else if (is_ELGAMAL (sk->pubkey_algo) && !sk->is_protected) */
1165   /*   { */
1166   /*     write_sexp_line (out, indent, "(elg\n"); */
1167   /*     (*indent)++; */
1168   /*     write_sexp_keyparm (out, indent, "p", sk->skey[0]); iobuf_put (out,'\n'); */
1169   /*     write_sexp_keyparm (out, indent, "g", sk->skey[2]); iobuf_put (out,'\n'); */
1170   /*     write_sexp_keyparm (out, indent, "y", sk->skey[3]); iobuf_put (out,'\n'); */
1171   /*     write_sexp_keyparm (out, indent, "x", sk->skey[4]); */
1172   /*     iobuf_put (out,')'); iobuf_put (out,'\n'); */
1173   /*     (*indent)--; */
1174   /*   } */
1175   /* write_sexp_line (out, indent,  "(attrib\n"); (*indent)++; */
1176   /* sprintf (tmpbuf, "(created \"%lu\"", (unsigned long)sk->timestamp); */
1177   /* write_sexp_line (out, indent, tmpbuf); */
1178   /* iobuf_put (out,')'); (*indent)--; /\* close created *\/ */
1179   /* iobuf_put (out,')'); (*indent)--; /\* close attrib *\/ */
1180   /* iobuf_put (out,')'); (*indent)--; /\* close private-key *\/ */
1181   /* if (pkt->pkttype != PKT_SECRET_KEY) */
1182   /*   iobuf_put (out,')'), (*indent)--; /\* close subkey *\/ */
1183   /* iobuf_put (out,'\n'); */
1184
1185   /* return 0; */
1186 }
1187
1188
1189 /* For some packet types we write them in a S-expression format.  This
1190    is still EXPERIMENTAL and subject to change.  */
1191 static int 
1192 build_sexp (iobuf_t out, PACKET *pkt, int *indent)
1193 {
1194   int rc;
1195
1196   switch (pkt->pkttype)
1197     {
1198     case PKT_SECRET_KEY:
1199     case PKT_SECRET_SUBKEY:
1200       rc = build_sexp_seckey (out, pkt, indent);
1201       break;
1202     default:
1203       rc = 0;
1204       break;
1205     }
1206   return rc;
1207 }