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