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