* import.c (import_one): Do collapse_uids() before we do any cleaning
[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_("export the smallest key possible")},
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     u32 keyid[2];
297
298     *any = 0;
299     init_packet( &pkt );
300     kdbhd = keydb_new (secret);
301
302     if (!users) {
303         ndesc = 1;
304         desc = xcalloc ( ndesc, sizeof *desc );
305         desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
306     }
307     else {
308         for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++) 
309             ;
310         desc = xmalloc ( ndesc * sizeof *desc);
311         
312         for (ndesc=0, sl=users; sl; sl = sl->next) {
313             if (classify_user_id (sl->d, desc+ndesc))
314                 ndesc++;
315             else
316                 log_error (_("key \"%s\" not found: %s\n"),
317                            sl->d, g10_errstr (G10ERR_INV_USER_ID));
318         }
319
320         /* It would be nice to see which of the given users did
321            actually match one in the keyring.  To implement this we
322            need to have a found flag for each entry in desc and to set
323            this we must check all those entries after a match to mark
324            all matched one - currently we stop at the first match.  To
325            do this we need an extra flag to enable this feature so */
326     }
327
328 #ifdef ENABLE_SELINUX_HACKS
329     if (secret) {
330         log_error (_("exporting secret keys not allowed\n"));
331         rc = G10ERR_GENERAL;
332         goto leave;
333     }
334 #endif
335
336     while (!(rc = keydb_search2 (kdbhd, desc, ndesc, &descindex))) {
337         int sha1_warned=0,skip_until_subkey=0;
338         u32 sk_keyid[2];
339
340         if (!users) 
341             desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
342
343         /* Read the keyblock. */
344         rc = keydb_get_keyblock (kdbhd, &keyblock );
345         if( rc ) {
346             log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
347             goto leave;
348         }
349
350         if((node=find_kbnode(keyblock,PKT_SECRET_KEY)))
351           {
352             PKT_secret_key *sk=node->pkt->pkt.secret_key;
353
354             keyid_from_sk(sk,sk_keyid);
355
356             /* We can't apply GNU mode 1001 on an unprotected key. */
357             if( secret == 2 && !sk->is_protected )
358               {
359                 log_info(_("key %s: not protected - skipped\n"),
360                          keystr(sk_keyid));
361                 continue;
362               }
363
364             /* No v3 keys with GNU mode 1001. */
365             if( secret == 2 && sk->version == 3 )
366               {
367                 log_info(_("key %s: PGP 2.x style key - skipped\n"),
368                          keystr(sk_keyid));
369                 continue;
370               }
371
372             /* It does not make sense to export a key with a primary
373                key on card using a non-key stub.  We simply skip those
374                keys when used with --export-secret-subkeys. */
375             if (secret == 2 && sk->is_protected
376                 && sk->protect.s2k.mode == 1002 ) 
377               {
378                 log_info(_("key %s: key material on-card - skipped\n"),
379                          keystr(sk_keyid));
380                 continue;
381               }
382           }
383         else
384           {
385             /* It's a public key export. */
386             if((options&EXPORT_MINIMAL)
387                && (node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
388               keyid_from_pk(node->pkt->pkt.public_key,keyid);
389
390             if(options&EXPORT_CLEAN_UIDS)
391               clean_uids_from_key(keyblock,opt.verbose);
392           }
393
394         /* And write it. */
395         for( kbctx=NULL; (node = walk_kbnode( keyblock, &kbctx, 0 )); ) {
396             if( skip_until_subkey )
397               {
398                 if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY
399                    || node->pkt->pkttype==PKT_SECRET_SUBKEY)
400                   skip_until_subkey=0;
401                 else
402                   continue;
403               }
404
405             /* We used to use comment packets, but not any longer.  In
406                case we still have comments on a key, strip them here
407                before we call build_packet(). */
408             if( node->pkt->pkttype == PKT_COMMENT )
409               continue;
410
411             /* Make sure that ring_trust packets never get exported. */
412             if (node->pkt->pkttype == PKT_RING_TRUST)
413               continue;
414
415             /* If exact is set, then we only export what was requested
416                (plus the primary key, if the user didn't specifically
417                request it). */
418             if(desc[descindex].exact
419                && (node->pkt->pkttype==PKT_PUBLIC_SUBKEY
420                    || node->pkt->pkttype==PKT_SECRET_SUBKEY))
421               {
422                 if (!exact_subkey_match_p (desc+descindex, node))
423                   {
424                     /* Before skipping this subkey, check whether any
425                        other description wants an exact match on a
426                        subkey and include that subkey into the output
427                        too.  Need to add this subkey to a list so that
428                        it won't get processed a second time.
429                    
430                        So the first step here is to check that list and
431                        skip in any case if the key is in that list.
432
433                        We need this whole mess because the import
434                        function is not able to merge secret keys and
435                        thus it is useless to output them as two
436                        separate keys and have import merge them.  */
437                     if (subkey_in_list_p (subkey_list, node))  
438                       skip_until_subkey = 1; /* Already processed this one. */
439                     else
440                       {
441                         size_t j;
442
443                         for (j=0; j < ndesc; j++)
444                           if (j != descindex && desc[j].exact
445                               && exact_subkey_match_p (desc+j, node))
446                             break;
447                         if (!(j < ndesc))
448                           skip_until_subkey = 1; /* No other one matching. */ 
449                       }
450                   }
451
452                 if(skip_until_subkey)
453                   continue;
454
455                 /* Mark this one as processed. */
456                 {
457                   subkey_list_t tmp = new_subkey_list_item (node);
458                   tmp->next = subkey_list;
459                   subkey_list = tmp;
460                 }
461               }
462
463
464             if(node->pkt->pkttype==PKT_USER_ID)
465               {
466                 /* Run clean_sigs_from_uid against each uid if
467                    export-clean-sigs is on. */
468                 if(options&EXPORT_CLEAN_SIGS)
469                   clean_sigs_from_uid(keyblock,node,opt.verbose);
470               }
471             else if(node->pkt->pkttype==PKT_SIGNATURE)
472               {
473                 /* If we have export-minimal turned on, do not include
474                    any signature that isn't a selfsig.  Note that this
475                    only applies to uid sigs (0x10, 0x11, 0x12, and
476                    0x13).  A designated revocation is not stripped. */
477                 if((options&EXPORT_MINIMAL)
478                    && IS_UID_SIG(node->pkt->pkt.signature)
479                    && (node->pkt->pkt.signature->keyid[0]!=keyid[0]
480                        || node->pkt->pkt.signature->keyid[1]!=keyid[1]))
481                   continue;
482
483                 /* do not export packets which are marked as not
484                    exportable */
485                 if(!(options&EXPORT_LOCAL_SIGS)
486                    && !node->pkt->pkt.signature->flags.exportable)
487                   continue; /* not exportable */
488
489                 /* Do not export packets with a "sensitive" revocation
490                    key unless the user wants us to.  Note that we do
491                    export these when issuing the actual revocation
492                    (see revoke.c). */
493                 if(!(options&EXPORT_SENSITIVE_REVKEYS)
494                    && node->pkt->pkt.signature->revkey)
495                   {
496                     int i;
497
498                     for(i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
499                       if(node->pkt->pkt.signature->revkey[i]->class & 0x40)
500                         break;
501
502                     if(i<node->pkt->pkt.signature->numrevkeys)
503                       continue;
504                   }
505               }
506
507             /* Don't export attribs? */
508             if( !(options&EXPORT_ATTRIBUTES) &&
509                 node->pkt->pkttype == PKT_USER_ID &&
510                 node->pkt->pkt.user_id->attrib_data ) {
511               /* Skip until we get to something that is not an attrib
512                  or a signature on an attrib */
513               while(kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE) {
514                 kbctx=kbctx->next;
515               }
516  
517               continue;
518             }
519
520             if( secret == 2 && node->pkt->pkttype == PKT_SECRET_KEY )
521               {
522                 /* We don't want to export the secret parts of the
523                  * primary key, this is done by using GNU protection mode 1001
524                  */
525                 int save_mode = node->pkt->pkt.secret_key->protect.s2k.mode;
526                 node->pkt->pkt.secret_key->protect.s2k.mode = 1001;
527                 rc = build_packet( out, node->pkt );
528                 node->pkt->pkt.secret_key->protect.s2k.mode = save_mode;
529               }
530             else if (secret == 2 && node->pkt->pkttype == PKT_SECRET_SUBKEY
531                      && (opt.export_options&EXPORT_RESET_SUBKEY_PASSWD))
532               {
533                 /* If the subkey is protected reset the passphrase to
534                    export an unprotected subkey.  This feature is
535                    useful in cases of a subkey copied to an unattended
536                    machine where a passphrase is not required. */
537                 PKT_secret_key *sk_save, *sk;
538
539                 sk_save = node->pkt->pkt.secret_key;
540                 sk = copy_secret_key (NULL, sk_save);
541                 node->pkt->pkt.secret_key = sk;
542
543                 log_info (_("about to export an unprotected subkey\n"));
544                 switch (is_secret_key_protected (sk))
545                   {
546                   case -1:
547                     rc = G10ERR_PUBKEY_ALGO;
548                     break;
549                   case 0:
550                     break;
551                   default:
552                     if (sk->protect.s2k.mode == 1001)
553                       ; /* No secret parts. */
554                     else if( sk->protect.s2k.mode == 1002 ) 
555                       ; /* Card key stub. */
556                     else 
557                       {
558                         rc = check_secret_key( sk, 0 );
559                       }
560                     break;
561                   }
562                 if (rc)
563                   {
564                     node->pkt->pkt.secret_key = sk_save;
565                     free_secret_key (sk);
566                     log_error (_("failed to unprotect the subkey: %s\n"),
567                                g10_errstr (rc));
568                     goto leave;
569                   }
570
571                 rc = build_packet (out, node->pkt);
572
573                 node->pkt->pkt.secret_key = sk_save;
574                 free_secret_key (sk);
575               }
576             else
577               {
578                 /* Warn the user if the secret key or any of the secret
579                    subkeys are protected with SHA1 and we have
580                    simple_sk_checksum set. */
581                 if(!sha1_warned && opt.simple_sk_checksum &&
582                    (node->pkt->pkttype==PKT_SECRET_KEY ||
583                     node->pkt->pkttype==PKT_SECRET_SUBKEY) &&
584                    node->pkt->pkt.secret_key->protect.sha1chk)
585                   {
586                     /* I hope this warning doesn't confuse people. */
587                     log_info(_("WARNING: secret key %s does not have a "
588                                "simple SK checksum\n"),keystr(sk_keyid));
589
590                     sha1_warned=1;
591                   }
592
593                 rc = build_packet( out, node->pkt );
594               }
595
596             if( rc ) {
597                 log_error("build_packet(%d) failed: %s\n",
598                             node->pkt->pkttype, g10_errstr(rc) );
599                 rc = G10ERR_WRITE_FILE;
600                 goto leave;
601             }
602         }
603         ++*any;
604         if(keyblock_out)
605           {
606             *keyblock_out=keyblock;
607             break;
608           }
609     }
610     if( rc == -1 )
611         rc = 0;
612
613   leave:
614     release_subkey_list (subkey_list);
615     xfree(desc);
616     keydb_release (kdbhd);
617     if(rc || keyblock_out==NULL)
618       release_kbnode( keyblock );
619     if( !*any )
620         log_info(_("WARNING: nothing exported\n"));
621     return rc;
622 }