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