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