* keygen.c (proc_parameter_file): Default key and subkey usage flags to
[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-sigs",IMPORT_CLEAN_SIGS,NULL,
105        N_("remove unusable signatures after import")},
106       {"import-clean-uids",IMPORT_CLEAN_UIDS,NULL,
107        N_("remove unusable user IDs after import")},
108       {"import-clean",IMPORT_CLEAN_SIGS|IMPORT_CLEAN_UIDS,NULL,
109        N_("all import-clean-* options from above")},
110       /* Aliases for backward compatibility */
111       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
112       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
113       /* dummy */
114       {"import-unusable-sigs",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 static int
670 clean_sigs_from_all_uids(KBNODE keyblock)
671 {
672   KBNODE uidnode;
673   int deleted=0;
674
675   for(uidnode=keyblock->next;uidnode;uidnode=uidnode->next)
676     if(uidnode->pkt->pkttype==PKT_USER_ID)
677       deleted+=clean_sigs_from_uid(keyblock,uidnode,opt.verbose);
678
679   return deleted;
680 }
681
682
683 /****************
684  * Try to import one keyblock.  Return an error only in serious cases, but
685  * never for an invalid keyblock.  It uses log_error to increase the
686  * internal errorcount, so that invalid input can be detected by programs
687  * which called g10.
688  */
689 static int
690 import_one( const char *fname, KBNODE keyblock,
691             struct stats_s *stats, unsigned int options )
692 {
693     PKT_public_key *pk;
694     PKT_public_key *pk_orig;
695     KBNODE node, uidnode;
696     KBNODE keyblock_orig = NULL;
697     u32 keyid[2];
698     int rc = 0;
699     int new_key = 0;
700     int mod_key = 0;
701     int non_self = 0;
702
703     /* get the key and print some info about it */
704     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
705     if( !node )
706         BUG();
707
708     pk = node->pkt->pkt.public_key;
709     keyid_from_pk( pk, keyid );
710     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
711
712     if( opt.verbose && !opt.interactive )
713       {
714         log_info( "pub  %4u%c/%s %s  ",
715                   nbits_from_pk( pk ),
716                   pubkey_letter( pk->pubkey_algo ),
717                   keystr_from_pk(pk), datestr_from_pk(pk) );
718         if( uidnode )
719           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
720                              uidnode->pkt->pkt.user_id->len );
721         putc('\n', stderr);
722       }
723
724     if( !uidnode )
725       {
726         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
727         return 0;
728       }
729     
730     if (opt.interactive) {
731         if(is_status_enabled())
732           print_import_check (pk, uidnode->pkt->pkt.user_id);
733         merge_keys_and_selfsig (keyblock);
734         tty_printf ("\n");
735         show_basic_key_info (keyblock);
736         tty_printf ("\n");
737         if (!cpr_get_answer_is_yes ("import.okay",
738                                     "Do you want to import this key? (y/N) "))
739             return 0;
740     }
741
742     /* Clean the key that we're about to import, to cut down on things
743        that we have to clean later.  This has no practical impact on
744        the end result, but does result in less logging which might
745        confuse the user. */
746     if(options&IMPORT_CLEAN_SIGS)
747       clean_sigs_from_all_uids(keyblock);
748
749     if(options&IMPORT_CLEAN_UIDS)
750       clean_uids_from_key(keyblock,opt.verbose);
751
752     clear_kbnode_flags( keyblock );
753
754     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
755        && opt.verbose)
756       log_info(_("key %s: PKS subkey corruption repaired\n"),
757                keystr_from_pk(pk));
758
759     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
760     if( rc )
761         return rc== -1? 0:rc;
762
763     /* If we allow such a thing, mark unsigned uids as valid */
764     if( opt.allow_non_selfsigned_uid )
765       for( node=keyblock; node; node = node->next )
766         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
767           {
768             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
769                                       node->pkt->pkt.user_id->len,0);
770             node->flag |= 1;
771             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
772                       keystr_from_pk(pk),user);
773             xfree(user);
774           }
775
776     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
777         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
778         if( !opt.quiet )
779           log_info(_("this may be caused by a missing self-signature\n"));
780         stats->no_user_id++;
781         return 0;
782     }
783
784     /* do we have this key already in one of our pubrings ? */
785     pk_orig = xmalloc_clear( sizeof *pk_orig );
786     rc = get_pubkey_fast ( pk_orig, keyid );
787     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
788       {
789         log_error( _("key %s: public key not found: %s\n"),
790                    keystr(keyid), g10_errstr(rc));
791       }
792     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
793       {
794         if( opt.verbose )
795           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
796         rc = 0;
797         stats->skipped_new_keys++;
798       }
799     else if( rc ) { /* insert this key */
800         KEYDB_HANDLE hd = keydb_new (0);
801
802         rc = keydb_locate_writable (hd, NULL);
803         if (rc) {
804             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
805             keydb_release (hd);
806             return G10ERR_GENERAL;
807         }
808         if( opt.verbose > 1 )
809             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
810
811         collapse_uids(&keyblock);
812
813         rc = keydb_insert_keyblock (hd, keyblock );
814         if (rc)
815            log_error (_("error writing keyring `%s': %s\n"),
816                        keydb_get_resource_name (hd), g10_errstr(rc));
817         else
818           {
819             /* This should not be possible since we delete the
820                ownertrust when a key is deleted, but it can happen if
821                the keyring and trustdb are out of sync.  It can also
822                be made to happen with the trusted-key command. */
823
824             clear_ownertrusts (pk);
825             if(non_self)
826               revalidation_mark ();
827           }
828         keydb_release (hd);
829
830         /* we are ready */
831         if( !opt.quiet )
832           {
833             char *p=get_user_id_native (keyid);
834             log_info( _("key %s: public key \"%s\" imported\n"),
835                       keystr(keyid),p);
836             xfree(p);
837           }
838         if( is_status_enabled() )
839           {
840             char *us = get_long_user_id_string( keyid );
841             write_status_text( STATUS_IMPORTED, us );
842             xfree(us);
843             print_import_ok (pk,NULL, 1);
844           }
845         stats->imported++;
846         if( is_RSA( pk->pubkey_algo ) )
847             stats->imported_rsa++;
848         new_key = 1;
849     }
850     else { /* merge */
851         KEYDB_HANDLE hd;
852         int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
853
854         /* Compare the original against the new key; just to be sure nothing
855          * weird is going on */
856         if( cmp_public_keys( pk_orig, pk ) )
857           {
858             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
859             goto leave;
860           }
861
862         /* now read the original keyblock */
863         hd = keydb_new (0);
864         {
865             byte afp[MAX_FINGERPRINT_LEN];
866             size_t an;
867
868             fingerprint_from_pk (pk_orig, afp, &an);
869             while (an < MAX_FINGERPRINT_LEN) 
870                 afp[an++] = 0;
871             rc = keydb_search_fpr (hd, afp);
872         }
873         if( rc )
874           {
875             log_error (_("key %s: can't locate original keyblock: %s\n"),
876                        keystr(keyid), g10_errstr(rc));
877             keydb_release (hd);
878             goto leave;
879           }
880         rc = keydb_get_keyblock (hd, &keyblock_orig );
881         if (rc)
882           {
883             log_error (_("key %s: can't read original keyblock: %s\n"),
884                        keystr(keyid), g10_errstr(rc));
885             keydb_release (hd);
886             goto leave;
887           }
888
889         collapse_uids( &keyblock );
890         /* and try to merge the block */
891         clear_kbnode_flags( keyblock_orig );
892         clear_kbnode_flags( keyblock );
893         n_uids = n_sigs = n_subk = n_sigs_cleaned = n_uids_cleaned = 0;
894         rc = merge_blocks( fname, keyblock_orig, keyblock,
895                            keyid, &n_uids, &n_sigs, &n_subk );
896         if( rc )
897           {
898             keydb_release (hd);
899             goto leave;
900           }
901
902         if(options&IMPORT_CLEAN_SIGS)
903           n_sigs_cleaned=clean_sigs_from_all_uids(keyblock_orig);
904
905         if(options&IMPORT_CLEAN_UIDS)
906           n_uids_cleaned=clean_uids_from_key(keyblock_orig,opt.verbose);
907
908         if( n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned) {
909             mod_key = 1;
910             /* keyblock_orig has been updated; write */
911             rc = keydb_update_keyblock (hd, keyblock_orig);
912             if (rc)
913                 log_error (_("error writing keyring `%s': %s\n"),
914                              keydb_get_resource_name (hd), g10_errstr(rc) );
915             else if(non_self)
916               revalidation_mark ();
917
918             /* we are ready */
919             if( !opt.quiet )
920               {
921                 char *p=get_user_id_native(keyid);
922                 if( n_uids == 1 )
923                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
924                            keystr(keyid),p);
925                 else if( n_uids )
926                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
927                             keystr(keyid),p,n_uids);
928                 if( n_sigs == 1 )
929                   log_info( _("key %s: \"%s\" 1 new signature\n"),
930                             keystr(keyid), p);
931                 else if( n_sigs )
932                   log_info( _("key %s: \"%s\" %d new signatures\n"),
933                             keystr(keyid), p, n_sigs );
934                 if( n_subk == 1 )
935                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
936                             keystr(keyid), p);
937                 else if( n_subk )
938                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
939                             keystr(keyid), p, n_subk );
940                 if(n_sigs_cleaned==1)
941                   log_info(_("key %s: \"%s\" %d signature cleaned\n"),
942                            keystr(keyid),p,n_sigs_cleaned);
943                 else if(n_sigs_cleaned)
944                   log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
945                            keystr(keyid),p,n_sigs_cleaned);
946                 if(n_uids_cleaned==1)
947                   log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
948                            keystr(keyid),p,n_uids_cleaned);
949                 else if(n_uids_cleaned)
950                   log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
951                            keystr(keyid),p,n_uids_cleaned);
952                 xfree(p);
953               }
954
955             stats->n_uids +=n_uids;
956             stats->n_sigs +=n_sigs;
957             stats->n_subk +=n_subk;
958             stats->n_sigs_cleaned +=n_sigs_cleaned;
959             stats->n_uids_cleaned +=n_uids_cleaned;
960
961             if (is_status_enabled ()) 
962                  print_import_ok (pk, NULL,
963                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
964         }
965         else
966           {
967             if (is_status_enabled ()) 
968               print_import_ok (pk, NULL, 0);
969
970             if( !opt.quiet )
971               {
972                 char *p=get_user_id_native(keyid);
973                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
974                 xfree(p);
975               }
976
977             stats->unchanged++;
978           }
979
980         keydb_release (hd); hd = NULL;
981     }
982
983   leave:
984
985     /* Now that the key is definitely incorporated into the keydb, we
986        need to check if a designated revocation is present or if the
987        prefs are not rational so we can warn the user. */
988
989     if(mod_key)
990       {
991         revocation_present(keyblock_orig);
992         if(seckey_available(keyid)==0)
993           check_prefs(keyblock_orig);
994       }
995     else if(new_key)
996       {
997         revocation_present(keyblock);
998         if(seckey_available(keyid)==0)
999           check_prefs(keyblock);
1000       }
1001
1002     release_kbnode( keyblock_orig );
1003     free_public_key( pk_orig );
1004
1005     return rc;
1006 }
1007
1008 /* Walk a secret keyblock and produce a public keyblock out of it. */
1009 static KBNODE
1010 sec_to_pub_keyblock(KBNODE sec_keyblock)
1011 {
1012   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
1013
1014   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
1015     {
1016       KBNODE pubnode;
1017
1018       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
1019          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
1020         {
1021           /* Make a public key.  We only need to convert enough to
1022              write the keyblock out. */
1023
1024           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
1025           PACKET *pkt=xmalloc_clear(sizeof(PACKET));
1026           PKT_public_key *pk=xmalloc_clear(sizeof(PKT_public_key));
1027           int n;
1028
1029           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
1030             pkt->pkttype=PKT_PUBLIC_KEY;
1031           else
1032             pkt->pkttype=PKT_PUBLIC_SUBKEY;
1033
1034           pkt->pkt.public_key=pk;
1035
1036           pk->version=sk->version;
1037           pk->timestamp=sk->timestamp;
1038           pk->expiredate=sk->expiredate;
1039           pk->pubkey_algo=sk->pubkey_algo;
1040
1041           n=pubkey_get_npkey(pk->pubkey_algo);
1042           if(n==0)
1043             {
1044               /* we can't properly extract the pubkey without knowing
1045                  the number of MPIs */
1046               release_kbnode(pub_keyblock);
1047               return NULL;
1048             }
1049           else
1050             {
1051               int i;
1052
1053               for(i=0;i<n;i++)
1054                 pk->pkey[i]=mpi_copy(sk->skey[i]);
1055             }
1056
1057           pubnode=new_kbnode(pkt);
1058         }
1059       else
1060         {
1061           pubnode=clone_kbnode(secnode);
1062         }
1063
1064       if(pub_keyblock==NULL)
1065         pub_keyblock=pubnode;
1066       else
1067         add_kbnode(pub_keyblock,pubnode);
1068     }
1069
1070   return pub_keyblock;
1071 }
1072
1073 /****************
1074  * Ditto for secret keys.  Handling is simpler than for public keys.
1075  * We allow secret key importing only when allow is true, this is so
1076  * that a secret key can not be imported accidently and thereby tampering
1077  * with the trust calculation.
1078  */
1079 static int
1080 import_secret_one( const char *fname, KBNODE keyblock, 
1081                    struct stats_s *stats, unsigned int options)
1082 {
1083     PKT_secret_key *sk;
1084     KBNODE node, uidnode;
1085     u32 keyid[2];
1086     int rc = 0;
1087
1088     /* get the key and print some info about it */
1089     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1090     if( !node )
1091         BUG();
1092
1093     sk = node->pkt->pkt.secret_key;
1094     keyid_from_sk( sk, keyid );
1095     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1096
1097     if( opt.verbose )
1098       {
1099         log_info( "sec  %4u%c/%s %s   ",
1100                   nbits_from_sk( sk ),
1101                   pubkey_letter( sk->pubkey_algo ),
1102                   keystr_from_sk(sk), datestr_from_sk(sk) );
1103         if( uidnode )
1104           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1105                              uidnode->pkt->pkt.user_id->len );
1106         putc('\n', stderr);
1107       }
1108     stats->secret_read++;
1109
1110     if( !uidnode )
1111       {
1112         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1113         return 0;
1114       }
1115
1116     if(sk->protect.algo>110)
1117       {
1118         log_error(_("key %s: secret key with invalid cipher %d"
1119                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1120         return 0;
1121       }
1122
1123 #ifdef ENABLE_SELINUX_HACKS
1124     if (1)
1125       {
1126         /* We don't allow to import secret keys because that may be used
1127            to put a secret key into the keyring and the user might later
1128            be tricked into signing stuff with that key.  */
1129         log_error (_("importing secret keys not allowed\n"));
1130         return 0;
1131       }
1132 #endif 
1133     
1134     clear_kbnode_flags( keyblock );
1135
1136     /* do we have this key already in one of our secrings ? */
1137     rc = seckey_available( keyid );
1138     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1139       {
1140         /* simply insert this key */
1141         KEYDB_HANDLE hd = keydb_new (1);
1142
1143         /* get default resource */
1144         rc = keydb_locate_writable (hd, NULL);
1145         if (rc) {
1146           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1147           keydb_release (hd);
1148           return G10ERR_GENERAL;
1149         }
1150         rc = keydb_insert_keyblock (hd, keyblock );
1151         if (rc)
1152           log_error (_("error writing keyring `%s': %s\n"),
1153                      keydb_get_resource_name (hd), g10_errstr(rc) );
1154         keydb_release (hd);
1155         /* we are ready */
1156         if( !opt.quiet )
1157           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1158         stats->secret_imported++;
1159         if (is_status_enabled ()) 
1160           print_import_ok (NULL, sk, 1|16);
1161
1162         if(options&IMPORT_SK2PK)
1163           {
1164             /* Try and make a public key out of this. */
1165
1166             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1167             if(pub_keyblock)
1168               {
1169                 import_one(fname,pub_keyblock,stats,opt.import_options);
1170                 release_kbnode(pub_keyblock);
1171               }
1172           }
1173
1174         /* Now that the key is definitely incorporated into the keydb,
1175            if we have the public part of this key, we need to check if
1176            the prefs are rational. */
1177         node=get_pubkeyblock(keyid);
1178         if(node)
1179           {
1180             check_prefs(node);
1181             release_kbnode(node);
1182           }
1183       }
1184     else if( !rc )
1185       { /* we can't merge secret keys */
1186         log_error( _("key %s: already in secret keyring\n"),
1187                    keystr_from_sk(sk));
1188         stats->secret_dups++;
1189         if (is_status_enabled ()) 
1190           print_import_ok (NULL, sk, 16);
1191
1192         /* TODO: if we ever do merge secret keys, make sure to handle
1193            the sec_to_pub_keyblock feature as well. */
1194       }
1195     else
1196       log_error( _("key %s: secret key not found: %s\n"),
1197                  keystr_from_sk(sk), g10_errstr(rc));
1198
1199     return rc;
1200 }
1201
1202
1203 /****************
1204  * Import a revocation certificate; this is a single signature packet.
1205  */
1206 static int
1207 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1208 {
1209     PKT_public_key *pk=NULL;
1210     KBNODE onode, keyblock = NULL;
1211     KEYDB_HANDLE hd = NULL;
1212     u32 keyid[2];
1213     int rc = 0;
1214
1215     assert( !node->next );
1216     assert( node->pkt->pkttype == PKT_SIGNATURE );
1217     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1218
1219     keyid[0] = node->pkt->pkt.signature->keyid[0];
1220     keyid[1] = node->pkt->pkt.signature->keyid[1];
1221
1222     pk = xmalloc_clear( sizeof *pk );
1223     rc = get_pubkey( pk, keyid );
1224     if( rc == G10ERR_NO_PUBKEY )
1225       {
1226         log_error(_("key %s: no public key -"
1227                     " can't apply revocation certificate\n"), keystr(keyid));
1228         rc = 0;
1229         goto leave;
1230       }
1231     else if( rc )
1232       {
1233         log_error(_("key %s: public key not found: %s\n"),
1234                   keystr(keyid), g10_errstr(rc));
1235         goto leave;
1236       }
1237
1238     /* read the original keyblock */
1239     hd = keydb_new (0);
1240     {
1241         byte afp[MAX_FINGERPRINT_LEN];
1242         size_t an;
1243         
1244         fingerprint_from_pk (pk, afp, &an);
1245         while (an < MAX_FINGERPRINT_LEN) 
1246             afp[an++] = 0;
1247         rc = keydb_search_fpr (hd, afp);
1248     }
1249     if (rc)
1250       {
1251         log_error (_("key %s: can't locate original keyblock: %s\n"),
1252                    keystr(keyid), g10_errstr(rc));
1253         goto leave;
1254       }
1255     rc = keydb_get_keyblock (hd, &keyblock );
1256     if (rc)
1257       {
1258         log_error (_("key %s: can't read original keyblock: %s\n"),
1259                    keystr(keyid), g10_errstr(rc));
1260         goto leave;
1261       }
1262
1263     /* it is okay, that node is not in keyblock because
1264      * check_key_signature works fine for sig_class 0x20 in this
1265      * special case. */
1266     rc = check_key_signature( keyblock, node, NULL);
1267     if( rc )
1268       {
1269         log_error( _("key %s: invalid revocation certificate"
1270                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1271         goto leave;
1272       }
1273
1274     /* check whether we already have this */
1275     for(onode=keyblock->next; onode; onode=onode->next ) {
1276         if( onode->pkt->pkttype == PKT_USER_ID )
1277             break;
1278         else if( onode->pkt->pkttype == PKT_SIGNATURE
1279                  && !cmp_signatures(node->pkt->pkt.signature,
1280                                     onode->pkt->pkt.signature))
1281           {
1282             rc = 0;
1283             goto leave; /* yes, we already know about it */
1284           }
1285     }
1286
1287
1288     /* insert it */
1289     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1290
1291     /* and write the keyblock back */
1292     rc = keydb_update_keyblock (hd, keyblock );
1293     if (rc)
1294         log_error (_("error writing keyring `%s': %s\n"),
1295                    keydb_get_resource_name (hd), g10_errstr(rc) );
1296     keydb_release (hd); hd = NULL;
1297     /* we are ready */
1298     if( !opt.quiet )
1299       {
1300         char *p=get_user_id_native (keyid);
1301         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1302                   keystr(keyid),p);
1303         xfree(p);
1304       }
1305     stats->n_revoc++;
1306
1307     /* If the key we just revoked was ultimately trusted, remove its
1308        ultimate trust.  This doesn't stop the user from putting the
1309        ultimate trust back, but is a reasonable solution for now. */
1310     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1311       clear_ownertrusts(pk);
1312
1313     revalidation_mark ();
1314
1315   leave:
1316     keydb_release (hd);
1317     release_kbnode( keyblock );
1318     free_public_key( pk );
1319     return rc;
1320 }
1321
1322
1323 /****************
1324  * loop over the keyblock and check all self signatures.
1325  * Mark all user-ids with a self-signature by setting flag bit 0.
1326  * Mark all user-ids with an invalid self-signature by setting bit 1.
1327  * This works also for subkeys, here the subkey is marked.  Invalid or
1328  * extra subkey sigs (binding or revocation) are marked for deletion.
1329  * non_self is set to true if there are any sigs other than self-sigs
1330  * in this keyblock.
1331  */
1332 static int
1333 chk_self_sigs( const char *fname, KBNODE keyblock,
1334                PKT_public_key *pk, u32 *keyid, int *non_self )
1335 {
1336     KBNODE n,knode=NULL;
1337     PKT_signature *sig;
1338     int rc;
1339     u32 bsdate=0,rsdate=0;
1340     KBNODE bsnode=NULL,rsnode=NULL;
1341
1342     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1343       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1344         {
1345           knode=n;
1346           bsdate=0;
1347           rsdate=0;
1348           bsnode=NULL;
1349           rsnode=NULL;
1350           continue;
1351         }
1352       else if( n->pkt->pkttype != PKT_SIGNATURE )
1353             continue;
1354         sig = n->pkt->pkt.signature;
1355         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1356
1357             /* This just caches the sigs for later use.  That way we
1358                import a fully-cached key which speeds things up. */
1359             if(!opt.no_sig_cache)
1360               check_key_signature(keyblock,n,NULL);
1361
1362             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1363               {
1364                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1365                 if( !unode )
1366                   {
1367                     log_error( _("key %s: no user ID for signature\n"),
1368                                keystr(keyid));
1369                     return -1;  /* the complete keyblock is invalid */
1370                   }
1371
1372                 /* If it hasn't been marked valid yet, keep trying */
1373                 if(!(unode->flag&1)) {
1374                   rc = check_key_signature( keyblock, n, NULL);
1375                   if( rc )
1376                     {
1377                       if( opt.verbose )
1378                         {
1379                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1380                                       strlen(unode->pkt->pkt.user_id->name),0);
1381                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1382                                     _("key %s: unsupported public key "
1383                                       "algorithm on user ID \"%s\"\n"):
1384                                     _("key %s: invalid self-signature "
1385                                       "on user ID \"%s\"\n"),
1386                                     keystr(keyid),p);
1387                           xfree(p);
1388                         }
1389                     }
1390                   else
1391                     unode->flag |= 1; /* mark that signature checked */
1392                 }
1393               }
1394             else if( sig->sig_class == 0x18 ) {
1395               /* Note that this works based solely on the timestamps
1396                  like the rest of gpg.  If the standard gets
1397                  revocation targets, this may need to be revised. */
1398
1399                 if( !knode )
1400                   {
1401                     if(opt.verbose)
1402                       log_info( _("key %s: no subkey for key binding\n"),
1403                                 keystr(keyid));
1404                     n->flag |= 4; /* delete this */
1405                   }
1406                 else
1407                   {
1408                     rc = check_key_signature( keyblock, n, NULL);
1409                     if( rc )
1410                       {
1411                         if(opt.verbose)
1412                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1413                                    _("key %s: unsupported public key"
1414                                      " algorithm\n"):
1415                                    _("key %s: invalid subkey binding\n"),
1416                                    keystr(keyid));
1417                         n->flag|=4;
1418                       }
1419                     else
1420                       {
1421                         /* It's valid, so is it newer? */
1422                         if(sig->timestamp>=bsdate) {
1423                           knode->flag |= 1;  /* the subkey is valid */
1424                           if(bsnode)
1425                             {
1426                               bsnode->flag|=4; /* Delete the last binding
1427                                                   sig since this one is
1428                                                   newer */
1429                               if(opt.verbose)
1430                                 log_info(_("key %s: removed multiple subkey"
1431                                            " binding\n"),keystr(keyid));
1432                             }
1433
1434                           bsnode=n;
1435                           bsdate=sig->timestamp;
1436                         }
1437                         else
1438                           n->flag|=4; /* older */
1439                       }
1440                   }
1441             }
1442             else if( sig->sig_class == 0x28 ) {
1443               /* We don't actually mark the subkey as revoked right
1444                  now, so just check that the revocation sig is the
1445                  most recent valid one.  Note that we don't care if
1446                  the binding sig is newer than the revocation sig.
1447                  See the comment in getkey.c:merge_selfsigs_subkey for
1448                  more */
1449                 if( !knode )
1450                   {
1451                     if(opt.verbose)
1452                       log_info( _("key %s: no subkey for key revocation\n"),
1453                                 keystr(keyid));
1454                     n->flag |= 4; /* delete this */
1455                   }
1456                 else
1457                   {
1458                     rc = check_key_signature( keyblock, n, NULL);
1459                     if( rc )
1460                       {
1461                         if(opt.verbose)
1462                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1463                                    _("key %s: unsupported public"
1464                                      " key algorithm\n"):
1465                                    _("key %s: invalid subkey revocation\n"),
1466                                    keystr(keyid));
1467                         n->flag|=4;
1468                       }
1469                     else
1470                       {
1471                         /* It's valid, so is it newer? */
1472                         if(sig->timestamp>=rsdate)
1473                           {
1474                             if(rsnode)
1475                               {
1476                                 rsnode->flag|=4; /* Delete the last revocation
1477                                                     sig since this one is
1478                                                     newer */
1479                                 if(opt.verbose)
1480                                   log_info(_("key %s: removed multiple subkey"
1481                                              " revocation\n"),keystr(keyid));
1482                               }
1483
1484                             rsnode=n;
1485                             rsdate=sig->timestamp;
1486                           }
1487                         else
1488                           n->flag|=4; /* older */
1489                       }
1490                   }
1491             }
1492         }
1493         else
1494           *non_self=1;
1495     }
1496
1497     return 0;
1498 }
1499
1500 /****************
1501  * delete all parts which are invalid and those signatures whose
1502  * public key algorithm is not available in this implemenation;
1503  * but consider RSA as valid, because parse/build_packets knows
1504  * about it.
1505  * returns: true if at least one valid user-id is left over.
1506  */
1507 static int
1508 delete_inv_parts( const char *fname, KBNODE keyblock,
1509                   u32 *keyid, unsigned int options)
1510 {
1511     KBNODE node;
1512     int nvalid=0, uid_seen=0, subkey_seen=0;
1513
1514     for(node=keyblock->next; node; node = node->next ) {
1515         if( node->pkt->pkttype == PKT_USER_ID ) {
1516             uid_seen = 1;
1517             if( (node->flag & 2) || !(node->flag & 1) ) {
1518                 if( opt.verbose )
1519                   {
1520                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1521                                            node->pkt->pkt.user_id->len,0);
1522                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1523                               keystr(keyid),p);
1524                     xfree(p);
1525                   }
1526                 delete_kbnode( node ); /* the user-id */
1527                 /* and all following packets up to the next user-id */
1528                 while( node->next
1529                        && node->next->pkt->pkttype != PKT_USER_ID
1530                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1531                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1532                     delete_kbnode( node->next );
1533                     node = node->next;
1534                 }
1535             }
1536             else
1537                 nvalid++;
1538         }
1539         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1540                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1541             if( (node->flag & 2) || !(node->flag & 1) ) {
1542                 if( opt.verbose )
1543                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1544
1545                 delete_kbnode( node ); /* the subkey */
1546                 /* and all following signature packets */
1547                 while( node->next
1548                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1549                     delete_kbnode( node->next );
1550                     node = node->next;
1551                 }
1552             }
1553             else
1554               subkey_seen = 1;
1555         }
1556         else if( node->pkt->pkttype == PKT_SIGNATURE
1557                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1558                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1559             delete_kbnode( node ); /* build_packet() can't handle this */
1560         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1561                  !node->pkt->pkt.signature->flags.exportable &&
1562                  !(options&IMPORT_LOCAL_SIGS) &&
1563                  seckey_available( node->pkt->pkt.signature->keyid ) )
1564           {
1565             /* here we violate the rfc a bit by still allowing
1566              * to import non-exportable signature when we have the
1567              * the secret key used to create this signature - it
1568              * seems that this makes sense */
1569             if(opt.verbose)
1570               log_info( _("key %s: non exportable signature"
1571                           " (class 0x%02X) - skipped\n"),
1572                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1573             delete_kbnode( node );
1574           }
1575         else if( node->pkt->pkttype == PKT_SIGNATURE
1576                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1577             if( uid_seen )
1578               {
1579                 if(opt.verbose)
1580                   log_info( _("key %s: revocation certificate"
1581                               " at wrong place - skipped\n"),keystr(keyid));
1582                 delete_kbnode( node );
1583               }
1584             else {
1585               /* If the revocation cert is from a different key than
1586                  the one we're working on don't check it - it's
1587                  probably from a revocation key and won't be
1588                  verifiable with this key anyway. */
1589
1590               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1591                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1592                 {
1593                   int rc = check_key_signature( keyblock, node, NULL);
1594                   if( rc )
1595                     {
1596                       if(opt.verbose)
1597                         log_info( _("key %s: invalid revocation"
1598                                     " certificate: %s - skipped\n"),
1599                                   keystr(keyid), g10_errstr(rc));
1600                       delete_kbnode( node );
1601                     }
1602                 }
1603             }
1604         }
1605         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1606                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1607                   node->pkt->pkt.signature->sig_class == 0x28) &&
1608                  !subkey_seen )
1609           {
1610             if(opt.verbose)
1611               log_info( _("key %s: subkey signature"
1612                           " in wrong place - skipped\n"), keystr(keyid));
1613             delete_kbnode( node );
1614           }
1615         else if( node->pkt->pkttype == PKT_SIGNATURE
1616                  && !IS_CERT(node->pkt->pkt.signature))
1617           {
1618             if(opt.verbose)
1619               log_info(_("key %s: unexpected signature class (0x%02X) -"
1620                          " skipped\n"),keystr(keyid),
1621                        node->pkt->pkt.signature->sig_class);
1622             delete_kbnode(node);
1623           }
1624         else if( (node->flag & 4) ) /* marked for deletion */
1625           delete_kbnode( node );
1626     }
1627
1628     /* note: because keyblock is the public key, it is never marked
1629      * for deletion and so keyblock cannot change */
1630     commit_kbnode( &keyblock );
1631     return nvalid;
1632 }
1633
1634
1635 /****************
1636  * It may happen that the imported keyblock has duplicated user IDs.
1637  * We check this here and collapse those user IDs together with their
1638  * sigs into one.
1639  * Returns: True if the keyblock hash changed.
1640  */
1641 int
1642 collapse_uids( KBNODE *keyblock )
1643 {
1644     KBNODE n, n2;
1645     int in_uid;
1646     int any=0;
1647
1648   restart:
1649     for( n = *keyblock; n; n = n->next ) {
1650         if( n->pkt->pkttype != PKT_USER_ID )
1651             continue;
1652         for( n2 = n->next; n2; n2 = n2->next ) {
1653             if( n2->pkt->pkttype == PKT_USER_ID
1654                 && !cmp_user_ids( n->pkt->pkt.user_id,
1655                                   n2->pkt->pkt.user_id ) ) {
1656                 /* found a duplicate */
1657                 any = 1;
1658                 if( !n2->next
1659                     || n2->next->pkt->pkttype == PKT_USER_ID
1660                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1661                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1662                     /* no more signatures: delete the user ID
1663                      * and start over */
1664                     remove_kbnode( keyblock, n2 );
1665                 }
1666                 else {
1667                     /* The simple approach: Move one signature and
1668                      * then start over to delete the next one :-( */
1669                     move_kbnode( keyblock, n2->next, n->next );
1670                 }
1671                 goto restart;
1672             }
1673         }
1674     }
1675     if( !any )
1676         return 0;
1677
1678   restart_sig:
1679     /* now we may have duplicate signatures on one user ID: fix this */
1680     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1681         if( n->pkt->pkttype == PKT_USER_ID )
1682             in_uid = 1;
1683         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1684                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1685             in_uid = 0;
1686         else if( in_uid ) {
1687             n2 = n;
1688             do {
1689                 KBNODE ncmp = NULL;
1690                 for( ; n2; n2 = n2->next ) {
1691                     if(    n2->pkt->pkttype == PKT_USER_ID
1692                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1693                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1694                         break;
1695                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1696                         ;
1697                     else if( !ncmp )
1698                         ncmp = n2;
1699                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1700                                                 n2->pkt->pkt.signature )) {
1701                         remove_kbnode( keyblock, n2 );
1702                         goto restart_sig;
1703                     }
1704                 }
1705                 n2 = ncmp? ncmp->next : NULL;
1706             } while( n2 );
1707         }
1708     }
1709
1710     if(!opt.quiet)
1711       {
1712         const char *key="???";
1713
1714         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1715           key=keystr_from_pk(n->pkt->pkt.public_key);
1716         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1717           key=keystr_from_sk(n->pkt->pkt.secret_key);
1718
1719         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1720       }
1721
1722     return 1;
1723 }
1724
1725 /* Check for a 0x20 revocation from a revocation key that is not
1726    present.  This may be called without the benefit of merge_xxxx so
1727    you can't rely on pk->revkey and friends. */
1728 static void
1729 revocation_present(KBNODE keyblock)
1730 {
1731   KBNODE onode,inode;
1732   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1733
1734   for(onode=keyblock->next;onode;onode=onode->next)
1735     {
1736       /* If we reach user IDs, we're done. */
1737       if(onode->pkt->pkttype==PKT_USER_ID)
1738         break;
1739
1740       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1741          onode->pkt->pkt.signature->sig_class==0x1F &&
1742          onode->pkt->pkt.signature->revkey)
1743         {
1744           int idx;
1745           PKT_signature *sig=onode->pkt->pkt.signature;
1746
1747           for(idx=0;idx<sig->numrevkeys;idx++)
1748             {
1749               u32 keyid[2];
1750
1751               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1752                                      MAX_FINGERPRINT_LEN,keyid);
1753
1754               for(inode=keyblock->next;inode;inode=inode->next)
1755                 {
1756                   /* If we reach user IDs, we're done. */
1757                   if(inode->pkt->pkttype==PKT_USER_ID)
1758                     break;
1759
1760                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1761                      inode->pkt->pkt.signature->sig_class==0x20 &&
1762                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1763                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1764                     {
1765                       /* Okay, we have a revocation key, and a
1766                          revocation issued by it.  Do we have the key
1767                          itself? */
1768                       int rc;
1769
1770                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1771                                                    MAX_FINGERPRINT_LEN);
1772                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1773                         {
1774                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1775
1776                           /* No, so try and get it */
1777                           if(opt.keyserver
1778                              && (opt.keyserver_options.options
1779                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1780                             {
1781                               log_info(_("WARNING: key %s may be revoked:"
1782                                          " fetching revocation key %s\n"),
1783                                        tempkeystr,keystr(keyid));
1784                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1785                                                       MAX_FINGERPRINT_LEN,
1786                                                       opt.keyserver);
1787
1788                               /* Do we have it now? */
1789                               rc=get_pubkey_byfprint_fast (NULL,
1790                                                      sig->revkey[idx]->fpr,
1791                                                      MAX_FINGERPRINT_LEN);
1792                             }
1793
1794                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1795                             log_info(_("WARNING: key %s may be revoked:"
1796                                        " revocation key %s not present.\n"),
1797                                      tempkeystr,keystr(keyid));
1798
1799                           xfree(tempkeystr);
1800                         }
1801                     }
1802                 }
1803             }
1804         }
1805     }
1806 }
1807
1808 /****************
1809  * compare and merge the blocks
1810  *
1811  * o compare the signatures: If we already have this signature, check
1812  *   that they compare okay; if not, issue a warning and ask the user.
1813  * o Simply add the signature.  Can't verify here because we may not have
1814  *   the signature's public key yet; verification is done when putting it
1815  *   into the trustdb, which is done automagically as soon as this pubkey
1816  *   is used.
1817  * Note: We indicate newly inserted packets with flag bit 0
1818  */
1819 static int
1820 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1821               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1822 {
1823     KBNODE onode, node;
1824     int rc, found;
1825
1826     /* 1st: handle revocation certificates */
1827     for(node=keyblock->next; node; node=node->next ) {
1828         if( node->pkt->pkttype == PKT_USER_ID )
1829             break;
1830         else if( node->pkt->pkttype == PKT_SIGNATURE
1831                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1832             /* check whether we already have this */
1833             found = 0;
1834             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1835                 if( onode->pkt->pkttype == PKT_USER_ID )
1836                     break;
1837                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1838                          && onode->pkt->pkt.signature->sig_class == 0x20
1839                          && !cmp_signatures(onode->pkt->pkt.signature,
1840                                             node->pkt->pkt.signature))
1841                   {
1842                     found = 1;
1843                     break;
1844                   }
1845             }
1846             if( !found ) {
1847                 KBNODE n2 = clone_kbnode(node);
1848                 insert_kbnode( keyblock_orig, n2, 0 );
1849                 n2->flag |= 1;
1850                 ++*n_sigs;
1851                 if(!opt.quiet)
1852                   {
1853                     char *p=get_user_id_native (keyid);
1854                     log_info(_("key %s: \"%s\" revocation"
1855                                " certificate added\n"), keystr(keyid),p);
1856                     xfree(p);
1857                   }
1858             }
1859         }
1860     }
1861
1862     /* 2nd: merge in any direct key (0x1F) sigs */
1863     for(node=keyblock->next; node; node=node->next ) {
1864         if( node->pkt->pkttype == PKT_USER_ID )
1865             break;
1866         else if( node->pkt->pkttype == PKT_SIGNATURE
1867                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1868             /* check whether we already have this */
1869             found = 0;
1870             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1871                 if( onode->pkt->pkttype == PKT_USER_ID )
1872                     break;
1873                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1874                          && onode->pkt->pkt.signature->sig_class == 0x1F
1875                          && !cmp_signatures(onode->pkt->pkt.signature,
1876                                             node->pkt->pkt.signature)) {
1877                     found = 1;
1878                     break;
1879                 }
1880             }
1881             if( !found )
1882               {
1883                 KBNODE n2 = clone_kbnode(node);
1884                 insert_kbnode( keyblock_orig, n2, 0 );
1885                 n2->flag |= 1;
1886                 ++*n_sigs;
1887                 if(!opt.quiet)
1888                   log_info( _("key %s: direct key signature added\n"),
1889                             keystr(keyid));
1890               }
1891         }
1892     }
1893
1894     /* 3rd: try to merge new certificates in */
1895     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1896         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1897             /* find the user id in the imported keyblock */
1898             for(node=keyblock->next; node; node=node->next )
1899                 if( node->pkt->pkttype == PKT_USER_ID
1900                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1901                                           node->pkt->pkt.user_id ) )
1902                     break;
1903             if( node ) { /* found: merge */
1904                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1905                 if( rc )
1906                     return rc;
1907             }
1908         }
1909     }
1910
1911     /* 4th: add new user-ids */
1912     for(node=keyblock->next; node; node=node->next ) {
1913         if( node->pkt->pkttype == PKT_USER_ID) {
1914             /* do we have this in the original keyblock */
1915             for(onode=keyblock_orig->next; onode; onode=onode->next )
1916                 if( onode->pkt->pkttype == PKT_USER_ID
1917                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1918                                       node->pkt->pkt.user_id ) )
1919                     break;
1920             if( !onode ) { /* this is a new user id: append */
1921                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1922                 if( rc )
1923                     return rc;
1924                 ++*n_uids;
1925             }
1926         }
1927     }
1928
1929     /* 5th: add new subkeys */
1930     for(node=keyblock->next; node; node=node->next ) {
1931         onode = NULL;
1932         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1933             /* do we have this in the original keyblock? */
1934             for(onode=keyblock_orig->next; onode; onode=onode->next )
1935                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1936                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1937                                          node->pkt->pkt.public_key ) )
1938                     break;
1939             if( !onode ) { /* this is a new subkey: append */
1940                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1941                 if( rc )
1942                     return rc;
1943                 ++*n_subk;
1944             }
1945         }
1946         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1947             /* do we have this in the original keyblock? */
1948             for(onode=keyblock_orig->next; onode; onode=onode->next )
1949                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1950                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1951                                          node->pkt->pkt.secret_key ) )
1952                     break;
1953             if( !onode ) { /* this is a new subkey: append */
1954                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1955                 if( rc )
1956                     return rc;
1957                 ++*n_subk;
1958             }
1959         }
1960     }
1961
1962     /* 6th: merge subkey certificates */
1963     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1964         if( !(onode->flag & 1)
1965             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1966                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1967             /* find the subkey in the imported keyblock */
1968             for(node=keyblock->next; node; node=node->next ) {
1969                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1970                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1971                                           node->pkt->pkt.public_key ) )
1972                     break;
1973                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1974                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1975                                           node->pkt->pkt.secret_key ) )
1976                     break;
1977             }
1978             if( node ) { /* found: merge */
1979                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1980                 if( rc )
1981                     return rc;
1982             }
1983         }
1984     }
1985
1986
1987     return 0;
1988 }
1989
1990
1991 /****************
1992  * append the userid starting with NODE and all signatures to KEYBLOCK.
1993  */
1994 static int
1995 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1996                                           const char *fname, u32 *keyid )
1997 {
1998     KBNODE n, n_where=NULL;
1999
2000     assert(node->pkt->pkttype == PKT_USER_ID );
2001
2002     /* find the position */
2003     for( n = keyblock; n; n_where = n, n = n->next ) {
2004         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2005             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2006             break;
2007     }
2008     if( !n )
2009         n_where = NULL;
2010
2011     /* and append/insert */
2012     while( node ) {
2013         /* we add a clone to the original keyblock, because this
2014          * one is released first */
2015         n = clone_kbnode(node);
2016         if( n_where ) {
2017             insert_kbnode( n_where, n, 0 );
2018             n_where = n;
2019         }
2020         else
2021             add_kbnode( keyblock, n );
2022         n->flag |= 1;
2023         node->flag |= 1;
2024         if( n->pkt->pkttype == PKT_SIGNATURE )
2025             ++*n_sigs;
2026
2027         node = node->next;
2028         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2029             break;
2030     }
2031
2032     return 0;
2033 }
2034
2035
2036 /****************
2037  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2038  * (how should we handle comment packets here?)
2039  */
2040 static int
2041 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2042                                     const char *fname, u32 *keyid )
2043 {
2044     KBNODE n, n2;
2045     int found=0;
2046
2047     assert(dst->pkt->pkttype == PKT_USER_ID );
2048     assert(src->pkt->pkttype == PKT_USER_ID );
2049
2050     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2051         if( n->pkt->pkttype != PKT_SIGNATURE )
2052             continue;
2053         if( n->pkt->pkt.signature->sig_class == 0x18
2054             || n->pkt->pkt.signature->sig_class == 0x28 )
2055             continue; /* skip signatures which are only valid on subkeys */
2056         found = 0;
2057         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2058           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2059             {
2060               found++;
2061               break;
2062             }
2063         if( !found ) {
2064             /* This signature is new or newer, append N to DST.
2065              * We add a clone to the original keyblock, because this
2066              * one is released first */
2067             n2 = clone_kbnode(n);
2068             insert_kbnode( dst, n2, PKT_SIGNATURE );
2069             n2->flag |= 1;
2070             n->flag |= 1;
2071             ++*n_sigs;
2072         }
2073     }
2074
2075     return 0;
2076 }
2077
2078 /****************
2079  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2080  */
2081 static int
2082 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2083                                     const char *fname, u32 *keyid )
2084 {
2085     KBNODE n, n2;
2086     int found=0;
2087
2088     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2089            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2090
2091     for(n=src->next; n ; n = n->next ) {
2092         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2093             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2094             break;
2095         if( n->pkt->pkttype != PKT_SIGNATURE )
2096             continue;
2097         found = 0;
2098         for(n2=dst->next; n2; n2 = n2->next){
2099             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2100                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2101                 break;
2102             if( n2->pkt->pkttype == PKT_SIGNATURE
2103                 && n->pkt->pkt.signature->keyid[0]
2104                    == n2->pkt->pkt.signature->keyid[0]
2105                 && n->pkt->pkt.signature->keyid[1]
2106                    == n2->pkt->pkt.signature->keyid[1]
2107                 && n->pkt->pkt.signature->timestamp
2108                    <= n2->pkt->pkt.signature->timestamp
2109                 && n->pkt->pkt.signature->sig_class
2110                    == n2->pkt->pkt.signature->sig_class ) {
2111                 found++;
2112                 break;
2113             }
2114         }
2115         if( !found ) {
2116             /* This signature is new or newer, append N to DST.
2117              * We add a clone to the original keyblock, because this
2118              * one is released first */
2119             n2 = clone_kbnode(n);
2120             insert_kbnode( dst, n2, PKT_SIGNATURE );
2121             n2->flag |= 1;
2122             n->flag |= 1;
2123             ++*n_sigs;
2124         }
2125     }
2126
2127     return 0;
2128 }
2129
2130 /****************
2131  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2132  * Mark all new and copied packets by setting flag bit 0.
2133  */
2134 static int
2135 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2136                                           const char *fname, u32 *keyid )
2137 {
2138     KBNODE n;
2139
2140     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2141            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2142
2143     while(  node ) {
2144         /* we add a clone to the original keyblock, because this
2145          * one is released first */
2146         n = clone_kbnode(node);
2147         add_kbnode( keyblock, n );
2148         n->flag |= 1;
2149         node->flag |= 1;
2150         if( n->pkt->pkttype == PKT_SIGNATURE )
2151             ++*n_sigs;
2152
2153         node = node->next;
2154         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2155             break;
2156     }
2157
2158     return 0;
2159 }
2160
2161
2162
2163 /* Walk a public keyblock and produce a secret keyblock out of it.
2164    Instead of inserting the secret key parameters (which we don't
2165    have), we insert a stub.  */
2166 static KBNODE
2167 pub_to_sec_keyblock (KBNODE pub_keyblock)
2168 {
2169   KBNODE pubnode, secnode;
2170   KBNODE sec_keyblock = NULL;
2171   KBNODE walkctx = NULL;
2172
2173   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2174     {
2175       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2176           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2177         {
2178           /* Make a secret key.  We only need to convert enough to
2179              write the keyblock out. */
2180           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2181           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2182           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2183           int i, n;
2184           
2185           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2186             pkt->pkttype = PKT_SECRET_KEY;
2187           else
2188             pkt->pkttype = PKT_SECRET_SUBKEY;
2189           
2190           pkt->pkt.secret_key = sk;
2191
2192           copy_public_parts_to_secret_key ( pk, sk );
2193           sk->version     = pk->version;
2194           sk->timestamp   = pk->timestamp;
2195         
2196           n = pubkey_get_npkey (pk->pubkey_algo);
2197           if (!n)
2198             n = 1; /* Unknown number of parameters, however the data
2199                       is stored in the first mpi. */
2200           for (i=0; i < n; i++ )
2201             sk->skey[i] = mpi_copy (pk->pkey[i]);
2202   
2203           sk->is_protected = 1;
2204           sk->protect.s2k.mode = 1001;
2205   
2206           secnode = new_kbnode (pkt);
2207         }
2208       else
2209         {
2210           secnode = clone_kbnode (pubnode);
2211         }
2212       
2213       if(!sec_keyblock)
2214         sec_keyblock = secnode;
2215       else
2216         add_kbnode (sec_keyblock, secnode);
2217     }
2218
2219   return sec_keyblock;
2220 }
2221
2222
2223 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2224    stub keys with the serial number SNNUM of the card if one of the
2225    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2226    a duplicate (may happen in case of backed uped keys). 
2227    
2228    Returns: True if anything changed.
2229 */
2230 static int
2231 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2232                                    const unsigned char *fpr1,
2233                                    const unsigned char *fpr2,
2234                                    const unsigned char *fpr3,
2235                                    const char *serialnostr)
2236 {
2237   KBNODE node;
2238   KBNODE walkctx = NULL;
2239   PKT_secret_key *sk;
2240   byte array[MAX_FINGERPRINT_LEN];
2241   size_t n;
2242   int result = 0;
2243   const char *s;
2244
2245   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2246     {
2247       if (node->pkt->pkttype != PKT_SECRET_KEY
2248           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2249         continue;
2250       sk = node->pkt->pkt.secret_key;
2251       
2252       fingerprint_from_sk (sk, array, &n);
2253       if (n != 20)
2254         continue; /* Can't be a card key.  */
2255       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2256              || (fpr2 && !memcmp (array, fpr2, 20))
2257              || (fpr3 && !memcmp (array, fpr3, 20))) )
2258         continue;  /* No match.  */
2259
2260       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2261         {
2262           /* Standard case: migrate that stub to a key stub.  */
2263           sk->protect.s2k.mode = 1002;
2264           s = serialnostr;
2265           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2266                sk->protect.ivlen++, s += 2)
2267             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2268           result = 1;
2269         }
2270       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2271         {
2272           s = serialnostr;
2273           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2274                sk->protect.ivlen++, s += 2)
2275             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2276               {
2277                 log_info (_("NOTE: a key's S/N does not "
2278                             "match the card's one\n"));
2279                 break;
2280               }
2281         }
2282       else
2283         {
2284           if (node->pkt->pkttype != PKT_SECRET_KEY)
2285             log_info (_("NOTE: primary key is online and stored on card\n"));
2286           else
2287             log_info (_("NOTE: secondary key is online and stored on card\n"));
2288         }
2289     }
2290
2291   return result;
2292 }
2293
2294
2295
2296 /* Check whether a secret key stub exists for the public key PK.  If
2297    not create such a stub key and store it into the secring.  If it
2298    exists, add appropriate subkey stubs and update the secring.
2299    Return 0 if the key could be created. */
2300 int
2301 auto_create_card_key_stub ( const char *serialnostr, 
2302                             const unsigned char *fpr1,
2303                             const unsigned char *fpr2,
2304                             const unsigned char *fpr3)
2305 {
2306   KBNODE pub_keyblock;
2307   KBNODE sec_keyblock;
2308   KEYDB_HANDLE hd;
2309   int rc;
2310
2311   /* We only want to do this for an OpenPGP card.  */
2312   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2313       || strlen (serialnostr) != 32 )
2314     return G10ERR_GENERAL;
2315
2316   /* First get the public keyring from any of the provided fingerprints. */
2317   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2318        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2319        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2320     ;
2321   else
2322     return G10ERR_GENERAL;
2323  
2324   hd = keydb_new (1);
2325
2326   /* Now check whether there is a secret keyring.  */
2327   {
2328     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2329     byte afp[MAX_FINGERPRINT_LEN];
2330     size_t an;
2331
2332     fingerprint_from_pk (pk, afp, &an);
2333     memset (afp, 0, MAX_FINGERPRINT_LEN);
2334     rc = keydb_search_fpr (hd, afp);
2335   }
2336
2337   if (!rc)
2338     {
2339       rc = keydb_get_keyblock (hd, &sec_keyblock);
2340       if (rc)
2341         {
2342           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2343           rc = G10ERR_GENERAL;
2344         }
2345       else
2346         {
2347           merge_keys_and_selfsig (sec_keyblock);
2348           
2349           /* FIXME: We need to add new subkeys first.  */
2350           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2351                                                  fpr1, fpr2, fpr3,
2352                                                  serialnostr))
2353             {
2354               rc = keydb_update_keyblock (hd, sec_keyblock );
2355               if (rc)
2356                 log_error (_("error writing keyring `%s': %s\n"),
2357                            keydb_get_resource_name (hd), g10_errstr(rc) );
2358             }
2359         }
2360     }
2361   else  /* A secret key does not exists - create it.  */
2362     {
2363       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2364       update_sec_keyblock_with_cardinfo (sec_keyblock,
2365                                          fpr1, fpr2, fpr3,
2366                                          serialnostr);
2367
2368       rc = keydb_locate_writable (hd, NULL);
2369       if (rc)
2370         {
2371           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2372           rc = G10ERR_GENERAL;
2373         }
2374       else
2375         {
2376           rc = keydb_insert_keyblock (hd, sec_keyblock );
2377           if (rc)
2378             log_error (_("error writing keyring `%s': %s\n"),
2379                        keydb_get_resource_name (hd), g10_errstr(rc) );
2380         }
2381     }
2382     
2383   release_kbnode (sec_keyblock);
2384   release_kbnode (pub_keyblock);
2385   keydb_release (hd);
2386   return rc;
2387 }
2388