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