Switched to GPLv3.
[gnupg.git] / g10 / export.c
1 /* export.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005 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 "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "main.h"
35 #include "i18n.h"
36 #include "trustdb.h"
37
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( STRLIST users, int secret, unsigned int options );
49 static int do_export_stream( IOBUF out, STRLIST users, int secret,
50                              KBNODE *keyblock_out, unsigned int options,
51                              int *any );
52
53 int
54 parse_export_options(char *str,unsigned int *options,int noisy)
55 {
56   struct parse_options export_opts[]=
57     {
58       {"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
59        N_("export signatures that are marked as local-only")},
60       {"export-attributes",EXPORT_ATTRIBUTES,NULL,
61        N_("export attribute user IDs (generally photo IDs)")},
62       {"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
63        N_("export revocation keys marked as \"sensitive\"")},
64       {"export-reset-subkey-passwd",EXPORT_RESET_SUBKEY_PASSWD,NULL,
65        N_("remove the passphrase from exported subkeys")},
66       {"export-clean",EXPORT_CLEAN,NULL,
67        N_("remove unusable parts from key during export")},
68       {"export-minimal",EXPORT_MINIMAL|EXPORT_CLEAN,NULL,
69        N_("remove as much as possible from key during export")},
70       /* Aliases for backward compatibility */
71       {"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
72       {"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
73       {"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
74       /* dummy */
75       {"export-unusable-sigs",0,NULL,NULL},
76       {"export-clean-sigs",0,NULL,NULL},
77       {"export-clean-uids",0,NULL,NULL},
78       {NULL,0,NULL,NULL}
79       /* add tags for include revoked and disabled? */
80     };
81
82   return parse_options(str,options,export_opts,noisy);
83 }
84
85
86 /****************
87  * Export the public keys (to standard out or --output).
88  * Depending on opt.armor the output is armored.
89  * options are defined in main.h.
90  * If USERS is NULL, the complete ring will be exported.  */
91 int
92 export_pubkeys( STRLIST users, unsigned int options )
93 {
94     return do_export( users, 0, options );
95 }
96
97 /****************
98  * Export to an already opened stream; return -1 if no keys have
99  * been exported
100  */
101 int
102 export_pubkeys_stream( IOBUF out, STRLIST users,
103                        KBNODE *keyblock_out, unsigned int options )
104 {
105     int any, rc;
106
107     rc = do_export_stream( out, users, 0, keyblock_out, options, &any );
108     if( !rc && !any )
109         rc = -1;
110     return rc;
111 }
112
113 int
114 export_seckeys( STRLIST users )
115 {
116     return do_export( users, 1, 0 );
117 }
118
119 int
120 export_secsubkeys( STRLIST users )
121 {
122     return do_export( users, 2, 0 );
123 }
124
125 static int
126 do_export( STRLIST users, int secret, unsigned int options )
127 {
128     IOBUF out = NULL;
129     int any, rc;
130     armor_filter_context_t afx;
131     compress_filter_context_t zfx;
132
133     memset( &afx, 0, sizeof afx);
134     memset( &zfx, 0, sizeof zfx);
135
136     rc = open_outfile( NULL, 0, &out );
137     if( rc )
138         return rc;
139
140     if( opt.armor ) {
141         afx.what = secret?5:1;
142         iobuf_push_filter( out, armor_filter, &afx );
143     }
144     if( opt.compress_keys )
145       push_compress_filter(out,&zfx,default_compress_algo());
146
147     rc = do_export_stream( out, users, secret, NULL, options, &any );
148     if( rc || !any )
149         iobuf_cancel(out);
150     else
151         iobuf_close(out);
152     return rc;
153 }
154
155
156
157 /* Release an entire subkey list. */
158 static void
159 release_subkey_list (subkey_list_t list)
160 {
161   while (list)
162     {
163       subkey_list_t tmp = list->next;;
164       xfree (list);
165       list = tmp;
166     }
167 }
168
169
170 /* Returns true if NODE is a subkey and contained in LIST. */
171 static int
172 subkey_in_list_p (subkey_list_t list, KBNODE node)
173 {
174   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
175       || node->pkt->pkttype == PKT_SECRET_SUBKEY )
176     {
177       u32 kid[2];
178
179       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
180         keyid_from_pk (node->pkt->pkt.public_key, kid);
181       else
182         keyid_from_sk (node->pkt->pkt.secret_key, kid);
183       
184       for (; list; list = list->next)
185         if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
186           return 1;
187     }
188   return 0;
189 }
190
191 /* Allocate a new subkey list item from NODE. */
192 static subkey_list_t
193 new_subkey_list_item (KBNODE node)
194 {
195   subkey_list_t list = xcalloc (1, sizeof *list);
196
197   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
198     keyid_from_pk (node->pkt->pkt.public_key, list->kid);
199   else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
200     keyid_from_sk (node->pkt->pkt.secret_key, list->kid);
201
202   return list;
203 }
204
205
206 /* Helper function to check whether the subkey at NODE actually
207    matches the description at DESC.  The function returns true if the
208    key under question has been specified by an exact specification
209    (keyID or fingerprint) and does match the one at NODE.  It is
210    assumed that the packet at NODE is either a public or secret
211    subkey. */
212 static int
213 exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, KBNODE node)
214 {
215   u32 kid[2];
216   byte fpr[MAX_FINGERPRINT_LEN];
217   size_t fprlen;
218   int result = 0;
219
220   switch(desc->mode)
221     {
222     case KEYDB_SEARCH_MODE_SHORT_KID:
223     case KEYDB_SEARCH_MODE_LONG_KID:
224       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
225         keyid_from_pk (node->pkt->pkt.public_key, kid);
226       else
227         keyid_from_sk (node->pkt->pkt.secret_key, kid);
228       break;
229       
230     case KEYDB_SEARCH_MODE_FPR16:
231     case KEYDB_SEARCH_MODE_FPR20:
232     case KEYDB_SEARCH_MODE_FPR:
233       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
234         fingerprint_from_pk (node->pkt->pkt.public_key, fpr,&fprlen);
235       else
236         fingerprint_from_sk (node->pkt->pkt.secret_key, fpr,&fprlen);
237       break;
238       
239     default:
240       break;
241     }
242   
243   switch(desc->mode)
244     {
245     case KEYDB_SEARCH_MODE_SHORT_KID:
246       if (desc->u.kid[1] == kid[1])
247         result = 1;
248       break;
249
250     case KEYDB_SEARCH_MODE_LONG_KID:
251       if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
252         result = 1;
253       break;
254
255     case KEYDB_SEARCH_MODE_FPR16:
256       if (!memcmp (desc->u.fpr, fpr, 16))
257         result = 1;
258       break;
259
260     case KEYDB_SEARCH_MODE_FPR20:
261     case KEYDB_SEARCH_MODE_FPR:
262       if (!memcmp (desc->u.fpr, fpr, 20))
263         result = 1;
264       break;
265
266     default:
267       break;
268     }
269
270   return result;
271 }
272
273
274 /* If keyblock_out is non-NULL, AND the exit code is zero, then it
275    contains a pointer to the first keyblock found and exported.  No
276    other keyblocks are exported.  The caller must free it. */
277 static int
278 do_export_stream( IOBUF out, STRLIST users, int secret,
279                   KBNODE *keyblock_out, unsigned int options, int *any )
280 {
281     int rc = 0;
282     PACKET pkt;
283     KBNODE keyblock = NULL;
284     KBNODE kbctx, node;
285     size_t ndesc, descindex;
286     KEYDB_SEARCH_DESC *desc = NULL;
287     subkey_list_t subkey_list = NULL;  /* Track alreay processed subkeys. */
288     KEYDB_HANDLE kdbhd;
289     STRLIST sl;
290
291     *any = 0;
292     init_packet( &pkt );
293     kdbhd = keydb_new (secret);
294
295     if (!users) {
296         ndesc = 1;
297         desc = xcalloc ( ndesc, sizeof *desc );
298         desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
299     }
300     else {
301         for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++) 
302             ;
303         desc = xmalloc ( ndesc * sizeof *desc);
304         
305         for (ndesc=0, sl=users; sl; sl = sl->next) {
306             if (classify_user_id (sl->d, desc+ndesc))
307                 ndesc++;
308             else
309                 log_error (_("key \"%s\" not found: %s\n"),
310                            sl->d, g10_errstr (G10ERR_INV_USER_ID));
311         }
312
313         /* It would be nice to see which of the given users did
314            actually match one in the keyring.  To implement this we
315            need to have a found flag for each entry in desc and to set
316            this we must check all those entries after a match to mark
317            all matched one - currently we stop at the first match.  To
318            do this we need an extra flag to enable this feature so */
319     }
320
321 #ifdef ENABLE_SELINUX_HACKS
322     if (secret) {
323         log_error (_("exporting secret keys not allowed\n"));
324         rc = G10ERR_GENERAL;
325         goto leave;
326     }
327 #endif
328
329     while (!(rc = keydb_search2 (kdbhd, desc, ndesc, &descindex))) {
330         int sha1_warned=0,skip_until_subkey=0;
331         u32 sk_keyid[2];
332
333         if (!users) 
334             desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
335
336         /* Read the keyblock. */
337         rc = keydb_get_keyblock (kdbhd, &keyblock );
338         if( rc ) {
339             log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
340             goto leave;
341         }
342
343         if((node=find_kbnode(keyblock,PKT_SECRET_KEY)))
344           {
345             PKT_secret_key *sk=node->pkt->pkt.secret_key;
346
347             keyid_from_sk(sk,sk_keyid);
348
349             /* We can't apply GNU mode 1001 on an unprotected key. */
350             if( secret == 2 && !sk->is_protected )
351               {
352                 log_info(_("key %s: not protected - skipped\n"),
353                          keystr(sk_keyid));
354                 continue;
355               }
356
357             /* No v3 keys with GNU mode 1001. */
358             if( secret == 2 && sk->version == 3 )
359               {
360                 log_info(_("key %s: PGP 2.x style key - skipped\n"),
361                          keystr(sk_keyid));
362                 continue;
363               }
364
365             /* It does not make sense to export a key with a primary
366                key on card using a non-key stub.  We simply skip those
367                keys when used with --export-secret-subkeys. */
368             if (secret == 2 && sk->is_protected
369                 && sk->protect.s2k.mode == 1002 ) 
370               {
371                 log_info(_("key %s: key material on-card - skipped\n"),
372                          keystr(sk_keyid));
373                 continue;
374               }
375           }
376         else
377           {
378             /* It's a public key export, so do the cleaning if
379                requested.  Note that both export-clean and
380                export-minimal only apply to UID sigs (0x10, 0x11,
381                0x12, and 0x13).  A designated revocation is never
382                stripped, even with export-minimal set. */
383
384             if(options&EXPORT_CLEAN)
385               clean_key(keyblock,opt.verbose,options&EXPORT_MINIMAL,NULL,NULL);
386           }
387
388         /* And write it. */
389         for( kbctx=NULL; (node = walk_kbnode( keyblock, &kbctx, 0 )); ) {
390             if( skip_until_subkey )
391               {
392                 if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY
393                    || node->pkt->pkttype==PKT_SECRET_SUBKEY)
394                   skip_until_subkey=0;
395                 else
396                   continue;
397               }
398
399             /* We used to use comment packets, but not any longer.  In
400                case we still have comments on a key, strip them here
401                before we call build_packet(). */
402             if( node->pkt->pkttype == PKT_COMMENT )
403               continue;
404
405             /* Make sure that ring_trust packets never get exported. */
406             if (node->pkt->pkttype == PKT_RING_TRUST)
407               continue;
408
409             /* If exact is set, then we only export what was requested
410                (plus the primary key, if the user didn't specifically
411                request it). */
412             if(desc[descindex].exact
413                && (node->pkt->pkttype==PKT_PUBLIC_SUBKEY
414                    || node->pkt->pkttype==PKT_SECRET_SUBKEY))
415               {
416                 if (!exact_subkey_match_p (desc+descindex, node))
417                   {
418                     /* Before skipping this subkey, check whether any
419                        other description wants an exact match on a
420                        subkey and include that subkey into the output
421                        too.  Need to add this subkey to a list so that
422                        it won't get processed a second time.
423                    
424                        So the first step here is to check that list and
425                        skip in any case if the key is in that list.
426
427                        We need this whole mess because the import
428                        function is not able to merge secret keys and
429                        thus it is useless to output them as two
430                        separate keys and have import merge them.  */
431                     if (subkey_in_list_p (subkey_list, node))  
432                       skip_until_subkey = 1; /* Already processed this one. */
433                     else
434                       {
435                         size_t j;
436
437                         for (j=0; j < ndesc; j++)
438                           if (j != descindex && desc[j].exact
439                               && exact_subkey_match_p (desc+j, node))
440                             break;
441                         if (!(j < ndesc))
442                           skip_until_subkey = 1; /* No other one matching. */ 
443                       }
444                   }
445
446                 if(skip_until_subkey)
447                   continue;
448
449                 /* Mark this one as processed. */
450                 {
451                   subkey_list_t tmp = new_subkey_list_item (node);
452                   tmp->next = subkey_list;
453                   subkey_list = tmp;
454                 }
455               }
456
457             if(node->pkt->pkttype==PKT_SIGNATURE)
458               {
459                 /* do not export packets which are marked as not
460                    exportable */
461                 if(!(options&EXPORT_LOCAL_SIGS)
462                    && !node->pkt->pkt.signature->flags.exportable)
463                   continue; /* not exportable */
464
465                 /* Do not export packets with a "sensitive" revocation
466                    key unless the user wants us to.  Note that we do
467                    export these when issuing the actual revocation
468                    (see revoke.c). */
469                 if(!(options&EXPORT_SENSITIVE_REVKEYS)
470                    && node->pkt->pkt.signature->revkey)
471                   {
472                     int i;
473
474                     for(i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
475                       if(node->pkt->pkt.signature->revkey[i]->class & 0x40)
476                         break;
477
478                     if(i<node->pkt->pkt.signature->numrevkeys)
479                       continue;
480                   }
481               }
482
483             /* Don't export attribs? */
484             if( !(options&EXPORT_ATTRIBUTES) &&
485                 node->pkt->pkttype == PKT_USER_ID &&
486                 node->pkt->pkt.user_id->attrib_data ) {
487               /* Skip until we get to something that is not an attrib
488                  or a signature on an attrib */
489               while(kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE) {
490                 kbctx=kbctx->next;
491               }
492  
493               continue;
494             }
495
496             if( secret == 2 && node->pkt->pkttype == PKT_SECRET_KEY )
497               {
498                 /* We don't want to export the secret parts of the
499                  * primary key, this is done by using GNU protection mode 1001
500                  */
501                 int save_mode = node->pkt->pkt.secret_key->protect.s2k.mode;
502                 node->pkt->pkt.secret_key->protect.s2k.mode = 1001;
503                 rc = build_packet( out, node->pkt );
504                 node->pkt->pkt.secret_key->protect.s2k.mode = save_mode;
505               }
506             else if (secret == 2 && node->pkt->pkttype == PKT_SECRET_SUBKEY
507                      && (opt.export_options&EXPORT_RESET_SUBKEY_PASSWD))
508               {
509                 /* If the subkey is protected reset the passphrase to
510                    export an unprotected subkey.  This feature is
511                    useful in cases of a subkey copied to an unattended
512                    machine where a passphrase is not required. */
513                 PKT_secret_key *sk_save, *sk;
514
515                 sk_save = node->pkt->pkt.secret_key;
516                 sk = copy_secret_key (NULL, sk_save);
517                 node->pkt->pkt.secret_key = sk;
518
519                 log_info (_("about to export an unprotected subkey\n"));
520                 switch (is_secret_key_protected (sk))
521                   {
522                   case -1:
523                     rc = G10ERR_PUBKEY_ALGO;
524                     break;
525                   case 0:
526                     break;
527                   default:
528                     if (sk->protect.s2k.mode == 1001)
529                       ; /* No secret parts. */
530                     else if( sk->protect.s2k.mode == 1002 ) 
531                       ; /* Card key stub. */
532                     else 
533                       {
534                         rc = check_secret_key( sk, 0 );
535                       }
536                     break;
537                   }
538                 if (rc)
539                   {
540                     node->pkt->pkt.secret_key = sk_save;
541                     free_secret_key (sk);
542                     log_error (_("failed to unprotect the subkey: %s\n"),
543                                g10_errstr (rc));
544                     goto leave;
545                   }
546
547                 rc = build_packet (out, node->pkt);
548
549                 node->pkt->pkt.secret_key = sk_save;
550                 free_secret_key (sk);
551               }
552             else
553               {
554                 /* Warn the user if the secret key or any of the secret
555                    subkeys are protected with SHA1 and we have
556                    simple_sk_checksum set. */
557                 if(!sha1_warned && opt.simple_sk_checksum &&
558                    (node->pkt->pkttype==PKT_SECRET_KEY ||
559                     node->pkt->pkttype==PKT_SECRET_SUBKEY) &&
560                    node->pkt->pkt.secret_key->protect.sha1chk)
561                   {
562                     /* I hope this warning doesn't confuse people. */
563                     log_info(_("WARNING: secret key %s does not have a "
564                                "simple SK checksum\n"),keystr(sk_keyid));
565
566                     sha1_warned=1;
567                   }
568
569                 rc = build_packet( out, node->pkt );
570               }
571
572             if( rc ) {
573                 log_error("build_packet(%d) failed: %s\n",
574                             node->pkt->pkttype, g10_errstr(rc) );
575                 rc = G10ERR_WRITE_FILE;
576                 goto leave;
577             }
578         }
579         ++*any;
580         if(keyblock_out)
581           {
582             *keyblock_out=keyblock;
583             break;
584           }
585     }
586     if( rc == -1 )
587         rc = 0;
588
589   leave:
590     release_subkey_list (subkey_list);
591     xfree(desc);
592     keydb_release (kdbhd);
593     if(rc || keyblock_out==NULL)
594       release_kbnode( keyblock );
595     if( !*any )
596         log_info(_("WARNING: nothing exported\n"));
597     return rc;
598 }