Yet another fix for the gpg.c rename
[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                 /* XXX: before skipping a subkey, check whether any
345                    other description wants an exact macth on a subkey
346                    and include that subkey into the output too.  Need
347                    to add this subkey to a list so that it won't get
348                    processed a second time. 
349                    
350                    So the first step here is to check that list and
351                    skip in any case if the key is in that list.
352
353                    We need this whole mess becuase the import fnction
354                    is not able to merge secret key and thus it is not
355                    possible to output them as two keys and have import
356                    merge them.
357                   */
358
359                 if(skip_until_subkey)
360                   continue;
361               }
362
363             if(node->pkt->pkttype==PKT_USER_ID)
364               {
365                 /* Run clean_sigs_from_uid against each uid if
366                    export-clean-sigs is on. */
367                 if(options&EXPORT_CLEAN_SIGS)
368                   clean_sigs_from_uid(keyblock,node,opt.verbose);
369               }
370             else if(node->pkt->pkttype==PKT_SIGNATURE)
371               {
372                 /* If we have export-minimal turned on, do not include
373                    any signature that isn't a selfsig.  Note that this
374                    only applies to uid sigs (0x10, 0x11, 0x12, and
375                    0x13).  A designated revocation is not stripped. */
376                 if((options&EXPORT_MINIMAL)
377                    && IS_UID_SIG(node->pkt->pkt.signature)
378                    && (node->pkt->pkt.signature->keyid[0]!=keyid[0]
379                        || node->pkt->pkt.signature->keyid[1]!=keyid[1]))
380                   continue;
381
382                 /* do not export packets which are marked as not
383                    exportable */
384                 if(!(options&EXPORT_LOCAL_SIGS)
385                    && !node->pkt->pkt.signature->flags.exportable)
386                   continue; /* not exportable */
387
388                 /* Do not export packets with a "sensitive" revocation
389                    key unless the user wants us to.  Note that we do
390                    export these when issuing the actual revocation
391                    (see revoke.c). */
392                 if(!(options&EXPORT_SENSITIVE_REVKEYS)
393                    && node->pkt->pkt.signature->revkey)
394                   {
395                     int i;
396
397                     for(i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
398                       if(node->pkt->pkt.signature->revkey[i]->class & 0x40)
399                         break;
400
401                     if(i<node->pkt->pkt.signature->numrevkeys)
402                       continue;
403                   }
404               }
405
406             /* Don't export attribs? */
407             if( !(options&EXPORT_ATTRIBUTES) &&
408                 node->pkt->pkttype == PKT_USER_ID &&
409                 node->pkt->pkt.user_id->attrib_data ) {
410               /* Skip until we get to something that is not an attrib
411                  or a signature on an attrib */
412               while(kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE) {
413                 kbctx=kbctx->next;
414               }
415  
416               continue;
417             }
418
419             if( secret == 2 && node->pkt->pkttype == PKT_SECRET_KEY )
420               {
421                 /* We don't want to export the secret parts of the
422                  * primary key, this is done by using GNU protection mode 1001
423                  */
424                 int save_mode = node->pkt->pkt.secret_key->protect.s2k.mode;
425                 node->pkt->pkt.secret_key->protect.s2k.mode = 1001;
426                 rc = build_packet( out, node->pkt );
427                 node->pkt->pkt.secret_key->protect.s2k.mode = save_mode;
428               }
429             else if (secret == 2 && node->pkt->pkttype == PKT_SECRET_SUBKEY
430                      && (opt.export_options&EXPORT_RESET_SUBKEY_PASSWD))
431               {
432                 /* If the subkey is protected reset the passphrase to
433                    export an unprotected subkey.  This feature is
434                    useful in cases of a subkey copied to an unattended
435                    machine where a passphrase is not required. */
436                 PKT_secret_key *sk_save, *sk;
437
438                 sk_save = node->pkt->pkt.secret_key;
439                 sk = copy_secret_key (NULL, sk_save);
440                 node->pkt->pkt.secret_key = sk;
441
442                 log_info (_("about to export an unprotected subkey\n"));
443                 switch (is_secret_key_protected (sk))
444                   {
445                   case -1:
446                     rc = G10ERR_PUBKEY_ALGO;
447                     break;
448                   case 0:
449                     break;
450                   default:
451                     if (sk->protect.s2k.mode == 1001)
452                       ; /* No secret parts. */
453                     else if( sk->protect.s2k.mode == 1002 ) 
454                       ; /* Card key stub. */
455                     else 
456                       {
457                         rc = check_secret_key( sk, 0 );
458                       }
459                     break;
460                   }
461                 if (rc)
462                   {
463                     node->pkt->pkt.secret_key = sk_save;
464                     free_secret_key (sk);
465                     log_error (_("failed to unprotect the subkey: %s\n"),
466                                g10_errstr (rc));
467                     goto leave;
468                   }
469
470                 rc = build_packet (out, node->pkt);
471
472                 node->pkt->pkt.secret_key = sk_save;
473                 free_secret_key (sk);
474               }
475             else
476               {
477                 /* Warn the user if the secret key or any of the secret
478                    subkeys are protected with SHA1 and we have
479                    simple_sk_checksum set. */
480                 if(!sha1_warned && opt.simple_sk_checksum &&
481                    (node->pkt->pkttype==PKT_SECRET_KEY ||
482                     node->pkt->pkttype==PKT_SECRET_SUBKEY) &&
483                    node->pkt->pkt.secret_key->protect.sha1chk)
484                   {
485                     /* I hope this warning doesn't confuse people. */
486                     log_info(_("WARNING: secret key %s does not have a "
487                                "simple SK checksum\n"),keystr(sk_keyid));
488
489                     sha1_warned=1;
490                   }
491
492                 rc = build_packet( out, node->pkt );
493               }
494
495             if( rc ) {
496                 log_error("build_packet(%d) failed: %s\n",
497                             node->pkt->pkttype, g10_errstr(rc) );
498                 rc = G10ERR_WRITE_FILE;
499                 goto leave;
500             }
501         }
502         ++*any;
503         if(keyblock_out)
504           {
505             *keyblock_out=keyblock;
506             break;
507           }
508     }
509     if( rc == -1 )
510         rc = 0;
511
512   leave:
513     xfree(desc);
514     keydb_release (kdbhd);
515     if(rc || keyblock_out==NULL)
516       release_kbnode( keyblock );
517     if( !*any )
518         log_info(_("WARNING: nothing exported\n"));
519     return rc;
520 }