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