More changes on the way to remove secring.gpg.
[gnupg.git] / g10 / import.c
1 /* import.c - import a key into our key storage.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "keydb.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "main.h"
36 #include "i18n.h"
37 #include "ttyio.h"
38 #include "status.h"
39 #include "keyserver-internal.h"
40
41 struct stats_s {
42     ulong count;
43     ulong no_user_id;
44     ulong imported;
45     ulong imported_rsa;
46     ulong n_uids;
47     ulong n_sigs;
48     ulong n_subk;
49     ulong unchanged;
50     ulong n_revoc;
51     ulong secret_read;
52     ulong secret_imported;
53     ulong secret_dups;
54     ulong skipped_new_keys;
55     ulong not_imported;
56     ulong n_sigs_cleaned;
57     ulong n_uids_cleaned;
58 };
59
60
61 static int import( IOBUF inp, const char* fname,struct stats_s *stats,
62                    unsigned char **fpr,size_t *fpr_len,unsigned int options );
63 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
64 static void revocation_present(KBNODE keyblock);
65 static int import_one(const char *fname, KBNODE keyblock,struct stats_s *stats,
66                       unsigned char **fpr,size_t *fpr_len,
67                       unsigned int options,int from_sk);
68 static int import_secret_one( const char *fname, KBNODE keyblock,
69                               struct stats_s *stats, unsigned int options);
70 static int import_revoke_cert( const char *fname, KBNODE node,
71                                struct stats_s *stats);
72 static int chk_self_sigs( const char *fname, KBNODE keyblock,
73                           PKT_public_key *pk, u32 *keyid, int *non_self );
74 static int delete_inv_parts( const char *fname, KBNODE keyblock,
75                              u32 *keyid, unsigned int options );
76 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
77                          KBNODE keyblock, u32 *keyid,
78                          int *n_uids, int *n_sigs, int *n_subk );
79 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
80                              const char *fname, u32 *keyid );
81 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
82                              const char *fname, u32 *keyid );
83 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
84                              const char *fname, u32 *keyid );
85 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
86                              const char *fname, u32 *keyid );
87
88 int
89 parse_import_options(char *str,unsigned int *options,int noisy)
90 {
91   struct parse_options import_opts[]=
92     {
93       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
94        N_("import signatures that are marked as local-only")},
95       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
96        N_("repair damage from the pks keyserver during import")},
97       {"fast-import",IMPORT_FAST,NULL,
98        N_("do not update the trustdb after import")},
99       {"convert-sk-to-pk",IMPORT_SK2PK,NULL,
100        N_("create a public key when importing a secret key")},
101       {"merge-only",IMPORT_MERGE_ONLY,NULL,
102        N_("only accept updates to existing keys")},
103       {"import-clean",IMPORT_CLEAN,NULL,
104        N_("remove unusable parts from key after import")},
105       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
106        N_("remove as much as possible from key after import")},
107       /* Aliases for backward compatibility */
108       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
109       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
110       /* dummy */
111       {"import-unusable-sigs",0,NULL,NULL},
112       {"import-clean-sigs",0,NULL,NULL},
113       {"import-clean-uids",0,NULL,NULL},
114       {NULL,0,NULL,NULL}
115     };
116
117   return parse_options(str,options,import_opts,noisy);
118 }
119
120 void *
121 import_new_stats_handle (void)
122 {
123     return xmalloc_clear ( sizeof (struct stats_s) );
124 }
125
126 void
127 import_release_stats_handle (void *p)
128 {
129     xfree (p);
130 }
131
132 /****************
133  * Import the public keys from the given filename. Input may be armored.
134  * This function rejects all keys which are not validly self signed on at
135  * least one userid. Only user ids which are self signed will be imported.
136  * Other signatures are not checked.
137  *
138  * Actually this function does a merge. It works like this:
139  *
140  *  - get the keyblock
141  *  - check self-signatures and remove all userids and their signatures
142  *    without/invalid self-signatures.
143  *  - reject the keyblock, if we have no valid userid.
144  *  - See whether we have this key already in one of our pubrings.
145  *    If not, simply add it to the default keyring.
146  *  - Compare the key and the self-signatures of the new and the one in
147  *    our keyring.  If they are different something weird is going on;
148  *    ask what to do.
149  *  - See whether we have only non-self-signature on one user id; if not
150  *    ask the user what to do.
151  *  - compare the signatures: If we already have this signature, check
152  *    that they compare okay; if not, issue a warning and ask the user.
153  *    (consider looking at the timestamp and use the newest?)
154  *  - Simply add the signature.  Can't verify here because we may not have
155  *    the signature's public key yet; verification is done when putting it
156  *    into the trustdb, which is done automagically as soon as this pubkey
157  *    is used.
158  *  - Proceed with next signature.
159  *
160  *  Key revocation certificates have special handling.
161  *
162  */
163 static int
164 import_keys_internal( IOBUF inp, char **fnames, int nnames,
165                       void *stats_handle, unsigned char **fpr, size_t *fpr_len,
166                       unsigned int options )
167 {
168     int i, rc = 0;
169     struct stats_s *stats = stats_handle;
170
171     if (!stats)
172         stats = import_new_stats_handle ();
173
174     if (inp) {
175         rc = import( inp, "[stream]", stats, fpr, fpr_len, options);
176     }
177     else {
178         if( !fnames && !nnames )
179             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
180
181         for(i=0; i < nnames; i++ ) {
182             const char *fname = fnames? fnames[i] : NULL;
183             IOBUF inp2 = iobuf_open(fname);
184             if( !fname )
185                 fname = "[stdin]";
186             if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
187               {
188                 iobuf_close (inp2);
189                 inp2 = NULL;
190                 gpg_err_set_errno (EPERM);
191               }
192             if( !inp2 )
193                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
194             else
195               {
196                 rc = import( inp2, fname, stats, fpr, fpr_len, options );
197                 iobuf_close(inp2);
198                 /* Must invalidate that ugly cache to actually close it. */
199                 iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 
200                              0, (char*)fname);
201                 if( rc )
202                   log_error("import from `%s' failed: %s\n", fname,
203                             g10_errstr(rc) );
204               }
205             if( !fname )
206                 break;
207         }
208     }
209     if (!stats_handle) {
210         import_print_stats (stats);
211         import_release_stats_handle (stats);
212     }
213
214     /* If no fast import and the trustdb is dirty (i.e. we added a key
215        or userID that had something other than a selfsig, a signature
216        that was other than a selfsig, or any revocation), then
217        update/check the trustdb if the user specified by setting
218        interactive or by not setting no-auto-check-trustdb */
219
220     if(!(options&IMPORT_FAST))
221       trustdb_check_or_update();
222
223     return rc;
224 }
225
226 void
227 import_keys( char **fnames, int nnames,
228              void *stats_handle, unsigned int options )
229 {
230   import_keys_internal(NULL,fnames,nnames,stats_handle,NULL,NULL,options);
231 }
232
233 int
234 import_keys_stream( IOBUF inp, void *stats_handle,
235                     unsigned char **fpr, size_t *fpr_len,unsigned int options )
236 {
237   return import_keys_internal(inp,NULL,0,stats_handle,fpr,fpr_len,options);
238 }
239
240 static int
241 import( IOBUF inp, const char* fname,struct stats_s *stats,
242         unsigned char **fpr,size_t *fpr_len,unsigned int options )
243 {
244     PACKET *pending_pkt = NULL;
245     KBNODE keyblock = NULL;  /* Need to initialize because gcc can't
246                                 grasp the return semantics of
247                                 read_block. */
248     int rc = 0;
249
250     getkey_disable_caches();
251
252     if( !opt.no_armor ) { /* armored reading is not disabled */
253         armor_filter_context_t *afx;
254
255         afx = new_armor_context ();
256         afx->only_keyblocks = 1;
257         push_armor_filter (afx, inp);
258         release_armor_context (afx);
259     }
260
261     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
262         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
263             rc = import_one( fname, keyblock, stats, fpr, fpr_len, options, 0);
264         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
265                 rc = import_secret_one( fname, keyblock, stats, options );
266         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
267                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
268             rc = import_revoke_cert( fname, keyblock, stats );
269         else {
270             log_info( _("skipping block of type %d\n"),
271                                             keyblock->pkt->pkttype );
272         }
273         release_kbnode(keyblock);
274         /* fixme: we should increment the not imported counter but this
275            does only make sense if we keep on going despite of errors. */
276         if( rc )
277             break;
278         if( !(++stats->count % 100) && !opt.quiet )
279             log_info(_("%lu keys processed so far\n"), stats->count );
280     }
281     if( rc == -1 )
282         rc = 0;
283     else if( rc && rc != G10ERR_INV_KEYRING )
284         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
285
286     return rc;
287 }
288
289
290 void
291 import_print_stats (void *hd)
292 {
293     struct stats_s *stats = hd;
294
295     if( !opt.quiet ) {
296         log_info(_("Total number processed: %lu\n"), stats->count );
297         if( stats->skipped_new_keys )
298             log_info(_("      skipped new keys: %lu\n"),
299                                                 stats->skipped_new_keys );
300         if( stats->no_user_id )
301             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
302         if( stats->imported || stats->imported_rsa ) {
303             log_info(_("              imported: %lu"), stats->imported );
304             if (stats->imported_rsa)
305               log_printf ("  (RSA: %lu)", stats->imported_rsa );
306             log_printf ("\n");
307         }
308         if( stats->unchanged )
309             log_info(_("             unchanged: %lu\n"), stats->unchanged );
310         if( stats->n_uids )
311             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
312         if( stats->n_subk )
313             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
314         if( stats->n_sigs )
315             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
316         if( stats->n_revoc )
317             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
318         if( stats->secret_read )
319             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
320         if( stats->secret_imported )
321             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
322         if( stats->secret_dups )
323             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
324         if( stats->not_imported )
325             log_info(_("          not imported: %lu\n"), stats->not_imported );
326         if( stats->n_sigs_cleaned)
327             log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
328         if( stats->n_uids_cleaned)
329             log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
330     }
331
332     if( is_status_enabled() ) {
333         char buf[14*20];
334         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
335                 stats->count,
336                 stats->no_user_id,
337                 stats->imported,
338                 stats->imported_rsa,
339                 stats->unchanged,
340                 stats->n_uids,
341                 stats->n_subk,
342                 stats->n_sigs,
343                 stats->n_revoc,
344                 stats->secret_read,
345                 stats->secret_imported,
346                 stats->secret_dups,
347                 stats->skipped_new_keys,
348                 stats->not_imported );
349         write_status_text( STATUS_IMPORT_RES, buf );
350     }
351 }
352
353
354 /****************
355  * Read the next keyblock from stream A.
356  * PENDING_PKT should be initialzed to NULL
357  * and not chnaged form the caller.
358  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
359  */
360 static int
361 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
362 {
363     int rc;
364     PACKET *pkt;
365     KBNODE root = NULL;
366     int in_cert;
367
368     if( *pending_pkt ) {
369         root = new_kbnode( *pending_pkt );
370         *pending_pkt = NULL;
371         in_cert = 1;
372     }
373     else
374         in_cert = 0;
375     pkt = xmalloc( sizeof *pkt );
376     init_packet(pkt);
377     while( (rc=parse_packet(a, pkt)) != -1 ) {
378         if( rc ) {  /* ignore errors */
379             if( rc != G10ERR_UNKNOWN_PACKET ) {
380                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
381                 rc = G10ERR_INV_KEYRING;
382                 goto ready;
383             }
384             free_packet( pkt );
385             init_packet(pkt);
386             continue;
387         }
388
389         if( !root && pkt->pkttype == PKT_SIGNATURE
390                   && pkt->pkt.signature->sig_class == 0x20 ) {
391             /* this is a revocation certificate which is handled
392              * in a special way */
393             root = new_kbnode( pkt );
394             pkt = NULL;
395             goto ready;
396         }
397
398         /* make a linked list of all packets */
399         switch( pkt->pkttype ) {
400           case PKT_COMPRESSED:
401             if(check_compress_algo(pkt->pkt.compressed->algorithm))
402               {
403                 rc = G10ERR_COMPR_ALGO;
404                 goto ready;
405               }
406             else
407               {
408                 compress_filter_context_t *cfx = xmalloc_clear( sizeof *cfx );
409                 pkt->pkt.compressed->buf = NULL;
410                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
411               }
412             free_packet( pkt );
413             init_packet(pkt);
414             break;
415
416           case PKT_RING_TRUST:
417             /* skip those packets */
418             free_packet( pkt );
419             init_packet(pkt);
420             break;
421
422           case PKT_PUBLIC_KEY:
423           case PKT_SECRET_KEY:
424             if( in_cert ) { /* store this packet */
425                 *pending_pkt = pkt;
426                 pkt = NULL;
427                 goto ready;
428             }
429             in_cert = 1;
430           default:
431             if( in_cert ) {
432                 if( !root )
433                     root = new_kbnode( pkt );
434                 else
435                     add_kbnode( root, new_kbnode( pkt ) );
436                 pkt = xmalloc( sizeof *pkt );
437             }
438             init_packet(pkt);
439             break;
440         }
441     }
442   ready:
443     if( rc == -1 && root )
444         rc = 0;
445
446     if( rc )
447         release_kbnode( root );
448     else
449         *ret_root = root;
450     free_packet( pkt );
451     xfree( pkt );
452     return rc;
453 }
454
455 /* Walk through the subkeys on a pk to find if we have the PKS
456    disease: multiple subkeys with their binding sigs stripped, and the
457    sig for the first subkey placed after the last subkey.  That is,
458    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
459    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
460    and sub3, as they are already lost, but we can try and rescue sub1
461    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
462    sub2 sub3".  Returns TRUE if the keyblock was modified. */
463
464 static int
465 fix_pks_corruption(KBNODE keyblock)
466 {
467   int changed=0,keycount=0;
468   KBNODE node,last=NULL,sknode=NULL;
469
470   /* First determine if we have the problem at all.  Look for 2 or
471      more subkeys in a row, followed by a single binding sig. */
472   for(node=keyblock;node;last=node,node=node->next)
473     {
474       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
475         {
476           keycount++;
477           if(!sknode)
478             sknode=node;
479         }
480       else if(node->pkt->pkttype==PKT_SIGNATURE &&
481               node->pkt->pkt.signature->sig_class==0x18 &&
482               keycount>=2 && node->next==NULL)
483         {
484           /* We might have the problem, as this key has two subkeys in
485              a row without any intervening packets. */
486
487           /* Sanity check */
488           if(last==NULL)
489             break;
490
491           /* Temporarily attach node to sknode. */
492           node->next=sknode->next;
493           sknode->next=node;
494           last->next=NULL;
495
496           /* Note we aren't checking whether this binding sig is a
497              selfsig.  This is not necessary here as the subkey and
498              binding sig will be rejected later if that is the
499              case. */
500           if(check_key_signature(keyblock,node,NULL))
501             {
502               /* Not a match, so undo the changes. */
503               sknode->next=node->next;
504               last->next=node;
505               node->next=NULL;
506               break;
507             }
508           else
509             {
510               sknode->flag |= 1; /* Mark it good so we don't need to
511                                     check it again */
512               changed=1;
513               break;
514             }
515         }
516       else
517         keycount=0;
518     }
519
520   return changed;
521 }
522
523
524 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_buffer (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 ();
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 ();
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 && have_secret_key_with_kid (keyid))
1019           check_prefs (keyblock_orig);
1020       }
1021     else if (new_key)
1022       {
1023         revocation_present (keyblock);
1024         if (!from_sk && have_secret_key_with_kid (keyid))
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_buffer (es_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 = -1 /* fixme seckey_available( keyid ) is not anymore
1164                available and has been replaced by
1165                have_secret_key_with_kid.  We need to rework the entire
1166                secret key import code.  The solution I am currently
1167                thinking about is to move that code into a helper
1168                program.  */;
1169     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1170       {
1171         /* simply insert this key */
1172         KEYDB_HANDLE hd = keydb_new (); /* FIXME*/
1173
1174         /* get default resource */
1175         rc = keydb_locate_writable (hd, NULL);
1176         if (rc) {
1177           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1178           keydb_release (hd);
1179           return G10ERR_GENERAL;
1180         }
1181         rc = keydb_insert_keyblock (hd, keyblock );
1182         if (rc)
1183           log_error (_("error writing keyring `%s': %s\n"),
1184                      keydb_get_resource_name (hd), g10_errstr(rc) );
1185         keydb_release (hd);
1186         /* we are ready */
1187         if( !opt.quiet )
1188           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1189         stats->secret_imported++;
1190         if (is_status_enabled ()) 
1191           print_import_ok (NULL, sk, 1|16);
1192
1193         if(options&IMPORT_SK2PK)
1194           {
1195             /* Try and make a public key out of this. */
1196
1197             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1198             if(pub_keyblock)
1199               {
1200                 import_one(fname,pub_keyblock,stats,
1201                            NULL,NULL,opt.import_options,1);
1202                 release_kbnode(pub_keyblock);
1203               }
1204           }
1205
1206         /* Now that the key is definitely incorporated into the keydb,
1207            if we have the public part of this key, we need to check if
1208            the prefs are rational. */
1209         node=get_pubkeyblock(keyid);
1210         if(node)
1211           {
1212             check_prefs(node);
1213             release_kbnode(node);
1214           }
1215       }
1216     else if( !rc )
1217       { /* we can't merge secret keys */
1218         log_error( _("key %s: already in secret keyring\n"),
1219                    keystr_from_sk(sk));
1220         stats->secret_dups++;
1221         if (is_status_enabled ()) 
1222           print_import_ok (NULL, sk, 16);
1223
1224         /* TODO: if we ever do merge secret keys, make sure to handle
1225            the sec_to_pub_keyblock feature as well. */
1226       }
1227     else
1228       log_error( _("key %s: secret key not found: %s\n"),
1229                  keystr_from_sk(sk), g10_errstr(rc));
1230
1231     return rc;
1232 }
1233
1234
1235 /****************
1236  * Import a revocation certificate; this is a single signature packet.
1237  */
1238 static int
1239 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1240 {
1241     PKT_public_key *pk=NULL;
1242     KBNODE onode, keyblock = NULL;
1243     KEYDB_HANDLE hd = NULL;
1244     u32 keyid[2];
1245     int rc = 0;
1246
1247     (void)fname;
1248
1249     assert( !node->next );
1250     assert( node->pkt->pkttype == PKT_SIGNATURE );
1251     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1252
1253     keyid[0] = node->pkt->pkt.signature->keyid[0];
1254     keyid[1] = node->pkt->pkt.signature->keyid[1];
1255
1256     pk = xmalloc_clear( sizeof *pk );
1257     rc = get_pubkey( pk, keyid );
1258     if( rc == G10ERR_NO_PUBKEY )
1259       {
1260         log_error(_("key %s: no public key -"
1261                     " can't apply revocation certificate\n"), keystr(keyid));
1262         rc = 0;
1263         goto leave;
1264       }
1265     else if( rc )
1266       {
1267         log_error(_("key %s: public key not found: %s\n"),
1268                   keystr(keyid), g10_errstr(rc));
1269         goto leave;
1270       }
1271
1272     /* read the original keyblock */
1273     hd = keydb_new ();
1274     {
1275         byte afp[MAX_FINGERPRINT_LEN];
1276         size_t an;
1277         
1278         fingerprint_from_pk (pk, afp, &an);
1279         while (an < MAX_FINGERPRINT_LEN) 
1280             afp[an++] = 0;
1281         rc = keydb_search_fpr (hd, afp);
1282     }
1283     if (rc)
1284       {
1285         log_error (_("key %s: can't locate original keyblock: %s\n"),
1286                    keystr(keyid), g10_errstr(rc));
1287         goto leave;
1288       }
1289     rc = keydb_get_keyblock (hd, &keyblock );
1290     if (rc)
1291       {
1292         log_error (_("key %s: can't read original keyblock: %s\n"),
1293                    keystr(keyid), g10_errstr(rc));
1294         goto leave;
1295       }
1296
1297     /* it is okay, that node is not in keyblock because
1298      * check_key_signature works fine for sig_class 0x20 in this
1299      * special case. */
1300     rc = check_key_signature( keyblock, node, NULL);
1301     if( rc )
1302       {
1303         log_error( _("key %s: invalid revocation certificate"
1304                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1305         goto leave;
1306       }
1307
1308     /* check whether we already have this */
1309     for(onode=keyblock->next; onode; onode=onode->next ) {
1310         if( onode->pkt->pkttype == PKT_USER_ID )
1311             break;
1312         else if( onode->pkt->pkttype == PKT_SIGNATURE
1313                  && !cmp_signatures(node->pkt->pkt.signature,
1314                                     onode->pkt->pkt.signature))
1315           {
1316             rc = 0;
1317             goto leave; /* yes, we already know about it */
1318           }
1319     }
1320
1321
1322     /* insert it */
1323     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1324
1325     /* and write the keyblock back */
1326     rc = keydb_update_keyblock (hd, keyblock );
1327     if (rc)
1328         log_error (_("error writing keyring `%s': %s\n"),
1329                    keydb_get_resource_name (hd), g10_errstr(rc) );
1330     keydb_release (hd); hd = NULL;
1331     /* we are ready */
1332     if( !opt.quiet )
1333       {
1334         char *p=get_user_id_native (keyid);
1335         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1336                   keystr(keyid),p);
1337         xfree(p);
1338       }
1339     stats->n_revoc++;
1340
1341     /* If the key we just revoked was ultimately trusted, remove its
1342        ultimate trust.  This doesn't stop the user from putting the
1343        ultimate trust back, but is a reasonable solution for now. */
1344     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1345       clear_ownertrusts(pk);
1346
1347     revalidation_mark ();
1348
1349   leave:
1350     keydb_release (hd);
1351     release_kbnode( keyblock );
1352     free_public_key( pk );
1353     return rc;
1354 }
1355
1356
1357 /****************
1358  * loop over the keyblock and check all self signatures.
1359  * Mark all user-ids with a self-signature by setting flag bit 0.
1360  * Mark all user-ids with an invalid self-signature by setting bit 1.
1361  * This works also for subkeys, here the subkey is marked.  Invalid or
1362  * extra subkey sigs (binding or revocation) are marked for deletion.
1363  * non_self is set to true if there are any sigs other than self-sigs
1364  * in this keyblock.
1365  */
1366 static int
1367 chk_self_sigs( const char *fname, KBNODE keyblock,
1368                PKT_public_key *pk, u32 *keyid, int *non_self )
1369 {
1370     KBNODE n,knode=NULL;
1371     PKT_signature *sig;
1372     int rc;
1373     u32 bsdate=0,rsdate=0;
1374     KBNODE bsnode=NULL,rsnode=NULL;
1375
1376     (void)fname;
1377     (void)pk;
1378
1379     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1380       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1381         {
1382           knode=n;
1383           bsdate=0;
1384           rsdate=0;
1385           bsnode=NULL;
1386           rsnode=NULL;
1387           continue;
1388         }
1389       else if( n->pkt->pkttype != PKT_SIGNATURE )
1390             continue;
1391         sig = n->pkt->pkt.signature;
1392         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1393
1394             /* This just caches the sigs for later use.  That way we
1395                import a fully-cached key which speeds things up. */
1396             if(!opt.no_sig_cache)
1397               check_key_signature(keyblock,n,NULL);
1398
1399             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1400               {
1401                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1402                 if( !unode )
1403                   {
1404                     log_error( _("key %s: no user ID for signature\n"),
1405                                keystr(keyid));
1406                     return -1;  /* the complete keyblock is invalid */
1407                   }
1408
1409                 /* If it hasn't been marked valid yet, keep trying */
1410                 if(!(unode->flag&1)) {
1411                   rc = check_key_signature( keyblock, n, NULL);
1412                   if( rc )
1413                     {
1414                       if( opt.verbose )
1415                         {
1416                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1417                                       strlen(unode->pkt->pkt.user_id->name),0);
1418                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1419                                     _("key %s: unsupported public key "
1420                                       "algorithm on user ID \"%s\"\n"):
1421                                     _("key %s: invalid self-signature "
1422                                       "on user ID \"%s\"\n"),
1423                                     keystr(keyid),p);
1424                           xfree(p);
1425                         }
1426                     }
1427                   else
1428                     unode->flag |= 1; /* mark that signature checked */
1429                 }
1430               }
1431             else if( sig->sig_class == 0x18 ) {
1432               /* Note that this works based solely on the timestamps
1433                  like the rest of gpg.  If the standard gets
1434                  revocation targets, this may need to be revised. */
1435
1436                 if( !knode )
1437                   {
1438                     if(opt.verbose)
1439                       log_info( _("key %s: no subkey for key binding\n"),
1440                                 keystr(keyid));
1441                     n->flag |= 4; /* delete this */
1442                   }
1443                 else
1444                   {
1445                     rc = check_key_signature( keyblock, n, NULL);
1446                     if( rc )
1447                       {
1448                         if(opt.verbose)
1449                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1450                                    _("key %s: unsupported public key"
1451                                      " algorithm\n"):
1452                                    _("key %s: invalid subkey binding\n"),
1453                                    keystr(keyid));
1454                         n->flag|=4;
1455                       }
1456                     else
1457                       {
1458                         /* It's valid, so is it newer? */
1459                         if(sig->timestamp>=bsdate) {
1460                           knode->flag |= 1;  /* the subkey is valid */
1461                           if(bsnode)
1462                             {
1463                               bsnode->flag|=4; /* Delete the last binding
1464                                                   sig since this one is
1465                                                   newer */
1466                               if(opt.verbose)
1467                                 log_info(_("key %s: removed multiple subkey"
1468                                            " binding\n"),keystr(keyid));
1469                             }
1470
1471                           bsnode=n;
1472                           bsdate=sig->timestamp;
1473                         }
1474                         else
1475                           n->flag|=4; /* older */
1476                       }
1477                   }
1478             }
1479             else if( sig->sig_class == 0x28 ) {
1480               /* We don't actually mark the subkey as revoked right
1481                  now, so just check that the revocation sig is the
1482                  most recent valid one.  Note that we don't care if
1483                  the binding sig is newer than the revocation sig.
1484                  See the comment in getkey.c:merge_selfsigs_subkey for
1485                  more */
1486                 if( !knode )
1487                   {
1488                     if(opt.verbose)
1489                       log_info( _("key %s: no subkey for key revocation\n"),
1490                                 keystr(keyid));
1491                     n->flag |= 4; /* delete this */
1492                   }
1493                 else
1494                   {
1495                     rc = check_key_signature( keyblock, n, NULL);
1496                     if( rc )
1497                       {
1498                         if(opt.verbose)
1499                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1500                                    _("key %s: unsupported public"
1501                                      " key algorithm\n"):
1502                                    _("key %s: invalid subkey revocation\n"),
1503                                    keystr(keyid));
1504                         n->flag|=4;
1505                       }
1506                     else
1507                       {
1508                         /* It's valid, so is it newer? */
1509                         if(sig->timestamp>=rsdate)
1510                           {
1511                             if(rsnode)
1512                               {
1513                                 rsnode->flag|=4; /* Delete the last revocation
1514                                                     sig since this one is
1515                                                     newer */
1516                                 if(opt.verbose)
1517                                   log_info(_("key %s: removed multiple subkey"
1518                                              " revocation\n"),keystr(keyid));
1519                               }
1520
1521                             rsnode=n;
1522                             rsdate=sig->timestamp;
1523                           }
1524                         else
1525                           n->flag|=4; /* older */
1526                       }
1527                   }
1528             }
1529         }
1530         else
1531           *non_self=1;
1532     }
1533
1534     return 0;
1535 }
1536
1537 /****************
1538  * delete all parts which are invalid and those signatures whose
1539  * public key algorithm is not available in this implemenation;
1540  * but consider RSA as valid, because parse/build_packets knows
1541  * about it.
1542  * returns: true if at least one valid user-id is left over.
1543  */
1544 static int
1545 delete_inv_parts( const char *fname, KBNODE keyblock,
1546                   u32 *keyid, unsigned int options)
1547 {
1548     KBNODE node;
1549     int nvalid=0, uid_seen=0, subkey_seen=0;
1550
1551     (void)fname;
1552
1553     for(node=keyblock->next; node; node = node->next ) {
1554         if( node->pkt->pkttype == PKT_USER_ID ) {
1555             uid_seen = 1;
1556             if( (node->flag & 2) || !(node->flag & 1) ) {
1557                 if( opt.verbose )
1558                   {
1559                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1560                                            node->pkt->pkt.user_id->len,0);
1561                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1562                               keystr(keyid),p);
1563                     xfree(p);
1564                   }
1565                 delete_kbnode( node ); /* the user-id */
1566                 /* and all following packets up to the next user-id */
1567                 while( node->next
1568                        && node->next->pkt->pkttype != PKT_USER_ID
1569                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1570                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1571                     delete_kbnode( node->next );
1572                     node = node->next;
1573                 }
1574             }
1575             else
1576                 nvalid++;
1577         }
1578         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1579                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1580             if( (node->flag & 2) || !(node->flag & 1) ) {
1581                 if( opt.verbose )
1582                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1583
1584                 delete_kbnode( node ); /* the subkey */
1585                 /* and all following signature packets */
1586                 while( node->next
1587                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1588                     delete_kbnode( node->next );
1589                     node = node->next;
1590                 }
1591             }
1592             else
1593               subkey_seen = 1;
1594         }
1595         else if (node->pkt->pkttype == PKT_SIGNATURE
1596                 && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
1597                 && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1598             delete_kbnode( node ); /* build_packet() can't handle this */
1599         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1600                  !node->pkt->pkt.signature->flags.exportable &&
1601                  !(options&IMPORT_LOCAL_SIGS) &&
1602                  !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
1603           {
1604             /* here we violate the rfc a bit by still allowing
1605              * to import non-exportable signature when we have the
1606              * the secret key used to create this signature - it
1607              * seems that this makes sense */
1608             if(opt.verbose)
1609               log_info( _("key %s: non exportable signature"
1610                           " (class 0x%02X) - skipped\n"),
1611                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1612             delete_kbnode( node );
1613           }
1614         else if( node->pkt->pkttype == PKT_SIGNATURE
1615                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1616             if( uid_seen )
1617               {
1618                 if(opt.verbose)
1619                   log_info( _("key %s: revocation certificate"
1620                               " at wrong place - skipped\n"),keystr(keyid));
1621                 delete_kbnode( node );
1622               }
1623             else {
1624               /* If the revocation cert is from a different key than
1625                  the one we're working on don't check it - it's
1626                  probably from a revocation key and won't be
1627                  verifiable with this key anyway. */
1628
1629               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1630                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1631                 {
1632                   int rc = check_key_signature( keyblock, node, NULL);
1633                   if( rc )
1634                     {
1635                       if(opt.verbose)
1636                         log_info( _("key %s: invalid revocation"
1637                                     " certificate: %s - skipped\n"),
1638                                   keystr(keyid), g10_errstr(rc));
1639                       delete_kbnode( node );
1640                     }
1641                 }
1642             }
1643         }
1644         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1645                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1646                   node->pkt->pkt.signature->sig_class == 0x28) &&
1647                  !subkey_seen )
1648           {
1649             if(opt.verbose)
1650               log_info( _("key %s: subkey signature"
1651                           " in wrong place - skipped\n"), keystr(keyid));
1652             delete_kbnode( node );
1653           }
1654         else if( node->pkt->pkttype == PKT_SIGNATURE
1655                  && !IS_CERT(node->pkt->pkt.signature))
1656           {
1657             if(opt.verbose)
1658               log_info(_("key %s: unexpected signature class (0x%02X) -"
1659                          " skipped\n"),keystr(keyid),
1660                        node->pkt->pkt.signature->sig_class);
1661             delete_kbnode(node);
1662           }
1663         else if( (node->flag & 4) ) /* marked for deletion */
1664           delete_kbnode( node );
1665     }
1666
1667     /* note: because keyblock is the public key, it is never marked
1668      * for deletion and so keyblock cannot change */
1669     commit_kbnode( &keyblock );
1670     return nvalid;
1671 }
1672
1673
1674 /****************
1675  * It may happen that the imported keyblock has duplicated user IDs.
1676  * We check this here and collapse those user IDs together with their
1677  * sigs into one.
1678  * Returns: True if the keyblock has changed.
1679  */
1680 int
1681 collapse_uids( KBNODE *keyblock )
1682 {
1683   KBNODE uid1;
1684   int any=0;
1685
1686   for(uid1=*keyblock;uid1;uid1=uid1->next)
1687     {
1688       KBNODE uid2;
1689
1690       if(is_deleted_kbnode(uid1))
1691         continue;
1692
1693       if(uid1->pkt->pkttype!=PKT_USER_ID)
1694         continue;
1695
1696       for(uid2=uid1->next;uid2;uid2=uid2->next)
1697         {
1698           if(is_deleted_kbnode(uid2))
1699             continue;
1700
1701           if(uid2->pkt->pkttype!=PKT_USER_ID)
1702             continue;
1703
1704           if(cmp_user_ids(uid1->pkt->pkt.user_id,
1705                           uid2->pkt->pkt.user_id)==0)
1706             {
1707               /* We have a duplicated uid */
1708               KBNODE sig1,last;
1709
1710               any=1;
1711
1712               /* Now take uid2's signatures, and attach them to
1713                  uid1 */
1714               for(last=uid2;last->next;last=last->next)
1715                 {
1716                   if(is_deleted_kbnode(last))
1717                     continue;
1718
1719                   if(last->next->pkt->pkttype==PKT_USER_ID
1720                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
1721                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
1722                     break;
1723                 }
1724
1725               /* Snip out uid2 */
1726               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
1727
1728               /* Now put uid2 in place as part of uid1 */
1729               last->next=uid1->next;
1730               uid1->next=uid2;
1731               delete_kbnode(uid2);
1732
1733               /* Now dedupe uid1 */
1734               for(sig1=uid1->next;sig1;sig1=sig1->next)
1735                 {
1736                   KBNODE sig2;
1737
1738                   if(is_deleted_kbnode(sig1))
1739                     continue;
1740
1741                   if(sig1->pkt->pkttype==PKT_USER_ID
1742                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
1743                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
1744                     break;
1745
1746                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
1747                     continue;
1748
1749                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
1750                     {
1751                       if(is_deleted_kbnode(sig2))
1752                         continue;
1753
1754                       if(sig2->pkt->pkttype==PKT_USER_ID
1755                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
1756                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
1757                         break;
1758
1759                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
1760                         continue;
1761
1762                       if(cmp_signatures(sig1->pkt->pkt.signature,
1763                                         sig2->pkt->pkt.signature)==0)
1764                         {
1765                           /* We have a match, so delete the second
1766                              signature */
1767                           delete_kbnode(sig2);
1768                           sig2=last;
1769                         }
1770                     }
1771                 }
1772             }
1773         }
1774     }
1775
1776   commit_kbnode(keyblock);
1777
1778   if(any && !opt.quiet)
1779     {
1780       const char *key="???";
1781
1782       if( (uid1=find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1783         key=keystr_from_pk(uid1->pkt->pkt.public_key);
1784       else if( (uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1785         key=keystr_from_sk(uid1->pkt->pkt.secret_key);
1786
1787       log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1788     }
1789
1790   return any;
1791 }
1792
1793 /* Check for a 0x20 revocation from a revocation key that is not
1794    present.  This may be called without the benefit of merge_xxxx so
1795    you can't rely on pk->revkey and friends. */
1796 static void
1797 revocation_present(KBNODE keyblock)
1798 {
1799   KBNODE onode,inode;
1800   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1801
1802   for(onode=keyblock->next;onode;onode=onode->next)
1803     {
1804       /* If we reach user IDs, we're done. */
1805       if(onode->pkt->pkttype==PKT_USER_ID)
1806         break;
1807
1808       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1809          onode->pkt->pkt.signature->sig_class==0x1F &&
1810          onode->pkt->pkt.signature->revkey)
1811         {
1812           int idx;
1813           PKT_signature *sig=onode->pkt->pkt.signature;
1814
1815           for(idx=0;idx<sig->numrevkeys;idx++)
1816             {
1817               u32 keyid[2];
1818
1819               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1820                                      MAX_FINGERPRINT_LEN,keyid);
1821
1822               for(inode=keyblock->next;inode;inode=inode->next)
1823                 {
1824                   /* If we reach user IDs, we're done. */
1825                   if(inode->pkt->pkttype==PKT_USER_ID)
1826                     break;
1827
1828                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1829                      inode->pkt->pkt.signature->sig_class==0x20 &&
1830                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1831                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1832                     {
1833                       /* Okay, we have a revocation key, and a
1834                          revocation issued by it.  Do we have the key
1835                          itself? */
1836                       int rc;
1837
1838                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1839                                                    MAX_FINGERPRINT_LEN);
1840                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1841                         {
1842                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1843
1844                           /* No, so try and get it */
1845                           if(opt.keyserver
1846                              && (opt.keyserver_options.options
1847                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1848                             {
1849                               log_info(_("WARNING: key %s may be revoked:"
1850                                          " fetching revocation key %s\n"),
1851                                        tempkeystr,keystr(keyid));
1852                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1853                                                       MAX_FINGERPRINT_LEN,
1854                                                       opt.keyserver);
1855
1856                               /* Do we have it now? */
1857                               rc=get_pubkey_byfprint_fast (NULL,
1858                                                      sig->revkey[idx]->fpr,
1859                                                      MAX_FINGERPRINT_LEN);
1860                             }
1861
1862                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1863                             log_info(_("WARNING: key %s may be revoked:"
1864                                        " revocation key %s not present.\n"),
1865                                      tempkeystr,keystr(keyid));
1866
1867                           xfree(tempkeystr);
1868                         }
1869                     }
1870                 }
1871             }
1872         }
1873     }
1874 }
1875
1876 /****************
1877  * compare and merge the blocks
1878  *
1879  * o compare the signatures: If we already have this signature, check
1880  *   that they compare okay; if not, issue a warning and ask the user.
1881  * o Simply add the signature.  Can't verify here because we may not have
1882  *   the signature's public key yet; verification is done when putting it
1883  *   into the trustdb, which is done automagically as soon as this pubkey
1884  *   is used.
1885  * Note: We indicate newly inserted packets with flag bit 0
1886  */
1887 static int
1888 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1889               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1890 {
1891     KBNODE onode, node;
1892     int rc, found;
1893
1894     /* 1st: handle revocation certificates */
1895     for(node=keyblock->next; node; node=node->next ) {
1896         if( node->pkt->pkttype == PKT_USER_ID )
1897             break;
1898         else if( node->pkt->pkttype == PKT_SIGNATURE
1899                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1900             /* check whether we already have this */
1901             found = 0;
1902             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1903                 if( onode->pkt->pkttype == PKT_USER_ID )
1904                     break;
1905                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1906                          && onode->pkt->pkt.signature->sig_class == 0x20
1907                          && !cmp_signatures(onode->pkt->pkt.signature,
1908                                             node->pkt->pkt.signature))
1909                   {
1910                     found = 1;
1911                     break;
1912                   }
1913             }
1914             if( !found ) {
1915                 KBNODE n2 = clone_kbnode(node);
1916                 insert_kbnode( keyblock_orig, n2, 0 );
1917                 n2->flag |= 1;
1918                 ++*n_sigs;
1919                 if(!opt.quiet)
1920                   {
1921                     char *p=get_user_id_native (keyid);
1922                     log_info(_("key %s: \"%s\" revocation"
1923                                " certificate added\n"), keystr(keyid),p);
1924                     xfree(p);
1925                   }
1926             }
1927         }
1928     }
1929
1930     /* 2nd: merge in any direct key (0x1F) sigs */
1931     for(node=keyblock->next; node; node=node->next ) {
1932         if( node->pkt->pkttype == PKT_USER_ID )
1933             break;
1934         else if( node->pkt->pkttype == PKT_SIGNATURE
1935                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1936             /* check whether we already have this */
1937             found = 0;
1938             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1939                 if( onode->pkt->pkttype == PKT_USER_ID )
1940                     break;
1941                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1942                          && onode->pkt->pkt.signature->sig_class == 0x1F
1943                          && !cmp_signatures(onode->pkt->pkt.signature,
1944                                             node->pkt->pkt.signature)) {
1945                     found = 1;
1946                     break;
1947                 }
1948             }
1949             if( !found )
1950               {
1951                 KBNODE n2 = clone_kbnode(node);
1952                 insert_kbnode( keyblock_orig, n2, 0 );
1953                 n2->flag |= 1;
1954                 ++*n_sigs;
1955                 if(!opt.quiet)
1956                   log_info( _("key %s: direct key signature added\n"),
1957                             keystr(keyid));
1958               }
1959         }
1960     }
1961
1962     /* 3rd: try to merge new certificates in */
1963     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1964         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1965             /* find the user id in the imported keyblock */
1966             for(node=keyblock->next; node; node=node->next )
1967                 if( node->pkt->pkttype == PKT_USER_ID
1968                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1969                                           node->pkt->pkt.user_id ) )
1970                     break;
1971             if( node ) { /* found: merge */
1972                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1973                 if( rc )
1974                     return rc;
1975             }
1976         }
1977     }
1978
1979     /* 4th: add new user-ids */
1980     for(node=keyblock->next; node; node=node->next ) {
1981         if( node->pkt->pkttype == PKT_USER_ID) {
1982             /* do we have this in the original keyblock */
1983             for(onode=keyblock_orig->next; onode; onode=onode->next )
1984                 if( onode->pkt->pkttype == PKT_USER_ID
1985                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1986                                       node->pkt->pkt.user_id ) )
1987                     break;
1988             if( !onode ) { /* this is a new user id: append */
1989                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1990                 if( rc )
1991                     return rc;
1992                 ++*n_uids;
1993             }
1994         }
1995     }
1996
1997     /* 5th: add new subkeys */
1998     for(node=keyblock->next; node; node=node->next ) {
1999         onode = NULL;
2000         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2001             /* do we have this in the original keyblock? */
2002             for(onode=keyblock_orig->next; onode; onode=onode->next )
2003                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2004                     && !cmp_public_keys( onode->pkt->pkt.public_key,
2005                                          node->pkt->pkt.public_key ) )
2006                     break;
2007             if( !onode ) { /* this is a new subkey: append */
2008                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
2009                 if( rc )
2010                     return rc;
2011                 ++*n_subk;
2012             }
2013         }
2014         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2015             /* do we have this in the original keyblock? */
2016             for(onode=keyblock_orig->next; onode; onode=onode->next )
2017                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
2018                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
2019                                          node->pkt->pkt.secret_key ) )
2020                     break;
2021             if( !onode ) { /* this is a new subkey: append */
2022                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
2023                 if( rc )
2024                     return rc;
2025                 ++*n_subk;
2026             }
2027         }
2028     }
2029
2030     /* 6th: merge subkey certificates */
2031     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2032         if( !(onode->flag & 1)
2033             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2034                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
2035             /* find the subkey in the imported keyblock */
2036             for(node=keyblock->next; node; node=node->next ) {
2037                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2038                     && !cmp_public_keys( onode->pkt->pkt.public_key,
2039                                           node->pkt->pkt.public_key ) )
2040                     break;
2041                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
2042                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
2043                                           node->pkt->pkt.secret_key ) )
2044                     break;
2045             }
2046             if( node ) { /* found: merge */
2047                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
2048                 if( rc )
2049                     return rc;
2050             }
2051         }
2052     }
2053
2054
2055     return 0;
2056 }
2057
2058
2059 /****************
2060  * append the userid starting with NODE and all signatures to KEYBLOCK.
2061  */
2062 static int
2063 append_uid (KBNODE keyblock, KBNODE node, int *n_sigs,
2064             const char *fname, u32 *keyid )
2065 {
2066     KBNODE n, n_where=NULL;
2067
2068     (void)fname;
2069     (void)keyid;
2070
2071     assert(node->pkt->pkttype == PKT_USER_ID );
2072
2073     /* find the position */
2074     for( n = keyblock; n; n_where = n, n = n->next ) {
2075         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2076             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2077             break;
2078     }
2079     if( !n )
2080         n_where = NULL;
2081
2082     /* and append/insert */
2083     while( node ) {
2084         /* we add a clone to the original keyblock, because this
2085          * one is released first */
2086         n = clone_kbnode(node);
2087         if( n_where ) {
2088             insert_kbnode( n_where, n, 0 );
2089             n_where = n;
2090         }
2091         else
2092             add_kbnode( keyblock, n );
2093         n->flag |= 1;
2094         node->flag |= 1;
2095         if( n->pkt->pkttype == PKT_SIGNATURE )
2096             ++*n_sigs;
2097
2098         node = node->next;
2099         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2100             break;
2101     }
2102
2103     return 0;
2104 }
2105
2106
2107 /****************
2108  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2109  * (how should we handle comment packets here?)
2110  */
2111 static int
2112 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2113                                     const char *fname, u32 *keyid )
2114 {
2115     KBNODE n, n2;
2116     int found=0;
2117
2118     (void)fname;
2119     (void)keyid;
2120
2121     assert(dst->pkt->pkttype == PKT_USER_ID );
2122     assert(src->pkt->pkttype == PKT_USER_ID );
2123
2124     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2125         if( n->pkt->pkttype != PKT_SIGNATURE )
2126             continue;
2127         if( n->pkt->pkt.signature->sig_class == 0x18
2128             || n->pkt->pkt.signature->sig_class == 0x28 )
2129             continue; /* skip signatures which are only valid on subkeys */
2130         found = 0;
2131         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2132           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2133             {
2134               found++;
2135               break;
2136             }
2137         if( !found ) {
2138             /* This signature is new or newer, append N to DST.
2139              * We add a clone to the original keyblock, because this
2140              * one is released first */
2141             n2 = clone_kbnode(n);
2142             insert_kbnode( dst, n2, PKT_SIGNATURE );
2143             n2->flag |= 1;
2144             n->flag |= 1;
2145             ++*n_sigs;
2146         }
2147     }
2148
2149     return 0;
2150 }
2151
2152 /****************
2153  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2154  */
2155 static int
2156 merge_keysigs (KBNODE dst, KBNODE src, int *n_sigs,
2157                const char *fname, u32 *keyid)
2158 {
2159     KBNODE n, n2;
2160     int found=0;
2161
2162     (void)fname;
2163     (void)keyid;
2164
2165     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2166            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2167
2168     for(n=src->next; n ; n = n->next ) {
2169         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2170             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2171             break;
2172         if( n->pkt->pkttype != PKT_SIGNATURE )
2173             continue;
2174         found = 0;
2175         for(n2=dst->next; n2; n2 = n2->next){
2176             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2177                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2178                 break;
2179             if( n2->pkt->pkttype == PKT_SIGNATURE
2180                 && n->pkt->pkt.signature->keyid[0]
2181                    == n2->pkt->pkt.signature->keyid[0]
2182                 && n->pkt->pkt.signature->keyid[1]
2183                    == n2->pkt->pkt.signature->keyid[1]
2184                 && n->pkt->pkt.signature->timestamp
2185                    <= n2->pkt->pkt.signature->timestamp
2186                 && n->pkt->pkt.signature->sig_class
2187                    == n2->pkt->pkt.signature->sig_class ) {
2188                 found++;
2189                 break;
2190             }
2191         }
2192         if( !found ) {
2193             /* This signature is new or newer, append N to DST.
2194              * We add a clone to the original keyblock, because this
2195              * one is released first */
2196             n2 = clone_kbnode(n);
2197             insert_kbnode( dst, n2, PKT_SIGNATURE );
2198             n2->flag |= 1;
2199             n->flag |= 1;
2200             ++*n_sigs;
2201         }
2202     }
2203
2204     return 0;
2205 }
2206
2207 /****************
2208  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2209  * Mark all new and copied packets by setting flag bit 0.
2210  */
2211 static int
2212 append_key (KBNODE keyblock, KBNODE node, int *n_sigs,
2213             const char *fname, u32 *keyid)
2214 {
2215     KBNODE n;
2216
2217     (void)fname;
2218     (void)keyid;
2219
2220     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2221            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2222
2223     while(  node ) {
2224         /* we add a clone to the original keyblock, because this
2225          * one is released first */
2226         n = clone_kbnode(node);
2227         add_kbnode( keyblock, n );
2228         n->flag |= 1;
2229         node->flag |= 1;
2230         if( n->pkt->pkttype == PKT_SIGNATURE )
2231             ++*n_sigs;
2232
2233         node = node->next;
2234         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2235             break;
2236     }
2237
2238     return 0;
2239 }
2240
2241
2242
2243 /* Walk a public keyblock and produce a secret keyblock out of it.
2244    Instead of inserting the secret key parameters (which we don't
2245    have), we insert a stub.  */
2246 static KBNODE
2247 pub_to_sec_keyblock (KBNODE pub_keyblock)
2248 {
2249   KBNODE pubnode, secnode;
2250   KBNODE sec_keyblock = NULL;
2251   KBNODE walkctx = NULL;
2252
2253   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2254     {
2255       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2256           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2257         {
2258           /* Make a secret key.  We only need to convert enough to
2259              write the keyblock out. */
2260           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2261           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2262           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2263           int i, n;
2264           
2265           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2266             pkt->pkttype = PKT_SECRET_KEY;
2267           else
2268             pkt->pkttype = PKT_SECRET_SUBKEY;
2269           
2270           pkt->pkt.secret_key = sk;
2271
2272           copy_public_parts_to_secret_key ( pk, sk );
2273           sk->version     = pk->version;
2274           sk->timestamp   = pk->timestamp;
2275         
2276           n = pubkey_get_npkey (pk->pubkey_algo);
2277           if (!n)
2278             n = 1; /* Unknown number of parameters, however the data
2279                       is stored in the first mpi. */
2280           for (i=0; i < n; i++ )
2281             sk->skey[i] = mpi_copy (pk->pkey[i]);
2282   
2283           sk->is_protected = 1;
2284           sk->protect.s2k.mode = 1001;
2285   
2286           secnode = new_kbnode (pkt);
2287         }
2288       else
2289         {
2290           secnode = clone_kbnode (pubnode);
2291         }
2292       
2293       if(!sec_keyblock)
2294         sec_keyblock = secnode;
2295       else
2296         add_kbnode (sec_keyblock, secnode);
2297     }
2298
2299   return sec_keyblock;
2300 }
2301
2302
2303 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2304    stub keys with the serial number SNNUM of the card if one of the
2305    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2306    a duplicate (may happen in case of backed uped keys). 
2307    
2308    Returns: True if anything changed.
2309 */
2310 static int
2311 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2312                                    const unsigned char *fpr1,
2313                                    const unsigned char *fpr2,
2314                                    const unsigned char *fpr3,
2315                                    const char *serialnostr)
2316 {
2317   KBNODE node;
2318   KBNODE walkctx = NULL;
2319   PKT_secret_key *sk;
2320   byte array[MAX_FINGERPRINT_LEN];
2321   size_t n;
2322   int result = 0;
2323   const char *s;
2324
2325   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2326     {
2327       if (node->pkt->pkttype != PKT_SECRET_KEY
2328           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2329         continue;
2330       sk = node->pkt->pkt.secret_key;
2331       
2332       fingerprint_from_sk (sk, array, &n);
2333       if (n != 20)
2334         continue; /* Can't be a card key.  */
2335       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2336              || (fpr2 && !memcmp (array, fpr2, 20))
2337              || (fpr3 && !memcmp (array, fpr3, 20))) )
2338         continue;  /* No match.  */
2339
2340       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2341         {
2342           /* Standard case: migrate that stub to a key stub.  */
2343           sk->protect.s2k.mode = 1002;
2344           s = serialnostr;
2345           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2346                sk->protect.ivlen++, s += 2)
2347             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2348           result = 1;
2349         }
2350       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2351         {
2352           s = serialnostr;
2353           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2354                sk->protect.ivlen++, s += 2)
2355             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2356               {
2357                 log_info (_("NOTE: a key's S/N does not "
2358                             "match the card's one\n"));
2359                 break;
2360               }
2361         }
2362       else
2363         {
2364           if (node->pkt->pkttype != PKT_SECRET_KEY)
2365             log_info (_("NOTE: primary key is online and stored on card\n"));
2366           else
2367             log_info (_("NOTE: secondary key is online and stored on card\n"));
2368         }
2369     }
2370
2371   return result;
2372 }
2373
2374
2375
2376 /* Check whether a secret key stub exists for the public key PK.  If
2377    not create such a stub key and store it into the secring.  If it
2378    exists, add appropriate subkey stubs and update the secring.
2379    Return 0 if the key could be created. */
2380 int
2381 auto_create_card_key_stub ( const char *serialnostr, 
2382                             const unsigned char *fpr1,
2383                             const unsigned char *fpr2,
2384                             const unsigned char *fpr3)
2385 {
2386   KBNODE pub_keyblock;
2387   KBNODE sec_keyblock;
2388   KEYDB_HANDLE hd;
2389   int rc;
2390
2391   /* We only want to do this for an OpenPGP card.  */
2392   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2393       || strlen (serialnostr) != 32 )
2394     return G10ERR_GENERAL;
2395
2396   /* First get the public keyring from any of the provided fingerprints. */
2397   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2398        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2399        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2400     ;
2401   else
2402     return G10ERR_GENERAL;
2403
2404   log_debug ("FIXME: Do we need the stub at all?\n");
2405   hd = keydb_new (); /* FIXME. */
2406
2407   /* Now check whether there is a secret keyring.  */
2408   {
2409     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2410     byte afp[MAX_FINGERPRINT_LEN];
2411     size_t an;
2412
2413     fingerprint_from_pk (pk, afp, &an);
2414     if (an < MAX_FINGERPRINT_LEN)
2415       memset (afp+an, 0, MAX_FINGERPRINT_LEN-an);
2416     rc = keydb_search_fpr (hd, afp);
2417   }
2418
2419   if (!rc)
2420     {
2421       rc = keydb_get_keyblock (hd, &sec_keyblock);
2422       if (rc)
2423         {
2424           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2425           rc = G10ERR_GENERAL;
2426         }
2427       else
2428         {
2429           merge_keys_and_selfsig (sec_keyblock);
2430           
2431           /* FIXME: We need to add new subkeys first.  */
2432           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2433                                                  fpr1, fpr2, fpr3,
2434                                                  serialnostr))
2435             {
2436               rc = keydb_update_keyblock (hd, sec_keyblock );
2437               if (rc)
2438                 log_error (_("error writing keyring `%s': %s\n"),
2439                            keydb_get_resource_name (hd), g10_errstr(rc) );
2440             }
2441         }
2442     }
2443   else  /* A secret key does not exists - create it.  */
2444     {
2445       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2446       update_sec_keyblock_with_cardinfo (sec_keyblock,
2447                                          fpr1, fpr2, fpr3,
2448                                          serialnostr);
2449
2450       rc = keydb_locate_writable (hd, NULL);
2451       if (rc)
2452         {
2453           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2454           rc = G10ERR_GENERAL;
2455         }
2456       else
2457         {
2458           rc = keydb_insert_keyblock (hd, sec_keyblock );
2459           if (rc)
2460             log_error (_("error writing keyring `%s': %s\n"),
2461                        keydb_get_resource_name (hd), g10_errstr(rc) );
2462         }
2463     }
2464     
2465   release_kbnode (sec_keyblock);
2466   release_kbnode (pub_keyblock);
2467   keydb_release (hd);
2468   return rc;
2469 }