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