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