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