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