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