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