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