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