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