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