* keyedit.c (keyedit_menu, menu_clean): Simplify clean options to just
[gnupg.git] / g10 / import.c
1 /* import.c - import a key into our key storage.
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 "trustdb.h"
37 #include "main.h"
38 #include "i18n.h"
39 #include "ttyio.h"
40 #include "status.h"
41 #include "keyserver-internal.h"
42
43 struct stats_s {
44     ulong count;
45     ulong no_user_id;
46     ulong imported;
47     ulong imported_rsa;
48     ulong n_uids;
49     ulong n_sigs;
50     ulong n_subk;
51     ulong unchanged;
52     ulong n_revoc;
53     ulong secret_read;
54     ulong secret_imported;
55     ulong secret_dups;
56     ulong skipped_new_keys;
57     ulong not_imported;
58     ulong n_sigs_cleaned;
59     ulong n_uids_cleaned;
60 };
61
62
63 static int import( IOBUF inp, const char* fname,
64                    struct stats_s *stats, unsigned int options );
65 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
66 static void revocation_present(KBNODE keyblock);
67 static int import_one( const char *fname, KBNODE keyblock,
68                        struct stats_s *stats, unsigned int options);
69 static int import_secret_one( const char *fname, KBNODE keyblock,
70                               struct stats_s *stats, unsigned int options);
71 static int import_revoke_cert( const char *fname, KBNODE node,
72                                struct stats_s *stats);
73 static int chk_self_sigs( const char *fname, KBNODE keyblock,
74                           PKT_public_key *pk, u32 *keyid, int *non_self );
75 static int delete_inv_parts( const char *fname, KBNODE keyblock,
76                              u32 *keyid, unsigned int options );
77 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
78                          KBNODE keyblock, u32 *keyid,
79                          int *n_uids, int *n_sigs, int *n_subk );
80 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
81                              const char *fname, u32 *keyid );
82 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
83                              const char *fname, u32 *keyid );
84 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
85                              const char *fname, u32 *keyid );
86 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
87                              const char *fname, u32 *keyid );
88
89 int
90 parse_import_options(char *str,unsigned int *options,int noisy)
91 {
92   struct parse_options import_opts[]=
93     {
94       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
95        N_("import signatures that are marked as local-only")},
96       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
97        N_("repair damage from the pks keyserver during import")},
98       {"fast-import",IMPORT_FAST,NULL,
99        N_("do not update the trustdb after import")},
100       {"convert-sk-to-pk",IMPORT_SK2PK,NULL,
101        N_("create a public key when importing a secret key")},
102       {"merge-only",IMPORT_MERGE_ONLY,NULL,
103        N_("only accept updates to existing keys")},
104       {"import-clean",IMPORT_CLEAN,NULL,
105        N_("remove unusable parts from key after import")},
106       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
107        N_("remove as much as possible from key after import")},
108       /* Aliases for backward compatibility */
109       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
110       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
111       /* dummy */
112       {"import-unusable-sigs",0,NULL,NULL},
113       {"import-clean-sigs",0,NULL,NULL},
114       {"import-clean-uids",0,NULL,NULL},
115       {NULL,0,NULL,NULL}
116     };
117
118   return parse_options(str,options,import_opts,noisy);
119 }
120
121 void *
122 import_new_stats_handle (void)
123 {
124     return xmalloc_clear ( sizeof (struct stats_s) );
125 }
126
127 void
128 import_release_stats_handle (void *p)
129 {
130     xfree (p);
131 }
132
133 /****************
134  * Import the public keys from the given filename. Input may be armored.
135  * This function rejects all keys which are not validly self signed on at
136  * least one userid. Only user ids which are self signed will be imported.
137  * Other signatures are not checked.
138  *
139  * Actually this function does a merge. It works like this:
140  *
141  *  - get the keyblock
142  *  - check self-signatures and remove all userids and their signatures
143  *    without/invalid self-signatures.
144  *  - reject the keyblock, if we have no valid userid.
145  *  - See whether we have this key already in one of our pubrings.
146  *    If not, simply add it to the default keyring.
147  *  - Compare the key and the self-signatures of the new and the one in
148  *    our keyring.  If they are different something weird is going on;
149  *    ask what to do.
150  *  - See whether we have only non-self-signature on one user id; if not
151  *    ask the user what to do.
152  *  - compare the signatures: If we already have this signature, check
153  *    that they compare okay; if not, issue a warning and ask the user.
154  *    (consider looking at the timestamp and use the newest?)
155  *  - Simply add the signature.  Can't verify here because we may not have
156  *    the signature's public key yet; verification is done when putting it
157  *    into the trustdb, which is done automagically as soon as this pubkey
158  *    is used.
159  *  - Proceed with next signature.
160  *
161  *  Key revocation certificates have special handling.
162  *
163  */
164 static int
165 import_keys_internal( IOBUF inp, char **fnames, int nnames,
166                       void *stats_handle, unsigned int options )
167 {
168     int i, rc = 0;
169     struct stats_s *stats = stats_handle;
170
171     if (!stats)
172         stats = import_new_stats_handle ();
173
174     if (inp) {
175         rc = import( inp, "[stream]", stats, options);
176     }
177     else {
178         if( !fnames && !nnames )
179             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
180
181         for(i=0; i < nnames; i++ ) {
182             const char *fname = fnames? fnames[i] : NULL;
183             IOBUF inp2 = iobuf_open(fname);
184             if( !fname )
185                 fname = "[stdin]";
186             if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
187               {
188                 iobuf_close (inp2);
189                 inp2 = NULL;
190                 errno = EPERM;
191               }
192             if( !inp2 )
193                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
194             else {
195                 rc = import( inp2, fname, stats, options );
196                 iobuf_close(inp2);
197                 /* Must invalidate that ugly cache to actually close it. */
198                 iobuf_ioctl (NULL, 2, 0, (char*)fname);
199                 if( rc )
200                     log_error("import from `%s' failed: %s\n", fname,
201                               g10_errstr(rc) );
202             }
203             if( !fname )
204                 break;
205         }
206     }
207     if (!stats_handle) {
208         import_print_stats (stats);
209         import_release_stats_handle (stats);
210     }
211
212     /* If no fast import and the trustdb is dirty (i.e. we added a key
213        or userID that had something other than a selfsig, a signature
214        that was other than a selfsig, or any revocation), then
215        update/check the trustdb if the user specified by setting
216        interactive or by not setting no-auto-check-trustdb */
217
218     if(!(options&IMPORT_FAST))
219       trustdb_check_or_update();
220
221     return rc;
222 }
223
224 void
225 import_keys( char **fnames, int nnames,
226              void *stats_handle, unsigned int options )
227 {
228     import_keys_internal( NULL, fnames, nnames, stats_handle, options);
229 }
230
231 int
232 import_keys_stream( IOBUF inp, void *stats_handle, unsigned int options )
233 {
234     return import_keys_internal( inp, NULL, 0, stats_handle, options);
235 }
236
237 static int
238 import( IOBUF inp, const char* fname,
239         struct stats_s *stats, unsigned int options )
240 {
241     PACKET *pending_pkt = NULL;
242     KBNODE keyblock;
243     int rc = 0;
244
245     getkey_disable_caches();
246
247     if( !opt.no_armor ) { /* armored reading is not disabled */
248         armor_filter_context_t *afx = xmalloc_clear( sizeof *afx );
249         afx->only_keyblocks = 1;
250         iobuf_push_filter2( inp, armor_filter, afx, 1 );
251     }
252
253     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
254         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
255             rc = import_one( fname, keyblock, stats, options );
256         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
257                 rc = import_secret_one( fname, keyblock, stats, options );
258         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
259                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
260             rc = import_revoke_cert( fname, keyblock, stats );
261         else {
262             log_info( _("skipping block of type %d\n"),
263                                             keyblock->pkt->pkttype );
264         }
265         release_kbnode(keyblock);
266         /* fixme: we should increment the not imported counter but this
267            does only make sense if we keep on going despite of errors. */
268         if( rc )
269             break;
270         if( !(++stats->count % 100) && !opt.quiet )
271             log_info(_("%lu keys processed so far\n"), stats->count );
272     }
273     if( rc == -1 )
274         rc = 0;
275     else if( rc && rc != G10ERR_INV_KEYRING )
276         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
277
278     return rc;
279 }
280
281
282 void
283 import_print_stats (void *hd)
284 {
285     struct stats_s *stats = hd;
286
287     if( !opt.quiet ) {
288         log_info(_("Total number processed: %lu\n"), stats->count );
289         if( stats->skipped_new_keys )
290             log_info(_("      skipped new keys: %lu\n"),
291                                                 stats->skipped_new_keys );
292         if( stats->no_user_id )
293             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
294         if( stats->imported || stats->imported_rsa ) {
295             log_info(_("              imported: %lu"), stats->imported );
296             if( stats->imported_rsa )
297                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
298             putc('\n', stderr);
299         }
300         if( stats->unchanged )
301             log_info(_("             unchanged: %lu\n"), stats->unchanged );
302         if( stats->n_uids )
303             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
304         if( stats->n_subk )
305             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
306         if( stats->n_sigs )
307             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
308         if( stats->n_revoc )
309             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
310         if( stats->secret_read )
311             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
312         if( stats->secret_imported )
313             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
314         if( stats->secret_dups )
315             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
316         if( stats->not_imported )
317             log_info(_("          not imported: %lu\n"), stats->not_imported );
318         if( stats->n_sigs_cleaned)
319             log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
320         if( stats->n_uids_cleaned)
321             log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
322     }
323
324     if( is_status_enabled() ) {
325         char buf[14*20];
326         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
327                 stats->count,
328                 stats->no_user_id,
329                 stats->imported,
330                 stats->imported_rsa,
331                 stats->unchanged,
332                 stats->n_uids,
333                 stats->n_subk,
334                 stats->n_sigs,
335                 stats->n_revoc,
336                 stats->secret_read,
337                 stats->secret_imported,
338                 stats->secret_dups,
339                 stats->skipped_new_keys,
340                 stats->not_imported );
341         write_status_text( STATUS_IMPORT_RES, buf );
342     }
343 }
344
345
346 /****************
347  * Read the next keyblock from stream A.
348  * PENDING_PKT should be initialzed to NULL
349  * and not chnaged form the caller.
350  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
351  */
352 static int
353 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
354 {
355     int rc;
356     PACKET *pkt;
357     KBNODE root = NULL;
358     int in_cert;
359
360     if( *pending_pkt ) {
361         root = new_kbnode( *pending_pkt );
362         *pending_pkt = NULL;
363         in_cert = 1;
364     }
365     else
366         in_cert = 0;
367     pkt = xmalloc( sizeof *pkt );
368     init_packet(pkt);
369     while( (rc=parse_packet(a, pkt)) != -1 ) {
370         if( rc ) {  /* ignore errors */
371             if( rc != G10ERR_UNKNOWN_PACKET ) {
372                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
373                 rc = G10ERR_INV_KEYRING;
374                 goto ready;
375             }
376             free_packet( pkt );
377             init_packet(pkt);
378             continue;
379         }
380
381         if( !root && pkt->pkttype == PKT_SIGNATURE
382                   && pkt->pkt.signature->sig_class == 0x20 ) {
383             /* this is a revocation certificate which is handled
384              * in a special way */
385             root = new_kbnode( pkt );
386             pkt = NULL;
387             goto ready;
388         }
389
390         /* make a linked list of all packets */
391         switch( pkt->pkttype ) {
392           case PKT_COMPRESSED:
393             if(check_compress_algo(pkt->pkt.compressed->algorithm))
394               {
395                 rc = G10ERR_COMPR_ALGO;
396                 goto ready;
397               }
398             else
399               {
400                 compress_filter_context_t *cfx = xmalloc_clear( sizeof *cfx );
401                 pkt->pkt.compressed->buf = NULL;
402                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
403               }
404             free_packet( pkt );
405             init_packet(pkt);
406             break;
407
408           case PKT_RING_TRUST:
409             /* skip those packets */
410             free_packet( pkt );
411             init_packet(pkt);
412             break;
413
414           case PKT_PUBLIC_KEY:
415           case PKT_SECRET_KEY:
416             if( in_cert ) { /* store this packet */
417                 *pending_pkt = pkt;
418                 pkt = NULL;
419                 goto ready;
420             }
421             in_cert = 1;
422           default:
423             if( in_cert ) {
424                 if( !root )
425                     root = new_kbnode( pkt );
426                 else
427                     add_kbnode( root, new_kbnode( pkt ) );
428                 pkt = xmalloc( sizeof *pkt );
429             }
430             init_packet(pkt);
431             break;
432         }
433     }
434   ready:
435     if( rc == -1 && root )
436         rc = 0;
437
438     if( rc )
439         release_kbnode( root );
440     else
441         *ret_root = root;
442     free_packet( pkt );
443     xfree( pkt );
444     return rc;
445 }
446
447 /* Walk through the subkeys on a pk to find if we have the PKS
448    disease: multiple subkeys with their binding sigs stripped, and the
449    sig for the first subkey placed after the last subkey.  That is,
450    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
451    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
452    and sub3, as they are already lost, but we can try and rescue sub1
453    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
454    sub2 sub3".  Returns TRUE if the keyblock was modified. */
455
456 static int
457 fix_pks_corruption(KBNODE keyblock)
458 {
459   int changed=0,keycount=0;
460   KBNODE node,last=NULL,sknode=NULL;
461
462   /* First determine if we have the problem at all.  Look for 2 or
463      more subkeys in a row, followed by a single binding sig. */
464   for(node=keyblock;node;last=node,node=node->next)
465     {
466       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
467         {
468           keycount++;
469           if(!sknode)
470             sknode=node;
471         }
472       else if(node->pkt->pkttype==PKT_SIGNATURE &&
473               node->pkt->pkt.signature->sig_class==0x18 &&
474               keycount>=2 && node->next==NULL)
475         {
476           /* We might have the problem, as this key has two subkeys in
477              a row without any intervening packets. */
478
479           /* Sanity check */
480           if(last==NULL)
481             break;
482
483           /* Temporarily attach node to sknode. */
484           node->next=sknode->next;
485           sknode->next=node;
486           last->next=NULL;
487
488           /* Note we aren't checking whether this binding sig is a
489              selfsig.  This is not necessary here as the subkey and
490              binding sig will be rejected later if that is the
491              case. */
492           if(check_key_signature(keyblock,node,NULL))
493             {
494               /* Not a match, so undo the changes. */
495               sknode->next=node->next;
496               last->next=node;
497               node->next=NULL;
498               break;
499             }
500           else
501             {
502               sknode->flag |= 1; /* Mark it good so we don't need to
503                                     check it again */
504               changed=1;
505               break;
506             }
507         }
508       else
509         keycount=0;
510     }
511
512   return changed;
513 }
514
515
516 static void
517 print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
518 {
519   byte array[MAX_FINGERPRINT_LEN], *s;
520   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
521   size_t i, n;
522
523   sprintf (buf, "%u ", reason);
524   p = buf + strlen (buf);
525
526   if (pk)
527     fingerprint_from_pk (pk, array, &n);
528   else
529     fingerprint_from_sk (sk, array, &n);
530   s = array;
531   for (i=0; i < n ; i++, s++, p += 2)
532     sprintf (p, "%02X", *s);
533
534   write_status_text (STATUS_IMPORT_OK, buf);
535 }
536
537 static void
538 print_import_check (PKT_public_key * pk, PKT_user_id * id)
539 {
540     char * buf;
541     byte fpr[24];
542     u32 keyid[2];
543     size_t i, pos = 0, n;
544
545     buf = xmalloc (17+41+id->len+32);
546     keyid_from_pk (pk, keyid);
547     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
548     pos = 17;
549     fingerprint_from_pk (pk, fpr, &n);
550     for (i = 0; i < n; i++, pos += 2)
551         sprintf (buf+pos, "%02X", fpr[i]);
552     strcat (buf, " ");
553     pos += 1;
554     strcat (buf, id->name);
555     write_status_text (STATUS_IMPORT_CHECK, buf);
556     xfree (buf);
557 }
558
559 static void
560 check_prefs_warning(PKT_public_key *pk)
561 {
562   log_info(_("WARNING: key %s contains preferences for unavailable\n"),
563            keystr_from_pk(pk));
564   log_info(_("algorithms on these user IDs:\n"));
565 }
566
567 static void
568 check_prefs(KBNODE keyblock)
569 {
570   KBNODE node;
571   PKT_public_key *pk;
572   int problem=0;
573   
574   merge_keys_and_selfsig(keyblock);
575   pk=keyblock->pkt->pkt.public_key;
576
577   for(node=keyblock;node;node=node->next)
578     {
579       if(node->pkt->pkttype==PKT_USER_ID
580          && node->pkt->pkt.user_id->created
581          && node->pkt->pkt.user_id->prefs)
582         {
583           PKT_user_id *uid=node->pkt->pkt.user_id;
584           prefitem_t *prefs=uid->prefs;
585           char *user=utf8_to_native(uid->name,strlen(uid->name),0);
586
587           for(;prefs->type;prefs++)
588             {
589               char num[10]; /* prefs->value is a byte, so we're over
590                                safe here */
591
592               sprintf(num,"%u",prefs->value);
593
594               if(prefs->type==PREFTYPE_SYM)
595                 {
596                   if(check_cipher_algo(prefs->value))
597                     {
598                       const char *algo=cipher_algo_to_string(prefs->value);
599                       if(!problem)
600                         check_prefs_warning(pk);
601                       log_info(_("         \"%s\": preference for cipher"
602                                  " algorithm %s\n"),user,algo?algo:num);
603                       problem=1;
604                     }
605                 }
606               else if(prefs->type==PREFTYPE_HASH)
607                 {
608                   if(check_digest_algo(prefs->value))
609                     {
610                       const char *algo=digest_algo_to_string(prefs->value);
611                       if(!problem)
612                         check_prefs_warning(pk);
613                       log_info(_("         \"%s\": preference for digest"
614                                  " algorithm %s\n"),user,algo?algo:num);
615                       problem=1;
616                     }
617                 }
618               else if(prefs->type==PREFTYPE_ZIP)
619                 {
620                   if(check_compress_algo(prefs->value))
621                     {
622                       const char *algo=compress_algo_to_string(prefs->value);
623                       if(!problem)
624                         check_prefs_warning(pk);
625                       log_info(_("         \"%s\": preference for compression"
626                                  " algorithm %s\n"),user,algo?algo:num);
627                       problem=1;
628                     }
629                 }
630             }
631
632           xfree(user);
633         }
634     }
635
636   if(problem)
637     {
638       log_info(_("it is strongly suggested that you update"
639                  " your preferences and\n"));
640       log_info(_("re-distribute this key to avoid potential algorithm"
641                  " mismatch problems\n"));
642
643       if(!opt.batch)
644         {
645           STRLIST sl=NULL,locusr=NULL;
646           size_t fprlen=0;
647           byte fpr[MAX_FINGERPRINT_LEN],*p;
648           char username[(MAX_FINGERPRINT_LEN*2)+1];
649           unsigned int i;
650
651           p=fingerprint_from_pk(pk,fpr,&fprlen);
652           for(i=0;i<fprlen;i++,p++)
653             sprintf(username+2*i,"%02X",*p);
654           add_to_strlist(&locusr,username);
655
656           append_to_strlist(&sl,"updpref");
657           append_to_strlist(&sl,"save");
658
659           keyedit_menu( username, locusr, sl, 1, 1 );
660           free_strlist(sl);
661           free_strlist(locusr);
662         }
663       else if(!opt.quiet)
664         log_info(_("you can update your preferences with:"
665                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
666     }
667 }
668
669 /****************
670  * Try to import one keyblock.  Return an error only in serious cases, but
671  * never for an invalid keyblock.  It uses log_error to increase the
672  * internal errorcount, so that invalid input can be detected by programs
673  * which called g10.
674  */
675 static int
676 import_one( const char *fname, KBNODE keyblock,
677             struct stats_s *stats, unsigned int options )
678 {
679     PKT_public_key *pk;
680     PKT_public_key *pk_orig;
681     KBNODE node, uidnode;
682     KBNODE keyblock_orig = NULL;
683     u32 keyid[2];
684     int rc = 0;
685     int new_key = 0;
686     int mod_key = 0;
687     int non_self = 0;
688
689     /* get the key and print some info about it */
690     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
691     if( !node )
692         BUG();
693
694     pk = node->pkt->pkt.public_key;
695     keyid_from_pk( pk, keyid );
696     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
697
698     if( opt.verbose && !opt.interactive )
699       {
700         log_info( "pub  %4u%c/%s %s  ",
701                   nbits_from_pk( pk ),
702                   pubkey_letter( pk->pubkey_algo ),
703                   keystr_from_pk(pk), datestr_from_pk(pk) );
704         if( uidnode )
705           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
706                              uidnode->pkt->pkt.user_id->len );
707         putc('\n', stderr);
708       }
709
710     if( !uidnode )
711       {
712         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
713         return 0;
714       }
715     
716     if (opt.interactive) {
717         if(is_status_enabled())
718           print_import_check (pk, uidnode->pkt->pkt.user_id);
719         merge_keys_and_selfsig (keyblock);
720         tty_printf ("\n");
721         show_basic_key_info (keyblock);
722         tty_printf ("\n");
723         if (!cpr_get_answer_is_yes ("import.okay",
724                                     "Do you want to import this key? (y/N) "))
725             return 0;
726     }
727
728     collapse_uids(&keyblock);
729
730     /* Clean the key that we're about to import, to cut down on things
731        that we have to clean later.  This has no practical impact on
732        the end result, but does result in less logging which might
733        confuse the user. */
734     if(options&IMPORT_CLEAN)
735       clean_key(keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);
736
737     clear_kbnode_flags( keyblock );
738
739     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
740        && opt.verbose)
741       log_info(_("key %s: PKS subkey corruption repaired\n"),
742                keystr_from_pk(pk));
743
744     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
745     if( rc )
746         return rc== -1? 0:rc;
747
748     /* If we allow such a thing, mark unsigned uids as valid */
749     if( opt.allow_non_selfsigned_uid )
750       for( node=keyblock; node; node = node->next )
751         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
752           {
753             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
754                                       node->pkt->pkt.user_id->len,0);
755             node->flag |= 1;
756             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
757                       keystr_from_pk(pk),user);
758             xfree(user);
759           }
760
761     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
762         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
763         if( !opt.quiet )
764           log_info(_("this may be caused by a missing self-signature\n"));
765         stats->no_user_id++;
766         return 0;
767     }
768
769     /* do we have this key already in one of our pubrings ? */
770     pk_orig = xmalloc_clear( sizeof *pk_orig );
771     rc = get_pubkey_fast ( pk_orig, keyid );
772     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
773       {
774         log_error( _("key %s: public key not found: %s\n"),
775                    keystr(keyid), g10_errstr(rc));
776       }
777     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
778       {
779         if( opt.verbose )
780           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
781         rc = 0;
782         stats->skipped_new_keys++;
783       }
784     else if( rc ) { /* insert this key */
785         KEYDB_HANDLE hd = keydb_new (0);
786
787         rc = keydb_locate_writable (hd, NULL);
788         if (rc) {
789             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
790             keydb_release (hd);
791             return G10ERR_GENERAL;
792         }
793         if( opt.verbose > 1 )
794             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
795
796         rc = keydb_insert_keyblock (hd, keyblock );
797         if (rc)
798            log_error (_("error writing keyring `%s': %s\n"),
799                        keydb_get_resource_name (hd), g10_errstr(rc));
800         else
801           {
802             /* This should not be possible since we delete the
803                ownertrust when a key is deleted, but it can happen if
804                the keyring and trustdb are out of sync.  It can also
805                be made to happen with the trusted-key command. */
806
807             clear_ownertrusts (pk);
808             if(non_self)
809               revalidation_mark ();
810           }
811         keydb_release (hd);
812
813         /* we are ready */
814         if( !opt.quiet )
815           {
816             char *p=get_user_id_native (keyid);
817             log_info( _("key %s: public key \"%s\" imported\n"),
818                       keystr(keyid),p);
819             xfree(p);
820           }
821         if( is_status_enabled() )
822           {
823             char *us = get_long_user_id_string( keyid );
824             write_status_text( STATUS_IMPORTED, us );
825             xfree(us);
826             print_import_ok (pk,NULL, 1);
827           }
828         stats->imported++;
829         if( is_RSA( pk->pubkey_algo ) )
830             stats->imported_rsa++;
831         new_key = 1;
832     }
833     else { /* merge */
834         KEYDB_HANDLE hd;
835         int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
836
837         /* Compare the original against the new key; just to be sure nothing
838          * weird is going on */
839         if( cmp_public_keys( pk_orig, pk ) )
840           {
841             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
842             goto leave;
843           }
844
845         /* now read the original keyblock */
846         hd = keydb_new (0);
847         {
848             byte afp[MAX_FINGERPRINT_LEN];
849             size_t an;
850
851             fingerprint_from_pk (pk_orig, afp, &an);
852             while (an < MAX_FINGERPRINT_LEN) 
853                 afp[an++] = 0;
854             rc = keydb_search_fpr (hd, afp);
855         }
856         if( rc )
857           {
858             log_error (_("key %s: can't locate original keyblock: %s\n"),
859                        keystr(keyid), g10_errstr(rc));
860             keydb_release (hd);
861             goto leave;
862           }
863         rc = keydb_get_keyblock (hd, &keyblock_orig );
864         if (rc)
865           {
866             log_error (_("key %s: can't read original keyblock: %s\n"),
867                        keystr(keyid), g10_errstr(rc));
868             keydb_release (hd);
869             goto leave;
870           }
871
872         /* and try to merge the block */
873         clear_kbnode_flags( keyblock_orig );
874         clear_kbnode_flags( keyblock );
875         n_uids = n_sigs = n_subk = n_sigs_cleaned = n_uids_cleaned = 0;
876         rc = merge_blocks( fname, keyblock_orig, keyblock,
877                            keyid, &n_uids, &n_sigs, &n_subk );
878         if( rc )
879           {
880             keydb_release (hd);
881             goto leave;
882           }
883
884         if(options&IMPORT_CLEAN)
885           clean_key(keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
886                     &n_uids_cleaned,&n_sigs_cleaned);
887
888         if( n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned) {
889             mod_key = 1;
890             /* keyblock_orig has been updated; write */
891             rc = keydb_update_keyblock (hd, keyblock_orig);
892             if (rc)
893                 log_error (_("error writing keyring `%s': %s\n"),
894                              keydb_get_resource_name (hd), g10_errstr(rc) );
895             else if(non_self)
896               revalidation_mark ();
897
898             /* we are ready */
899             if( !opt.quiet )
900               {
901                 char *p=get_user_id_native(keyid);
902                 if( n_uids == 1 )
903                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
904                            keystr(keyid),p);
905                 else if( n_uids )
906                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
907                             keystr(keyid),p,n_uids);
908                 if( n_sigs == 1 )
909                   log_info( _("key %s: \"%s\" 1 new signature\n"),
910                             keystr(keyid), p);
911                 else if( n_sigs )
912                   log_info( _("key %s: \"%s\" %d new signatures\n"),
913                             keystr(keyid), p, n_sigs );
914                 if( n_subk == 1 )
915                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
916                             keystr(keyid), p);
917                 else if( n_subk )
918                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
919                             keystr(keyid), p, n_subk );
920                 if(n_sigs_cleaned==1)
921                   log_info(_("key %s: \"%s\" %d signature cleaned\n"),
922                            keystr(keyid),p,n_sigs_cleaned);
923                 else if(n_sigs_cleaned)
924                   log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
925                            keystr(keyid),p,n_sigs_cleaned);
926                 if(n_uids_cleaned==1)
927                   log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
928                            keystr(keyid),p,n_uids_cleaned);
929                 else if(n_uids_cleaned)
930                   log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
931                            keystr(keyid),p,n_uids_cleaned);
932                 xfree(p);
933               }
934
935             stats->n_uids +=n_uids;
936             stats->n_sigs +=n_sigs;
937             stats->n_subk +=n_subk;
938             stats->n_sigs_cleaned +=n_sigs_cleaned;
939             stats->n_uids_cleaned +=n_uids_cleaned;
940
941             if (is_status_enabled ()) 
942                  print_import_ok (pk, NULL,
943                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
944         }
945         else
946           {
947             if (is_status_enabled ()) 
948               print_import_ok (pk, NULL, 0);
949
950             if( !opt.quiet )
951               {
952                 char *p=get_user_id_native(keyid);
953                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
954                 xfree(p);
955               }
956
957             stats->unchanged++;
958           }
959
960         keydb_release (hd); hd = NULL;
961     }
962
963   leave:
964
965     /* Now that the key is definitely incorporated into the keydb, we
966        need to check if a designated revocation is present or if the
967        prefs are not rational so we can warn the user. */
968
969     if(mod_key)
970       {
971         revocation_present(keyblock_orig);
972         if(seckey_available(keyid)==0)
973           check_prefs(keyblock_orig);
974       }
975     else if(new_key)
976       {
977         revocation_present(keyblock);
978         if(seckey_available(keyid)==0)
979           check_prefs(keyblock);
980       }
981
982     release_kbnode( keyblock_orig );
983     free_public_key( pk_orig );
984
985     return rc;
986 }
987
988 /* Walk a secret keyblock and produce a public keyblock out of it. */
989 static KBNODE
990 sec_to_pub_keyblock(KBNODE sec_keyblock)
991 {
992   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
993
994   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
995     {
996       KBNODE pubnode;
997
998       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
999          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
1000         {
1001           /* Make a public key.  We only need to convert enough to
1002              write the keyblock out. */
1003
1004           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
1005           PACKET *pkt=xmalloc_clear(sizeof(PACKET));
1006           PKT_public_key *pk=xmalloc_clear(sizeof(PKT_public_key));
1007           int n;
1008
1009           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
1010             pkt->pkttype=PKT_PUBLIC_KEY;
1011           else
1012             pkt->pkttype=PKT_PUBLIC_SUBKEY;
1013
1014           pkt->pkt.public_key=pk;
1015
1016           pk->version=sk->version;
1017           pk->timestamp=sk->timestamp;
1018           pk->expiredate=sk->expiredate;
1019           pk->pubkey_algo=sk->pubkey_algo;
1020
1021           n=pubkey_get_npkey(pk->pubkey_algo);
1022           if(n==0)
1023             {
1024               /* we can't properly extract the pubkey without knowing
1025                  the number of MPIs */
1026               release_kbnode(pub_keyblock);
1027               return NULL;
1028             }
1029           else
1030             {
1031               int i;
1032
1033               for(i=0;i<n;i++)
1034                 pk->pkey[i]=mpi_copy(sk->skey[i]);
1035             }
1036
1037           pubnode=new_kbnode(pkt);
1038         }
1039       else
1040         {
1041           pubnode=clone_kbnode(secnode);
1042         }
1043
1044       if(pub_keyblock==NULL)
1045         pub_keyblock=pubnode;
1046       else
1047         add_kbnode(pub_keyblock,pubnode);
1048     }
1049
1050   return pub_keyblock;
1051 }
1052
1053 /****************
1054  * Ditto for secret keys.  Handling is simpler than for public keys.
1055  * We allow secret key importing only when allow is true, this is so
1056  * that a secret key can not be imported accidently and thereby tampering
1057  * with the trust calculation.
1058  */
1059 static int
1060 import_secret_one( const char *fname, KBNODE keyblock, 
1061                    struct stats_s *stats, unsigned int options)
1062 {
1063     PKT_secret_key *sk;
1064     KBNODE node, uidnode;
1065     u32 keyid[2];
1066     int rc = 0;
1067
1068     /* get the key and print some info about it */
1069     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1070     if( !node )
1071         BUG();
1072
1073     sk = node->pkt->pkt.secret_key;
1074     keyid_from_sk( sk, keyid );
1075     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1076
1077     if( opt.verbose )
1078       {
1079         log_info( "sec  %4u%c/%s %s   ",
1080                   nbits_from_sk( sk ),
1081                   pubkey_letter( sk->pubkey_algo ),
1082                   keystr_from_sk(sk), datestr_from_sk(sk) );
1083         if( uidnode )
1084           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1085                              uidnode->pkt->pkt.user_id->len );
1086         putc('\n', stderr);
1087       }
1088     stats->secret_read++;
1089
1090     if( !uidnode )
1091       {
1092         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1093         return 0;
1094       }
1095
1096     if(sk->protect.algo>110)
1097       {
1098         log_error(_("key %s: secret key with invalid cipher %d"
1099                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1100         return 0;
1101       }
1102
1103 #ifdef ENABLE_SELINUX_HACKS
1104     if (1)
1105       {
1106         /* We don't allow to import secret keys because that may be used
1107            to put a secret key into the keyring and the user might later
1108            be tricked into signing stuff with that key.  */
1109         log_error (_("importing secret keys not allowed\n"));
1110         return 0;
1111       }
1112 #endif 
1113     
1114     clear_kbnode_flags( keyblock );
1115
1116     /* do we have this key already in one of our secrings ? */
1117     rc = seckey_available( keyid );
1118     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1119       {
1120         /* simply insert this key */
1121         KEYDB_HANDLE hd = keydb_new (1);
1122
1123         /* get default resource */
1124         rc = keydb_locate_writable (hd, NULL);
1125         if (rc) {
1126           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1127           keydb_release (hd);
1128           return G10ERR_GENERAL;
1129         }
1130         rc = keydb_insert_keyblock (hd, keyblock );
1131         if (rc)
1132           log_error (_("error writing keyring `%s': %s\n"),
1133                      keydb_get_resource_name (hd), g10_errstr(rc) );
1134         keydb_release (hd);
1135         /* we are ready */
1136         if( !opt.quiet )
1137           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1138         stats->secret_imported++;
1139         if (is_status_enabled ()) 
1140           print_import_ok (NULL, sk, 1|16);
1141
1142         if(options&IMPORT_SK2PK)
1143           {
1144             /* Try and make a public key out of this. */
1145
1146             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1147             if(pub_keyblock)
1148               {
1149                 import_one(fname,pub_keyblock,stats,opt.import_options);
1150                 release_kbnode(pub_keyblock);
1151               }
1152           }
1153
1154         /* Now that the key is definitely incorporated into the keydb,
1155            if we have the public part of this key, we need to check if
1156            the prefs are rational. */
1157         node=get_pubkeyblock(keyid);
1158         if(node)
1159           {
1160             check_prefs(node);
1161             release_kbnode(node);
1162           }
1163       }
1164     else if( !rc )
1165       { /* we can't merge secret keys */
1166         log_error( _("key %s: already in secret keyring\n"),
1167                    keystr_from_sk(sk));
1168         stats->secret_dups++;
1169         if (is_status_enabled ()) 
1170           print_import_ok (NULL, sk, 16);
1171
1172         /* TODO: if we ever do merge secret keys, make sure to handle
1173            the sec_to_pub_keyblock feature as well. */
1174       }
1175     else
1176       log_error( _("key %s: secret key not found: %s\n"),
1177                  keystr_from_sk(sk), g10_errstr(rc));
1178
1179     return rc;
1180 }
1181
1182
1183 /****************
1184  * Import a revocation certificate; this is a single signature packet.
1185  */
1186 static int
1187 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1188 {
1189     PKT_public_key *pk=NULL;
1190     KBNODE onode, keyblock = NULL;
1191     KEYDB_HANDLE hd = NULL;
1192     u32 keyid[2];
1193     int rc = 0;
1194
1195     assert( !node->next );
1196     assert( node->pkt->pkttype == PKT_SIGNATURE );
1197     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1198
1199     keyid[0] = node->pkt->pkt.signature->keyid[0];
1200     keyid[1] = node->pkt->pkt.signature->keyid[1];
1201
1202     pk = xmalloc_clear( sizeof *pk );
1203     rc = get_pubkey( pk, keyid );
1204     if( rc == G10ERR_NO_PUBKEY )
1205       {
1206         log_error(_("key %s: no public key -"
1207                     " can't apply revocation certificate\n"), keystr(keyid));
1208         rc = 0;
1209         goto leave;
1210       }
1211     else if( rc )
1212       {
1213         log_error(_("key %s: public key not found: %s\n"),
1214                   keystr(keyid), g10_errstr(rc));
1215         goto leave;
1216       }
1217
1218     /* read the original keyblock */
1219     hd = keydb_new (0);
1220     {
1221         byte afp[MAX_FINGERPRINT_LEN];
1222         size_t an;
1223         
1224         fingerprint_from_pk (pk, afp, &an);
1225         while (an < MAX_FINGERPRINT_LEN) 
1226             afp[an++] = 0;
1227         rc = keydb_search_fpr (hd, afp);
1228     }
1229     if (rc)
1230       {
1231         log_error (_("key %s: can't locate original keyblock: %s\n"),
1232                    keystr(keyid), g10_errstr(rc));
1233         goto leave;
1234       }
1235     rc = keydb_get_keyblock (hd, &keyblock );
1236     if (rc)
1237       {
1238         log_error (_("key %s: can't read original keyblock: %s\n"),
1239                    keystr(keyid), g10_errstr(rc));
1240         goto leave;
1241       }
1242
1243     /* it is okay, that node is not in keyblock because
1244      * check_key_signature works fine for sig_class 0x20 in this
1245      * special case. */
1246     rc = check_key_signature( keyblock, node, NULL);
1247     if( rc )
1248       {
1249         log_error( _("key %s: invalid revocation certificate"
1250                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1251         goto leave;
1252       }
1253
1254     /* check whether we already have this */
1255     for(onode=keyblock->next; onode; onode=onode->next ) {
1256         if( onode->pkt->pkttype == PKT_USER_ID )
1257             break;
1258         else if( onode->pkt->pkttype == PKT_SIGNATURE
1259                  && !cmp_signatures(node->pkt->pkt.signature,
1260                                     onode->pkt->pkt.signature))
1261           {
1262             rc = 0;
1263             goto leave; /* yes, we already know about it */
1264           }
1265     }
1266
1267
1268     /* insert it */
1269     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1270
1271     /* and write the keyblock back */
1272     rc = keydb_update_keyblock (hd, keyblock );
1273     if (rc)
1274         log_error (_("error writing keyring `%s': %s\n"),
1275                    keydb_get_resource_name (hd), g10_errstr(rc) );
1276     keydb_release (hd); hd = NULL;
1277     /* we are ready */
1278     if( !opt.quiet )
1279       {
1280         char *p=get_user_id_native (keyid);
1281         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1282                   keystr(keyid),p);
1283         xfree(p);
1284       }
1285     stats->n_revoc++;
1286
1287     /* If the key we just revoked was ultimately trusted, remove its
1288        ultimate trust.  This doesn't stop the user from putting the
1289        ultimate trust back, but is a reasonable solution for now. */
1290     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1291       clear_ownertrusts(pk);
1292
1293     revalidation_mark ();
1294
1295   leave:
1296     keydb_release (hd);
1297     release_kbnode( keyblock );
1298     free_public_key( pk );
1299     return rc;
1300 }
1301
1302
1303 /****************
1304  * loop over the keyblock and check all self signatures.
1305  * Mark all user-ids with a self-signature by setting flag bit 0.
1306  * Mark all user-ids with an invalid self-signature by setting bit 1.
1307  * This works also for subkeys, here the subkey is marked.  Invalid or
1308  * extra subkey sigs (binding or revocation) are marked for deletion.
1309  * non_self is set to true if there are any sigs other than self-sigs
1310  * in this keyblock.
1311  */
1312 static int
1313 chk_self_sigs( const char *fname, KBNODE keyblock,
1314                PKT_public_key *pk, u32 *keyid, int *non_self )
1315 {
1316     KBNODE n,knode=NULL;
1317     PKT_signature *sig;
1318     int rc;
1319     u32 bsdate=0,rsdate=0;
1320     KBNODE bsnode=NULL,rsnode=NULL;
1321
1322     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1323       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1324         {
1325           knode=n;
1326           bsdate=0;
1327           rsdate=0;
1328           bsnode=NULL;
1329           rsnode=NULL;
1330           continue;
1331         }
1332       else if( n->pkt->pkttype != PKT_SIGNATURE )
1333             continue;
1334         sig = n->pkt->pkt.signature;
1335         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1336
1337             /* This just caches the sigs for later use.  That way we
1338                import a fully-cached key which speeds things up. */
1339             if(!opt.no_sig_cache)
1340               check_key_signature(keyblock,n,NULL);
1341
1342             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1343               {
1344                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1345                 if( !unode )
1346                   {
1347                     log_error( _("key %s: no user ID for signature\n"),
1348                                keystr(keyid));
1349                     return -1;  /* the complete keyblock is invalid */
1350                   }
1351
1352                 /* If it hasn't been marked valid yet, keep trying */
1353                 if(!(unode->flag&1)) {
1354                   rc = check_key_signature( keyblock, n, NULL);
1355                   if( rc )
1356                     {
1357                       if( opt.verbose )
1358                         {
1359                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1360                                       strlen(unode->pkt->pkt.user_id->name),0);
1361                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1362                                     _("key %s: unsupported public key "
1363                                       "algorithm on user ID \"%s\"\n"):
1364                                     _("key %s: invalid self-signature "
1365                                       "on user ID \"%s\"\n"),
1366                                     keystr(keyid),p);
1367                           xfree(p);
1368                         }
1369                     }
1370                   else
1371                     unode->flag |= 1; /* mark that signature checked */
1372                 }
1373               }
1374             else if( sig->sig_class == 0x18 ) {
1375               /* Note that this works based solely on the timestamps
1376                  like the rest of gpg.  If the standard gets
1377                  revocation targets, this may need to be revised. */
1378
1379                 if( !knode )
1380                   {
1381                     if(opt.verbose)
1382                       log_info( _("key %s: no subkey for key binding\n"),
1383                                 keystr(keyid));
1384                     n->flag |= 4; /* delete this */
1385                   }
1386                 else
1387                   {
1388                     rc = check_key_signature( keyblock, n, NULL);
1389                     if( rc )
1390                       {
1391                         if(opt.verbose)
1392                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1393                                    _("key %s: unsupported public key"
1394                                      " algorithm\n"):
1395                                    _("key %s: invalid subkey binding\n"),
1396                                    keystr(keyid));
1397                         n->flag|=4;
1398                       }
1399                     else
1400                       {
1401                         /* It's valid, so is it newer? */
1402                         if(sig->timestamp>=bsdate) {
1403                           knode->flag |= 1;  /* the subkey is valid */
1404                           if(bsnode)
1405                             {
1406                               bsnode->flag|=4; /* Delete the last binding
1407                                                   sig since this one is
1408                                                   newer */
1409                               if(opt.verbose)
1410                                 log_info(_("key %s: removed multiple subkey"
1411                                            " binding\n"),keystr(keyid));
1412                             }
1413
1414                           bsnode=n;
1415                           bsdate=sig->timestamp;
1416                         }
1417                         else
1418                           n->flag|=4; /* older */
1419                       }
1420                   }
1421             }
1422             else if( sig->sig_class == 0x28 ) {
1423               /* We don't actually mark the subkey as revoked right
1424                  now, so just check that the revocation sig is the
1425                  most recent valid one.  Note that we don't care if
1426                  the binding sig is newer than the revocation sig.
1427                  See the comment in getkey.c:merge_selfsigs_subkey for
1428                  more */
1429                 if( !knode )
1430                   {
1431                     if(opt.verbose)
1432                       log_info( _("key %s: no subkey for key revocation\n"),
1433                                 keystr(keyid));
1434                     n->flag |= 4; /* delete this */
1435                   }
1436                 else
1437                   {
1438                     rc = check_key_signature( keyblock, n, NULL);
1439                     if( rc )
1440                       {
1441                         if(opt.verbose)
1442                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1443                                    _("key %s: unsupported public"
1444                                      " key algorithm\n"):
1445                                    _("key %s: invalid subkey revocation\n"),
1446                                    keystr(keyid));
1447                         n->flag|=4;
1448                       }
1449                     else
1450                       {
1451                         /* It's valid, so is it newer? */
1452                         if(sig->timestamp>=rsdate)
1453                           {
1454                             if(rsnode)
1455                               {
1456                                 rsnode->flag|=4; /* Delete the last revocation
1457                                                     sig since this one is
1458                                                     newer */
1459                                 if(opt.verbose)
1460                                   log_info(_("key %s: removed multiple subkey"
1461                                              " revocation\n"),keystr(keyid));
1462                               }
1463
1464                             rsnode=n;
1465                             rsdate=sig->timestamp;
1466                           }
1467                         else
1468                           n->flag|=4; /* older */
1469                       }
1470                   }
1471             }
1472         }
1473         else
1474           *non_self=1;
1475     }
1476
1477     return 0;
1478 }
1479
1480 /****************
1481  * delete all parts which are invalid and those signatures whose
1482  * public key algorithm is not available in this implemenation;
1483  * but consider RSA as valid, because parse/build_packets knows
1484  * about it.
1485  * returns: true if at least one valid user-id is left over.
1486  */
1487 static int
1488 delete_inv_parts( const char *fname, KBNODE keyblock,
1489                   u32 *keyid, unsigned int options)
1490 {
1491     KBNODE node;
1492     int nvalid=0, uid_seen=0, subkey_seen=0;
1493
1494     for(node=keyblock->next; node; node = node->next ) {
1495         if( node->pkt->pkttype == PKT_USER_ID ) {
1496             uid_seen = 1;
1497             if( (node->flag & 2) || !(node->flag & 1) ) {
1498                 if( opt.verbose )
1499                   {
1500                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1501                                            node->pkt->pkt.user_id->len,0);
1502                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1503                               keystr(keyid),p);
1504                     xfree(p);
1505                   }
1506                 delete_kbnode( node ); /* the user-id */
1507                 /* and all following packets up to the next user-id */
1508                 while( node->next
1509                        && node->next->pkt->pkttype != PKT_USER_ID
1510                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1511                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1512                     delete_kbnode( node->next );
1513                     node = node->next;
1514                 }
1515             }
1516             else
1517                 nvalid++;
1518         }
1519         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1520                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1521             if( (node->flag & 2) || !(node->flag & 1) ) {
1522                 if( opt.verbose )
1523                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1524
1525                 delete_kbnode( node ); /* the subkey */
1526                 /* and all following signature packets */
1527                 while( node->next
1528                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1529                     delete_kbnode( node->next );
1530                     node = node->next;
1531                 }
1532             }
1533             else
1534               subkey_seen = 1;
1535         }
1536         else if( node->pkt->pkttype == PKT_SIGNATURE
1537                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1538                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1539             delete_kbnode( node ); /* build_packet() can't handle this */
1540         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1541                  !node->pkt->pkt.signature->flags.exportable &&
1542                  !(options&IMPORT_LOCAL_SIGS) &&
1543                  seckey_available( node->pkt->pkt.signature->keyid ) )
1544           {
1545             /* here we violate the rfc a bit by still allowing
1546              * to import non-exportable signature when we have the
1547              * the secret key used to create this signature - it
1548              * seems that this makes sense */
1549             if(opt.verbose)
1550               log_info( _("key %s: non exportable signature"
1551                           " (class 0x%02X) - skipped\n"),
1552                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1553             delete_kbnode( node );
1554           }
1555         else if( node->pkt->pkttype == PKT_SIGNATURE
1556                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1557             if( uid_seen )
1558               {
1559                 if(opt.verbose)
1560                   log_info( _("key %s: revocation certificate"
1561                               " at wrong place - skipped\n"),keystr(keyid));
1562                 delete_kbnode( node );
1563               }
1564             else {
1565               /* If the revocation cert is from a different key than
1566                  the one we're working on don't check it - it's
1567                  probably from a revocation key and won't be
1568                  verifiable with this key anyway. */
1569
1570               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1571                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1572                 {
1573                   int rc = check_key_signature( keyblock, node, NULL);
1574                   if( rc )
1575                     {
1576                       if(opt.verbose)
1577                         log_info( _("key %s: invalid revocation"
1578                                     " certificate: %s - skipped\n"),
1579                                   keystr(keyid), g10_errstr(rc));
1580                       delete_kbnode( node );
1581                     }
1582                 }
1583             }
1584         }
1585         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1586                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1587                   node->pkt->pkt.signature->sig_class == 0x28) &&
1588                  !subkey_seen )
1589           {
1590             if(opt.verbose)
1591               log_info( _("key %s: subkey signature"
1592                           " in wrong place - skipped\n"), keystr(keyid));
1593             delete_kbnode( node );
1594           }
1595         else if( node->pkt->pkttype == PKT_SIGNATURE
1596                  && !IS_CERT(node->pkt->pkt.signature))
1597           {
1598             if(opt.verbose)
1599               log_info(_("key %s: unexpected signature class (0x%02X) -"
1600                          " skipped\n"),keystr(keyid),
1601                        node->pkt->pkt.signature->sig_class);
1602             delete_kbnode(node);
1603           }
1604         else if( (node->flag & 4) ) /* marked for deletion */
1605           delete_kbnode( node );
1606     }
1607
1608     /* note: because keyblock is the public key, it is never marked
1609      * for deletion and so keyblock cannot change */
1610     commit_kbnode( &keyblock );
1611     return nvalid;
1612 }
1613
1614
1615 /****************
1616  * It may happen that the imported keyblock has duplicated user IDs.
1617  * We check this here and collapse those user IDs together with their
1618  * sigs into one.
1619  * Returns: True if the keyblock hash changed.
1620  */
1621 int
1622 collapse_uids( KBNODE *keyblock )
1623 {
1624     KBNODE n, n2;
1625     int in_uid;
1626     int any=0;
1627
1628   restart:
1629     for( n = *keyblock; n; n = n->next ) {
1630         if( n->pkt->pkttype != PKT_USER_ID )
1631             continue;
1632         for( n2 = n->next; n2; n2 = n2->next ) {
1633             if( n2->pkt->pkttype == PKT_USER_ID
1634                 && !cmp_user_ids( n->pkt->pkt.user_id,
1635                                   n2->pkt->pkt.user_id ) ) {
1636                 /* found a duplicate */
1637                 any = 1;
1638                 if( !n2->next
1639                     || n2->next->pkt->pkttype == PKT_USER_ID
1640                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1641                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1642                     /* no more signatures: delete the user ID
1643                      * and start over */
1644                     remove_kbnode( keyblock, n2 );
1645                 }
1646                 else {
1647                     /* The simple approach: Move one signature and
1648                      * then start over to delete the next one :-( */
1649                     move_kbnode( keyblock, n2->next, n->next );
1650                 }
1651                 goto restart;
1652             }
1653         }
1654     }
1655     if( !any )
1656         return 0;
1657
1658   restart_sig:
1659     /* now we may have duplicate signatures on one user ID: fix this */
1660     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1661         if( n->pkt->pkttype == PKT_USER_ID )
1662             in_uid = 1;
1663         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1664                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1665             in_uid = 0;
1666         else if( in_uid ) {
1667             n2 = n;
1668             do {
1669                 KBNODE ncmp = NULL;
1670                 for( ; n2; n2 = n2->next ) {
1671                     if(    n2->pkt->pkttype == PKT_USER_ID
1672                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1673                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1674                         break;
1675                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1676                         ;
1677                     else if( !ncmp )
1678                         ncmp = n2;
1679                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1680                                                 n2->pkt->pkt.signature )) {
1681                         remove_kbnode( keyblock, n2 );
1682                         goto restart_sig;
1683                     }
1684                 }
1685                 n2 = ncmp? ncmp->next : NULL;
1686             } while( n2 );
1687         }
1688     }
1689
1690     if(!opt.quiet)
1691       {
1692         const char *key="???";
1693
1694         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1695           key=keystr_from_pk(n->pkt->pkt.public_key);
1696         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1697           key=keystr_from_sk(n->pkt->pkt.secret_key);
1698
1699         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1700       }
1701
1702     return 1;
1703 }
1704
1705 /* Check for a 0x20 revocation from a revocation key that is not
1706    present.  This may be called without the benefit of merge_xxxx so
1707    you can't rely on pk->revkey and friends. */
1708 static void
1709 revocation_present(KBNODE keyblock)
1710 {
1711   KBNODE onode,inode;
1712   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1713
1714   for(onode=keyblock->next;onode;onode=onode->next)
1715     {
1716       /* If we reach user IDs, we're done. */
1717       if(onode->pkt->pkttype==PKT_USER_ID)
1718         break;
1719
1720       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1721          onode->pkt->pkt.signature->sig_class==0x1F &&
1722          onode->pkt->pkt.signature->revkey)
1723         {
1724           int idx;
1725           PKT_signature *sig=onode->pkt->pkt.signature;
1726
1727           for(idx=0;idx<sig->numrevkeys;idx++)
1728             {
1729               u32 keyid[2];
1730
1731               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1732                                      MAX_FINGERPRINT_LEN,keyid);
1733
1734               for(inode=keyblock->next;inode;inode=inode->next)
1735                 {
1736                   /* If we reach user IDs, we're done. */
1737                   if(inode->pkt->pkttype==PKT_USER_ID)
1738                     break;
1739
1740                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1741                      inode->pkt->pkt.signature->sig_class==0x20 &&
1742                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1743                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1744                     {
1745                       /* Okay, we have a revocation key, and a
1746                          revocation issued by it.  Do we have the key
1747                          itself? */
1748                       int rc;
1749
1750                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1751                                                    MAX_FINGERPRINT_LEN);
1752                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1753                         {
1754                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1755
1756                           /* No, so try and get it */
1757                           if(opt.keyserver
1758                              && (opt.keyserver_options.options
1759                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1760                             {
1761                               log_info(_("WARNING: key %s may be revoked:"
1762                                          " fetching revocation key %s\n"),
1763                                        tempkeystr,keystr(keyid));
1764                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1765                                                       MAX_FINGERPRINT_LEN,
1766                                                       opt.keyserver);
1767
1768                               /* Do we have it now? */
1769                               rc=get_pubkey_byfprint_fast (NULL,
1770                                                      sig->revkey[idx]->fpr,
1771                                                      MAX_FINGERPRINT_LEN);
1772                             }
1773
1774                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1775                             log_info(_("WARNING: key %s may be revoked:"
1776                                        " revocation key %s not present.\n"),
1777                                      tempkeystr,keystr(keyid));
1778
1779                           xfree(tempkeystr);
1780                         }
1781                     }
1782                 }
1783             }
1784         }
1785     }
1786 }
1787
1788 /****************
1789  * compare and merge the blocks
1790  *
1791  * o compare the signatures: If we already have this signature, check
1792  *   that they compare okay; if not, issue a warning and ask the user.
1793  * o Simply add the signature.  Can't verify here because we may not have
1794  *   the signature's public key yet; verification is done when putting it
1795  *   into the trustdb, which is done automagically as soon as this pubkey
1796  *   is used.
1797  * Note: We indicate newly inserted packets with flag bit 0
1798  */
1799 static int
1800 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1801               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1802 {
1803     KBNODE onode, node;
1804     int rc, found;
1805
1806     /* 1st: handle revocation certificates */
1807     for(node=keyblock->next; node; node=node->next ) {
1808         if( node->pkt->pkttype == PKT_USER_ID )
1809             break;
1810         else if( node->pkt->pkttype == PKT_SIGNATURE
1811                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1812             /* check whether we already have this */
1813             found = 0;
1814             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1815                 if( onode->pkt->pkttype == PKT_USER_ID )
1816                     break;
1817                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1818                          && onode->pkt->pkt.signature->sig_class == 0x20
1819                          && !cmp_signatures(onode->pkt->pkt.signature,
1820                                             node->pkt->pkt.signature))
1821                   {
1822                     found = 1;
1823                     break;
1824                   }
1825             }
1826             if( !found ) {
1827                 KBNODE n2 = clone_kbnode(node);
1828                 insert_kbnode( keyblock_orig, n2, 0 );
1829                 n2->flag |= 1;
1830                 ++*n_sigs;
1831                 if(!opt.quiet)
1832                   {
1833                     char *p=get_user_id_native (keyid);
1834                     log_info(_("key %s: \"%s\" revocation"
1835                                " certificate added\n"), keystr(keyid),p);
1836                     xfree(p);
1837                   }
1838             }
1839         }
1840     }
1841
1842     /* 2nd: merge in any direct key (0x1F) sigs */
1843     for(node=keyblock->next; node; node=node->next ) {
1844         if( node->pkt->pkttype == PKT_USER_ID )
1845             break;
1846         else if( node->pkt->pkttype == PKT_SIGNATURE
1847                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1848             /* check whether we already have this */
1849             found = 0;
1850             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1851                 if( onode->pkt->pkttype == PKT_USER_ID )
1852                     break;
1853                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1854                          && onode->pkt->pkt.signature->sig_class == 0x1F
1855                          && !cmp_signatures(onode->pkt->pkt.signature,
1856                                             node->pkt->pkt.signature)) {
1857                     found = 1;
1858                     break;
1859                 }
1860             }
1861             if( !found )
1862               {
1863                 KBNODE n2 = clone_kbnode(node);
1864                 insert_kbnode( keyblock_orig, n2, 0 );
1865                 n2->flag |= 1;
1866                 ++*n_sigs;
1867                 if(!opt.quiet)
1868                   log_info( _("key %s: direct key signature added\n"),
1869                             keystr(keyid));
1870               }
1871         }
1872     }
1873
1874     /* 3rd: try to merge new certificates in */
1875     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1876         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1877             /* find the user id in the imported keyblock */
1878             for(node=keyblock->next; node; node=node->next )
1879                 if( node->pkt->pkttype == PKT_USER_ID
1880                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1881                                           node->pkt->pkt.user_id ) )
1882                     break;
1883             if( node ) { /* found: merge */
1884                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1885                 if( rc )
1886                     return rc;
1887             }
1888         }
1889     }
1890
1891     /* 4th: add new user-ids */
1892     for(node=keyblock->next; node; node=node->next ) {
1893         if( node->pkt->pkttype == PKT_USER_ID) {
1894             /* do we have this in the original keyblock */
1895             for(onode=keyblock_orig->next; onode; onode=onode->next )
1896                 if( onode->pkt->pkttype == PKT_USER_ID
1897                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1898                                       node->pkt->pkt.user_id ) )
1899                     break;
1900             if( !onode ) { /* this is a new user id: append */
1901                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1902                 if( rc )
1903                     return rc;
1904                 ++*n_uids;
1905             }
1906         }
1907     }
1908
1909     /* 5th: add new subkeys */
1910     for(node=keyblock->next; node; node=node->next ) {
1911         onode = NULL;
1912         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1913             /* do we have this in the original keyblock? */
1914             for(onode=keyblock_orig->next; onode; onode=onode->next )
1915                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1916                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1917                                          node->pkt->pkt.public_key ) )
1918                     break;
1919             if( !onode ) { /* this is a new subkey: append */
1920                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1921                 if( rc )
1922                     return rc;
1923                 ++*n_subk;
1924             }
1925         }
1926         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1927             /* do we have this in the original keyblock? */
1928             for(onode=keyblock_orig->next; onode; onode=onode->next )
1929                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1930                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1931                                          node->pkt->pkt.secret_key ) )
1932                     break;
1933             if( !onode ) { /* this is a new subkey: append */
1934                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1935                 if( rc )
1936                     return rc;
1937                 ++*n_subk;
1938             }
1939         }
1940     }
1941
1942     /* 6th: merge subkey certificates */
1943     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1944         if( !(onode->flag & 1)
1945             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1946                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1947             /* find the subkey in the imported keyblock */
1948             for(node=keyblock->next; node; node=node->next ) {
1949                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1950                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1951                                           node->pkt->pkt.public_key ) )
1952                     break;
1953                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1954                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1955                                           node->pkt->pkt.secret_key ) )
1956                     break;
1957             }
1958             if( node ) { /* found: merge */
1959                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1960                 if( rc )
1961                     return rc;
1962             }
1963         }
1964     }
1965
1966
1967     return 0;
1968 }
1969
1970
1971 /****************
1972  * append the userid starting with NODE and all signatures to KEYBLOCK.
1973  */
1974 static int
1975 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1976                                           const char *fname, u32 *keyid )
1977 {
1978     KBNODE n, n_where=NULL;
1979
1980     assert(node->pkt->pkttype == PKT_USER_ID );
1981
1982     /* find the position */
1983     for( n = keyblock; n; n_where = n, n = n->next ) {
1984         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1985             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1986             break;
1987     }
1988     if( !n )
1989         n_where = NULL;
1990
1991     /* and append/insert */
1992     while( node ) {
1993         /* we add a clone to the original keyblock, because this
1994          * one is released first */
1995         n = clone_kbnode(node);
1996         if( n_where ) {
1997             insert_kbnode( n_where, n, 0 );
1998             n_where = n;
1999         }
2000         else
2001             add_kbnode( keyblock, n );
2002         n->flag |= 1;
2003         node->flag |= 1;
2004         if( n->pkt->pkttype == PKT_SIGNATURE )
2005             ++*n_sigs;
2006
2007         node = node->next;
2008         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2009             break;
2010     }
2011
2012     return 0;
2013 }
2014
2015
2016 /****************
2017  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2018  * (how should we handle comment packets here?)
2019  */
2020 static int
2021 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2022                                     const char *fname, u32 *keyid )
2023 {
2024     KBNODE n, n2;
2025     int found=0;
2026
2027     assert(dst->pkt->pkttype == PKT_USER_ID );
2028     assert(src->pkt->pkttype == PKT_USER_ID );
2029
2030     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2031         if( n->pkt->pkttype != PKT_SIGNATURE )
2032             continue;
2033         if( n->pkt->pkt.signature->sig_class == 0x18
2034             || n->pkt->pkt.signature->sig_class == 0x28 )
2035             continue; /* skip signatures which are only valid on subkeys */
2036         found = 0;
2037         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2038           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2039             {
2040               found++;
2041               break;
2042             }
2043         if( !found ) {
2044             /* This signature is new or newer, append N to DST.
2045              * We add a clone to the original keyblock, because this
2046              * one is released first */
2047             n2 = clone_kbnode(n);
2048             insert_kbnode( dst, n2, PKT_SIGNATURE );
2049             n2->flag |= 1;
2050             n->flag |= 1;
2051             ++*n_sigs;
2052         }
2053     }
2054
2055     return 0;
2056 }
2057
2058 /****************
2059  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2060  */
2061 static int
2062 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2063                                     const char *fname, u32 *keyid )
2064 {
2065     KBNODE n, n2;
2066     int found=0;
2067
2068     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2069            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2070
2071     for(n=src->next; n ; n = n->next ) {
2072         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2073             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2074             break;
2075         if( n->pkt->pkttype != PKT_SIGNATURE )
2076             continue;
2077         found = 0;
2078         for(n2=dst->next; n2; n2 = n2->next){
2079             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2080                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2081                 break;
2082             if( n2->pkt->pkttype == PKT_SIGNATURE
2083                 && n->pkt->pkt.signature->keyid[0]
2084                    == n2->pkt->pkt.signature->keyid[0]
2085                 && n->pkt->pkt.signature->keyid[1]
2086                    == n2->pkt->pkt.signature->keyid[1]
2087                 && n->pkt->pkt.signature->timestamp
2088                    <= n2->pkt->pkt.signature->timestamp
2089                 && n->pkt->pkt.signature->sig_class
2090                    == n2->pkt->pkt.signature->sig_class ) {
2091                 found++;
2092                 break;
2093             }
2094         }
2095         if( !found ) {
2096             /* This signature is new or newer, append N to DST.
2097              * We add a clone to the original keyblock, because this
2098              * one is released first */
2099             n2 = clone_kbnode(n);
2100             insert_kbnode( dst, n2, PKT_SIGNATURE );
2101             n2->flag |= 1;
2102             n->flag |= 1;
2103             ++*n_sigs;
2104         }
2105     }
2106
2107     return 0;
2108 }
2109
2110 /****************
2111  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2112  * Mark all new and copied packets by setting flag bit 0.
2113  */
2114 static int
2115 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2116                                           const char *fname, u32 *keyid )
2117 {
2118     KBNODE n;
2119
2120     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2121            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2122
2123     while(  node ) {
2124         /* we add a clone to the original keyblock, because this
2125          * one is released first */
2126         n = clone_kbnode(node);
2127         add_kbnode( keyblock, n );
2128         n->flag |= 1;
2129         node->flag |= 1;
2130         if( n->pkt->pkttype == PKT_SIGNATURE )
2131             ++*n_sigs;
2132
2133         node = node->next;
2134         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2135             break;
2136     }
2137
2138     return 0;
2139 }
2140
2141
2142
2143 /* Walk a public keyblock and produce a secret keyblock out of it.
2144    Instead of inserting the secret key parameters (which we don't
2145    have), we insert a stub.  */
2146 static KBNODE
2147 pub_to_sec_keyblock (KBNODE pub_keyblock)
2148 {
2149   KBNODE pubnode, secnode;
2150   KBNODE sec_keyblock = NULL;
2151   KBNODE walkctx = NULL;
2152
2153   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2154     {
2155       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2156           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2157         {
2158           /* Make a secret key.  We only need to convert enough to
2159              write the keyblock out. */
2160           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2161           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2162           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2163           int i, n;
2164           
2165           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2166             pkt->pkttype = PKT_SECRET_KEY;
2167           else
2168             pkt->pkttype = PKT_SECRET_SUBKEY;
2169           
2170           pkt->pkt.secret_key = sk;
2171
2172           copy_public_parts_to_secret_key ( pk, sk );
2173           sk->version     = pk->version;
2174           sk->timestamp   = pk->timestamp;
2175         
2176           n = pubkey_get_npkey (pk->pubkey_algo);
2177           if (!n)
2178             n = 1; /* Unknown number of parameters, however the data
2179                       is stored in the first mpi. */
2180           for (i=0; i < n; i++ )
2181             sk->skey[i] = mpi_copy (pk->pkey[i]);
2182   
2183           sk->is_protected = 1;
2184           sk->protect.s2k.mode = 1001;
2185   
2186           secnode = new_kbnode (pkt);
2187         }
2188       else
2189         {
2190           secnode = clone_kbnode (pubnode);
2191         }
2192       
2193       if(!sec_keyblock)
2194         sec_keyblock = secnode;
2195       else
2196         add_kbnode (sec_keyblock, secnode);
2197     }
2198
2199   return sec_keyblock;
2200 }
2201
2202
2203 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2204    stub keys with the serial number SNNUM of the card if one of the
2205    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2206    a duplicate (may happen in case of backed uped keys). 
2207    
2208    Returns: True if anything changed.
2209 */
2210 static int
2211 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2212                                    const unsigned char *fpr1,
2213                                    const unsigned char *fpr2,
2214                                    const unsigned char *fpr3,
2215                                    const char *serialnostr)
2216 {
2217   KBNODE node;
2218   KBNODE walkctx = NULL;
2219   PKT_secret_key *sk;
2220   byte array[MAX_FINGERPRINT_LEN];
2221   size_t n;
2222   int result = 0;
2223   const char *s;
2224
2225   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2226     {
2227       if (node->pkt->pkttype != PKT_SECRET_KEY
2228           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2229         continue;
2230       sk = node->pkt->pkt.secret_key;
2231       
2232       fingerprint_from_sk (sk, array, &n);
2233       if (n != 20)
2234         continue; /* Can't be a card key.  */
2235       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2236              || (fpr2 && !memcmp (array, fpr2, 20))
2237              || (fpr3 && !memcmp (array, fpr3, 20))) )
2238         continue;  /* No match.  */
2239
2240       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2241         {
2242           /* Standard case: migrate that stub to a key stub.  */
2243           sk->protect.s2k.mode = 1002;
2244           s = serialnostr;
2245           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2246                sk->protect.ivlen++, s += 2)
2247             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2248           result = 1;
2249         }
2250       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2251         {
2252           s = serialnostr;
2253           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2254                sk->protect.ivlen++, s += 2)
2255             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2256               {
2257                 log_info (_("NOTE: a key's S/N does not "
2258                             "match the card's one\n"));
2259                 break;
2260               }
2261         }
2262       else
2263         {
2264           if (node->pkt->pkttype != PKT_SECRET_KEY)
2265             log_info (_("NOTE: primary key is online and stored on card\n"));
2266           else
2267             log_info (_("NOTE: secondary key is online and stored on card\n"));
2268         }
2269     }
2270
2271   return result;
2272 }
2273
2274
2275
2276 /* Check whether a secret key stub exists for the public key PK.  If
2277    not create such a stub key and store it into the secring.  If it
2278    exists, add appropriate subkey stubs and update the secring.
2279    Return 0 if the key could be created. */
2280 int
2281 auto_create_card_key_stub ( const char *serialnostr, 
2282                             const unsigned char *fpr1,
2283                             const unsigned char *fpr2,
2284                             const unsigned char *fpr3)
2285 {
2286   KBNODE pub_keyblock;
2287   KBNODE sec_keyblock;
2288   KEYDB_HANDLE hd;
2289   int rc;
2290
2291   /* We only want to do this for an OpenPGP card.  */
2292   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2293       || strlen (serialnostr) != 32 )
2294     return G10ERR_GENERAL;
2295
2296   /* First get the public keyring from any of the provided fingerprints. */
2297   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2298        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2299        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2300     ;
2301   else
2302     return G10ERR_GENERAL;
2303  
2304   hd = keydb_new (1);
2305
2306   /* Now check whether there is a secret keyring.  */
2307   {
2308     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2309     byte afp[MAX_FINGERPRINT_LEN];
2310     size_t an;
2311
2312     fingerprint_from_pk (pk, afp, &an);
2313     memset (afp, 0, MAX_FINGERPRINT_LEN);
2314     rc = keydb_search_fpr (hd, afp);
2315   }
2316
2317   if (!rc)
2318     {
2319       rc = keydb_get_keyblock (hd, &sec_keyblock);
2320       if (rc)
2321         {
2322           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2323           rc = G10ERR_GENERAL;
2324         }
2325       else
2326         {
2327           merge_keys_and_selfsig (sec_keyblock);
2328           
2329           /* FIXME: We need to add new subkeys first.  */
2330           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2331                                                  fpr1, fpr2, fpr3,
2332                                                  serialnostr))
2333             {
2334               rc = keydb_update_keyblock (hd, sec_keyblock );
2335               if (rc)
2336                 log_error (_("error writing keyring `%s': %s\n"),
2337                            keydb_get_resource_name (hd), g10_errstr(rc) );
2338             }
2339         }
2340     }
2341   else  /* A secret key does not exists - create it.  */
2342     {
2343       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2344       update_sec_keyblock_with_cardinfo (sec_keyblock,
2345                                          fpr1, fpr2, fpr3,
2346                                          serialnostr);
2347
2348       rc = keydb_locate_writable (hd, NULL);
2349       if (rc)
2350         {
2351           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2352           rc = G10ERR_GENERAL;
2353         }
2354       else
2355         {
2356           rc = keydb_insert_keyblock (hd, sec_keyblock );
2357           if (rc)
2358             log_error (_("error writing keyring `%s': %s\n"),
2359                        keydb_get_resource_name (hd), g10_errstr(rc) );
2360         }
2361     }
2362     
2363   release_kbnode (sec_keyblock);
2364   release_kbnode (pub_keyblock);
2365   keydb_release (hd);
2366   return rc;
2367 }
2368