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