Preparing a release
[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   if(problem)
629     {
630       log_info(_("it is strongly suggested that you update"
631                  " your preferences and\n"));
632       log_info(_("re-distribute this key to avoid potential algorithm"
633                  " mismatch problems\n"));
634
635       if(!opt.batch)
636         {
637           STRLIST sl=NULL,locusr=NULL;
638           size_t fprlen=0;
639           byte fpr[MAX_FINGERPRINT_LEN],*p;
640           char username[(MAX_FINGERPRINT_LEN*2)+1];
641           unsigned int i;
642
643           p=fingerprint_from_pk(pk,fpr,&fprlen);
644           for(i=0;i<fprlen;i++,p++)
645             sprintf(username+2*i,"%02X",*p);
646           add_to_strlist(&locusr,username);
647
648           append_to_strlist(&sl,"updpref");
649           append_to_strlist(&sl,"save");
650
651           keyedit_menu( username, locusr, sl, 1, 1 );
652           free_strlist(sl);
653           free_strlist(locusr);
654         }
655       else if(!opt.quiet)
656         log_info(_("you can update your preferences with:"
657                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
658     }
659 }
660
661 static int
662 clean_sigs_from_all_uids(KBNODE keyblock)
663 {
664   KBNODE uidnode;
665   int deleted=0;
666
667   for(uidnode=keyblock->next;uidnode;uidnode=uidnode->next)
668     if(uidnode->pkt->pkttype==PKT_USER_ID)
669       deleted+=clean_sigs_from_uid(keyblock,uidnode,opt.verbose);
670
671   return deleted;
672 }
673
674
675 /****************
676  * Try to import one keyblock.  Return an error only in serious cases, but
677  * never for an invalid keyblock.  It uses log_error to increase the
678  * internal errorcount, so that invalid input can be detected by programs
679  * which called g10.
680  */
681 static int
682 import_one( const char *fname, KBNODE keyblock,
683             struct stats_s *stats, unsigned int options )
684 {
685     PKT_public_key *pk;
686     PKT_public_key *pk_orig;
687     KBNODE node, uidnode;
688     KBNODE keyblock_orig = NULL;
689     u32 keyid[2];
690     int rc = 0;
691     int new_key = 0;
692     int mod_key = 0;
693     int non_self = 0;
694
695     /* get the key and print some info about it */
696     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
697     if( !node )
698         BUG();
699
700     pk = node->pkt->pkt.public_key;
701     keyid_from_pk( pk, keyid );
702     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
703
704     if( opt.verbose && !opt.interactive )
705       {
706         log_info( "pub  %4u%c/%s %s  ",
707                   nbits_from_pk( pk ),
708                   pubkey_letter( pk->pubkey_algo ),
709                   keystr_from_pk(pk), datestr_from_pk(pk) );
710         if( uidnode )
711           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
712                              uidnode->pkt->pkt.user_id->len );
713         putc('\n', stderr);
714       }
715
716     if( !uidnode )
717       {
718         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
719         return 0;
720       }
721     
722     if (opt.interactive) {
723         if(is_status_enabled())
724           print_import_check (pk, uidnode->pkt->pkt.user_id);
725         merge_keys_and_selfsig (keyblock);
726         tty_printf ("\n");
727         show_basic_key_info (keyblock);
728         tty_printf ("\n");
729         if (!cpr_get_answer_is_yes ("import.okay",
730                                     "Do you want to import this key? (y/N) "))
731             return 0;
732     }
733
734     /* Clean the key that we're about to import, to cut down on things
735        that we have to clean later.  This has no practical impact on
736        the end result, but does result in less logging which might
737        confuse the user. */
738     if(options&IMPORT_CLEAN_SIGS)
739       clean_sigs_from_all_uids(keyblock);
740
741     if(options&IMPORT_CLEAN_UIDS)
742       clean_uids_from_key(keyblock,opt.verbose);
743
744     clear_kbnode_flags( keyblock );
745
746     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
747        && opt.verbose)
748       log_info(_("key %s: PKS subkey corruption repaired\n"),
749                keystr_from_pk(pk));
750
751     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
752     if( rc )
753         return rc== -1? 0:rc;
754
755     /* If we allow such a thing, mark unsigned uids as valid */
756     if( opt.allow_non_selfsigned_uid )
757       for( node=keyblock; node; node = node->next )
758         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
759           {
760             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
761                                       node->pkt->pkt.user_id->len,0);
762             node->flag |= 1;
763             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
764                       keystr_from_pk(pk),user);
765             m_free(user);
766           }
767
768     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
769         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
770         if( !opt.quiet )
771           log_info(_("this may be caused by a missing self-signature\n"));
772         stats->no_user_id++;
773         return 0;
774     }
775
776     /* do we have this key already in one of our pubrings ? */
777     pk_orig = m_alloc_clear( sizeof *pk_orig );
778     rc = get_pubkey_fast ( pk_orig, keyid );
779     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
780       {
781         log_error( _("key %s: public key not found: %s\n"),
782                    keystr(keyid), g10_errstr(rc));
783       }
784     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
785       {
786         if( opt.verbose )
787           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
788         rc = 0;
789         stats->skipped_new_keys++;
790       }
791     else if( rc ) { /* insert this key */
792         KEYDB_HANDLE hd = keydb_new (0);
793
794         rc = keydb_locate_writable (hd, NULL);
795         if (rc) {
796             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
797             keydb_release (hd);
798             return G10ERR_GENERAL;
799         }
800         if( opt.verbose > 1 )
801             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
802
803         collapse_uids(&keyblock);
804
805         rc = keydb_insert_keyblock (hd, keyblock );
806         if (rc)
807            log_error (_("error writing keyring `%s': %s\n"),
808                        keydb_get_resource_name (hd), g10_errstr(rc));
809         else
810           {
811             /* This should not be possible since we delete the
812                ownertrust when a key is deleted, but it can happen if
813                the keyring and trustdb are out of sync.  It can also
814                be made to happen with the trusted-key command. */
815
816             clear_ownertrusts (pk);
817             if(non_self)
818               revalidation_mark ();
819           }
820         keydb_release (hd);
821
822         /* we are ready */
823         if( !opt.quiet )
824           {
825             char *p=get_user_id_native (keyid);
826             log_info( _("key %s: public key \"%s\" imported\n"),
827                       keystr(keyid),p);
828             m_free(p);
829           }
830         if( is_status_enabled() )
831           {
832             char *us = get_long_user_id_string( keyid );
833             write_status_text( STATUS_IMPORTED, us );
834             m_free(us);
835             print_import_ok (pk,NULL, 1);
836           }
837         stats->imported++;
838         if( is_RSA( pk->pubkey_algo ) )
839             stats->imported_rsa++;
840         new_key = 1;
841     }
842     else { /* merge */
843         KEYDB_HANDLE hd;
844         int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
845
846         /* Compare the original against the new key; just to be sure nothing
847          * weird is going on */
848         if( cmp_public_keys( pk_orig, pk ) )
849           {
850             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
851             goto leave;
852           }
853
854         /* now read the original keyblock */
855         hd = keydb_new (0);
856         {
857             byte afp[MAX_FINGERPRINT_LEN];
858             size_t an;
859
860             fingerprint_from_pk (pk_orig, afp, &an);
861             while (an < MAX_FINGERPRINT_LEN) 
862                 afp[an++] = 0;
863             rc = keydb_search_fpr (hd, afp);
864         }
865         if( rc )
866           {
867             log_error (_("key %s: can't locate original keyblock: %s\n"),
868                        keystr(keyid), g10_errstr(rc));
869             keydb_release (hd);
870             goto leave;
871           }
872         rc = keydb_get_keyblock (hd, &keyblock_orig );
873         if (rc)
874           {
875             log_error (_("key %s: can't read original keyblock: %s\n"),
876                        keystr(keyid), g10_errstr(rc));
877             keydb_release (hd);
878             goto leave;
879           }
880
881         collapse_uids( &keyblock );
882         /* and try to merge the block */
883         clear_kbnode_flags( keyblock_orig );
884         clear_kbnode_flags( keyblock );
885         n_uids = n_sigs = n_subk = n_sigs_cleaned = n_uids_cleaned = 0;
886         rc = merge_blocks( fname, keyblock_orig, keyblock,
887                            keyid, &n_uids, &n_sigs, &n_subk );
888         if( rc )
889           {
890             keydb_release (hd);
891             goto leave;
892           }
893
894         if(options&IMPORT_CLEAN_SIGS)
895           n_sigs_cleaned=clean_sigs_from_all_uids(keyblock_orig);
896
897         if(options&IMPORT_CLEAN_UIDS)
898           n_uids_cleaned=clean_uids_from_key(keyblock_orig,opt.verbose);
899
900         if( n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned) {
901             mod_key = 1;
902             /* keyblock_orig has been updated; write */
903             rc = keydb_update_keyblock (hd, keyblock_orig);
904             if (rc)
905                 log_error (_("error writing keyring `%s': %s\n"),
906                              keydb_get_resource_name (hd), g10_errstr(rc) );
907             else if(non_self)
908               revalidation_mark ();
909
910             /* we are ready */
911             if( !opt.quiet )
912               {
913                 char *p=get_user_id_native(keyid);
914                 if( n_uids == 1 )
915                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
916                            keystr(keyid),p);
917                 else if( n_uids )
918                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
919                             keystr(keyid),p,n_uids);
920                 if( n_sigs == 1 )
921                   log_info( _("key %s: \"%s\" 1 new signature\n"),
922                             keystr(keyid), p);
923                 else if( n_sigs )
924                   log_info( _("key %s: \"%s\" %d new signatures\n"),
925                             keystr(keyid), p, n_sigs );
926                 if( n_subk == 1 )
927                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
928                             keystr(keyid), p);
929                 else if( n_subk )
930                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
931                             keystr(keyid), p, n_subk );
932                 if(n_sigs_cleaned==1)
933                   log_info(_("key %s: \"%s\" %d signature cleaned\n"),
934                            keystr(keyid),p,n_sigs_cleaned);
935                 else if(n_sigs_cleaned)
936                   log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
937                            keystr(keyid),p,n_sigs_cleaned);
938                 if(n_uids_cleaned==1)
939                   log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
940                            keystr(keyid),p,n_uids_cleaned);
941                 else if(n_uids_cleaned)
942                   log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
943                            keystr(keyid),p,n_uids_cleaned);
944                 m_free(p);
945               }
946
947             stats->n_uids +=n_uids;
948             stats->n_sigs +=n_sigs;
949             stats->n_subk +=n_subk;
950             stats->n_sigs_cleaned +=n_sigs_cleaned;
951             stats->n_uids_cleaned +=n_uids_cleaned;
952
953             if (is_status_enabled ()) 
954                  print_import_ok (pk, NULL,
955                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
956         }
957         else
958           {
959             if (is_status_enabled ()) 
960               print_import_ok (pk, NULL, 0);
961
962             if( !opt.quiet )
963               {
964                 char *p=get_user_id_native(keyid);
965                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
966                 m_free(p);
967               }
968
969             stats->unchanged++;
970           }
971
972         keydb_release (hd); hd = NULL;
973     }
974
975   leave:
976
977     /* Now that the key is definitely incorporated into the keydb, we
978        need to check if a designated revocation is present or if the
979        prefs are not rational so we can warn the user. */
980
981     if(mod_key)
982       {
983         revocation_present(keyblock_orig);
984         if(seckey_available(keyid)==0)
985           check_prefs(keyblock_orig);
986       }
987     else if(new_key)
988       {
989         revocation_present(keyblock);
990         if(seckey_available(keyid)==0)
991           check_prefs(keyblock);
992       }
993
994     release_kbnode( keyblock_orig );
995     free_public_key( pk_orig );
996
997     return rc;
998 }
999
1000 /* Walk a secret keyblock and produce a public keyblock out of it. */
1001 static KBNODE
1002 sec_to_pub_keyblock(KBNODE sec_keyblock)
1003 {
1004   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
1005
1006   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
1007     {
1008       KBNODE pubnode;
1009
1010       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
1011          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
1012         {
1013           /* Make a public key.  We only need to convert enough to
1014              write the keyblock out. */
1015
1016           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
1017           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
1018           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
1019           int n;
1020
1021           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
1022             pkt->pkttype=PKT_PUBLIC_KEY;
1023           else
1024             pkt->pkttype=PKT_PUBLIC_SUBKEY;
1025
1026           pkt->pkt.public_key=pk;
1027
1028           pk->version=sk->version;
1029           pk->timestamp=sk->timestamp;
1030           pk->expiredate=sk->expiredate;
1031           pk->pubkey_algo=sk->pubkey_algo;
1032
1033           n=pubkey_get_npkey(pk->pubkey_algo);
1034           if(n==0)
1035             {
1036               /* we can't properly extract the pubkey without knowing
1037                  the number of MPIs */
1038               release_kbnode(pub_keyblock);
1039               return NULL;
1040             }
1041           else
1042             {
1043               int i;
1044
1045               for(i=0;i<n;i++)
1046                 pk->pkey[i]=mpi_copy(sk->skey[i]);
1047             }
1048
1049           pubnode=new_kbnode(pkt);
1050         }
1051       else
1052         {
1053           pubnode=clone_kbnode(secnode);
1054         }
1055
1056       if(pub_keyblock==NULL)
1057         pub_keyblock=pubnode;
1058       else
1059         add_kbnode(pub_keyblock,pubnode);
1060     }
1061
1062   return pub_keyblock;
1063 }
1064
1065 /****************
1066  * Ditto for secret keys.  Handling is simpler than for public keys.
1067  * We allow secret key importing only when allow is true, this is so
1068  * that a secret key can not be imported accidently and thereby tampering
1069  * with the trust calculation.
1070  */
1071 static int
1072 import_secret_one( const char *fname, KBNODE keyblock, 
1073                    struct stats_s *stats, unsigned int options)
1074 {
1075     PKT_secret_key *sk;
1076     KBNODE node, uidnode;
1077     u32 keyid[2];
1078     int rc = 0;
1079
1080     /* get the key and print some info about it */
1081     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1082     if( !node )
1083         BUG();
1084
1085     sk = node->pkt->pkt.secret_key;
1086     keyid_from_sk( sk, keyid );
1087     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1088
1089     if( opt.verbose )
1090       {
1091         log_info( "sec  %4u%c/%s %s   ",
1092                   nbits_from_sk( sk ),
1093                   pubkey_letter( sk->pubkey_algo ),
1094                   keystr_from_sk(sk), datestr_from_sk(sk) );
1095         if( uidnode )
1096           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1097                              uidnode->pkt->pkt.user_id->len );
1098         putc('\n', stderr);
1099       }
1100     stats->secret_read++;
1101
1102     if( !uidnode )
1103       {
1104         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1105         return 0;
1106       }
1107
1108     if(sk->protect.algo>110)
1109       {
1110         log_error(_("key %s: secret key with invalid cipher %d"
1111                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1112         return 0;
1113       }
1114
1115 #ifdef ENABLE_SELINUX_HACKS
1116     if (1)
1117       {
1118         /* We don't allow to import secret keys because that may be used
1119            to put a secret key into the keyring and the user might later
1120            be tricked into signing stuff with that key.  */
1121         log_error (_("importing secret keys not allowed\n"));
1122         return 0;
1123       }
1124 #endif 
1125     
1126     clear_kbnode_flags( keyblock );
1127
1128     /* do we have this key already in one of our secrings ? */
1129     rc = seckey_available( keyid );
1130     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1131       {
1132         /* simply insert this key */
1133         KEYDB_HANDLE hd = keydb_new (1);
1134
1135         /* get default resource */
1136         rc = keydb_locate_writable (hd, NULL);
1137         if (rc) {
1138           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1139           keydb_release (hd);
1140           return G10ERR_GENERAL;
1141         }
1142         rc = keydb_insert_keyblock (hd, keyblock );
1143         if (rc)
1144           log_error (_("error writing keyring `%s': %s\n"),
1145                      keydb_get_resource_name (hd), g10_errstr(rc) );
1146         keydb_release (hd);
1147         /* we are ready */
1148         if( !opt.quiet )
1149           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1150         stats->secret_imported++;
1151         if (is_status_enabled ()) 
1152           print_import_ok (NULL, sk, 1|16);
1153
1154         if(options&IMPORT_SK2PK)
1155           {
1156             /* Try and make a public key out of this. */
1157
1158             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1159             if(pub_keyblock)
1160               {
1161                 import_one(fname,pub_keyblock,stats,opt.import_options);
1162                 release_kbnode(pub_keyblock);
1163               }
1164           }
1165
1166         /* Now that the key is definitely incorporated into the keydb,
1167            if we have the public part of this key, we need to check if
1168            the prefs are rational. */
1169         node=get_pubkeyblock(keyid);
1170         if(node)
1171           {
1172             check_prefs(node);
1173             release_kbnode(node);
1174           }
1175       }
1176     else if( !rc )
1177       { /* we can't merge secret keys */
1178         log_error( _("key %s: already in secret keyring\n"),
1179                    keystr_from_sk(sk));
1180         stats->secret_dups++;
1181         if (is_status_enabled ()) 
1182           print_import_ok (NULL, sk, 16);
1183
1184         /* TODO: if we ever do merge secret keys, make sure to handle
1185            the sec_to_pub_keyblock feature as well. */
1186       }
1187     else
1188       log_error( _("key %s: secret key not found: %s\n"),
1189                  keystr_from_sk(sk), g10_errstr(rc));
1190
1191     return rc;
1192 }
1193
1194
1195 /****************
1196  * Import a revocation certificate; this is a single signature packet.
1197  */
1198 static int
1199 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1200 {
1201     PKT_public_key *pk=NULL;
1202     KBNODE onode, keyblock = NULL;
1203     KEYDB_HANDLE hd = NULL;
1204     u32 keyid[2];
1205     int rc = 0;
1206
1207     assert( !node->next );
1208     assert( node->pkt->pkttype == PKT_SIGNATURE );
1209     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1210
1211     keyid[0] = node->pkt->pkt.signature->keyid[0];
1212     keyid[1] = node->pkt->pkt.signature->keyid[1];
1213
1214     pk = m_alloc_clear( sizeof *pk );
1215     rc = get_pubkey( pk, keyid );
1216     if( rc == G10ERR_NO_PUBKEY )
1217       {
1218         log_error(_("key %s: no public key -"
1219                     " can't apply revocation certificate\n"), keystr(keyid));
1220         rc = 0;
1221         goto leave;
1222       }
1223     else if( rc )
1224       {
1225         log_error(_("key %s: public key not found: %s\n"),
1226                   keystr(keyid), g10_errstr(rc));
1227         goto leave;
1228       }
1229
1230     /* read the original keyblock */
1231     hd = keydb_new (0);
1232     {
1233         byte afp[MAX_FINGERPRINT_LEN];
1234         size_t an;
1235         
1236         fingerprint_from_pk (pk, afp, &an);
1237         while (an < MAX_FINGERPRINT_LEN) 
1238             afp[an++] = 0;
1239         rc = keydb_search_fpr (hd, afp);
1240     }
1241     if (rc)
1242       {
1243         log_error (_("key %s: can't locate original keyblock: %s\n"),
1244                    keystr(keyid), g10_errstr(rc));
1245         goto leave;
1246       }
1247     rc = keydb_get_keyblock (hd, &keyblock );
1248     if (rc)
1249       {
1250         log_error (_("key %s: can't read original keyblock: %s\n"),
1251                    keystr(keyid), g10_errstr(rc));
1252         goto leave;
1253       }
1254
1255     /* it is okay, that node is not in keyblock because
1256      * check_key_signature works fine for sig_class 0x20 in this
1257      * special case. */
1258     rc = check_key_signature( keyblock, node, NULL);
1259     if( rc )
1260       {
1261         log_error( _("key %s: invalid revocation certificate"
1262                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1263         goto leave;
1264       }
1265
1266     /* check whether we already have this */
1267     for(onode=keyblock->next; onode; onode=onode->next ) {
1268         if( onode->pkt->pkttype == PKT_USER_ID )
1269             break;
1270         else if( onode->pkt->pkttype == PKT_SIGNATURE
1271                  && !cmp_signatures(node->pkt->pkt.signature,
1272                                     onode->pkt->pkt.signature))
1273           {
1274             rc = 0;
1275             goto leave; /* yes, we already know about it */
1276           }
1277     }
1278
1279
1280     /* insert it */
1281     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1282
1283     /* and write the keyblock back */
1284     rc = keydb_update_keyblock (hd, keyblock );
1285     if (rc)
1286         log_error (_("error writing keyring `%s': %s\n"),
1287                    keydb_get_resource_name (hd), g10_errstr(rc) );
1288     keydb_release (hd); hd = NULL;
1289     /* we are ready */
1290     if( !opt.quiet )
1291       {
1292         char *p=get_user_id_native (keyid);
1293         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1294                   keystr(keyid),p);
1295         m_free(p);
1296       }
1297     stats->n_revoc++;
1298
1299     /* If the key we just revoked was ultimately trusted, remove its
1300        ultimate trust.  This doesn't stop the user from putting the
1301        ultimate trust back, but is a reasonable solution for now. */
1302     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1303       clear_ownertrusts(pk);
1304
1305     revalidation_mark ();
1306
1307   leave:
1308     keydb_release (hd);
1309     release_kbnode( keyblock );
1310     free_public_key( pk );
1311     return rc;
1312 }
1313
1314
1315 /****************
1316  * loop over the keyblock and check all self signatures.
1317  * Mark all user-ids with a self-signature by setting flag bit 0.
1318  * Mark all user-ids with an invalid self-signature by setting bit 1.
1319  * This works also for subkeys, here the subkey is marked.  Invalid or
1320  * extra subkey sigs (binding or revocation) are marked for deletion.
1321  * non_self is set to true if there are any sigs other than self-sigs
1322  * in this keyblock.
1323  */
1324 static int
1325 chk_self_sigs( const char *fname, KBNODE keyblock,
1326                PKT_public_key *pk, u32 *keyid, int *non_self )
1327 {
1328     KBNODE n,knode=NULL;
1329     PKT_signature *sig;
1330     int rc;
1331     u32 bsdate=0,rsdate=0;
1332     KBNODE bsnode=NULL,rsnode=NULL;
1333
1334     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1335       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1336         {
1337           knode=n;
1338           bsdate=0;
1339           rsdate=0;
1340           bsnode=NULL;
1341           rsnode=NULL;
1342           continue;
1343         }
1344       else if( n->pkt->pkttype != PKT_SIGNATURE )
1345             continue;
1346         sig = n->pkt->pkt.signature;
1347         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1348
1349             /* This just caches the sigs for later use.  That way we
1350                import a fully-cached key which speeds things up. */
1351             if(!opt.no_sig_cache)
1352               check_key_signature(keyblock,n,NULL);
1353
1354             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1355               {
1356                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1357                 if( !unode )
1358                   {
1359                     log_error( _("key %s: no user ID for signature\n"),
1360                                keystr(keyid));
1361                     return -1;  /* the complete keyblock is invalid */
1362                   }
1363
1364                 /* If it hasn't been marked valid yet, keep trying */
1365                 if(!(unode->flag&1)) {
1366                   rc = check_key_signature( keyblock, n, NULL);
1367                   if( rc )
1368                     {
1369                       if( opt.verbose )
1370                         {
1371                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1372                                       strlen(unode->pkt->pkt.user_id->name),0);
1373                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1374                                     _("key %s: unsupported public key "
1375                                       "algorithm on user ID \"%s\"\n"):
1376                                     _("key %s: invalid self-signature "
1377                                       "on user ID \"%s\"\n"),
1378                                     keystr(keyid),p);
1379                           m_free(p);
1380                         }
1381                     }
1382                   else
1383                     unode->flag |= 1; /* mark that signature checked */
1384                 }
1385               }
1386             else if( sig->sig_class == 0x18 ) {
1387               /* Note that this works based solely on the timestamps
1388                  like the rest of gpg.  If the standard gets
1389                  revocation targets, this may need to be revised. */
1390
1391                 if( !knode )
1392                   {
1393                     if(opt.verbose)
1394                       log_info( _("key %s: no subkey for key binding\n"),
1395                                 keystr(keyid));
1396                     n->flag |= 4; /* delete this */
1397                   }
1398                 else
1399                   {
1400                     rc = check_key_signature( keyblock, n, NULL);
1401                     if( rc )
1402                       {
1403                         if(opt.verbose)
1404                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1405                                    _("key %s: unsupported public key"
1406                                      " algorithm\n"):
1407                                    _("key %s: invalid subkey binding\n"),
1408                                    keystr(keyid));
1409                         n->flag|=4;
1410                       }
1411                     else
1412                       {
1413                         /* It's valid, so is it newer? */
1414                         if(sig->timestamp>=bsdate) {
1415                           knode->flag |= 1;  /* the subkey is valid */
1416                           if(bsnode)
1417                             {
1418                               bsnode->flag|=4; /* Delete the last binding
1419                                                   sig since this one is
1420                                                   newer */
1421                               if(opt.verbose)
1422                                 log_info(_("key %s: removed multiple subkey"
1423                                            " binding\n"),keystr(keyid));
1424                             }
1425
1426                           bsnode=n;
1427                           bsdate=sig->timestamp;
1428                         }
1429                         else
1430                           n->flag|=4; /* older */
1431                       }
1432                   }
1433             }
1434             else if( sig->sig_class == 0x28 ) {
1435               /* We don't actually mark the subkey as revoked right
1436                  now, so just check that the revocation sig is the
1437                  most recent valid one.  Note that we don't care if
1438                  the binding sig is newer than the revocation sig.
1439                  See the comment in getkey.c:merge_selfsigs_subkey for
1440                  more */
1441                 if( !knode )
1442                   {
1443                     if(opt.verbose)
1444                       log_info( _("key %s: no subkey for key revocation\n"),
1445                                 keystr(keyid));
1446                     n->flag |= 4; /* delete this */
1447                   }
1448                 else
1449                   {
1450                     rc = check_key_signature( keyblock, n, NULL);
1451                     if( rc )
1452                       {
1453                         if(opt.verbose)
1454                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1455                                    _("key %s: unsupported public"
1456                                      " key algorithm\n"):
1457                                    _("key %s: invalid subkey revocation\n"),
1458                                    keystr(keyid));
1459                         n->flag|=4;
1460                       }
1461                     else
1462                       {
1463                         /* It's valid, so is it newer? */
1464                         if(sig->timestamp>=rsdate)
1465                           {
1466                             if(rsnode)
1467                               {
1468                                 rsnode->flag|=4; /* Delete the last revocation
1469                                                     sig since this one is
1470                                                     newer */
1471                                 if(opt.verbose)
1472                                   log_info(_("key %s: removed multiple subkey"
1473                                              " revocation\n"),keystr(keyid));
1474                               }
1475
1476                             rsnode=n;
1477                             rsdate=sig->timestamp;
1478                           }
1479                         else
1480                           n->flag|=4; /* older */
1481                       }
1482                   }
1483             }
1484         }
1485         else
1486           *non_self=1;
1487     }
1488
1489     return 0;
1490 }
1491
1492 /****************
1493  * delete all parts which are invalid and those signatures whose
1494  * public key algorithm is not available in this implemenation;
1495  * but consider RSA as valid, because parse/build_packets knows
1496  * about it.
1497  * returns: true if at least one valid user-id is left over.
1498  */
1499 static int
1500 delete_inv_parts( const char *fname, KBNODE keyblock,
1501                   u32 *keyid, unsigned int options)
1502 {
1503     KBNODE node;
1504     int nvalid=0, uid_seen=0, subkey_seen=0;
1505
1506     for(node=keyblock->next; node; node = node->next ) {
1507         if( node->pkt->pkttype == PKT_USER_ID ) {
1508             uid_seen = 1;
1509             if( (node->flag & 2) || !(node->flag & 1) ) {
1510                 if( opt.verbose )
1511                   {
1512                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1513                                            node->pkt->pkt.user_id->len,0);
1514                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1515                               keystr(keyid),p);
1516                     m_free(p);
1517                   }
1518                 delete_kbnode( node ); /* the user-id */
1519                 /* and all following packets up to the next user-id */
1520                 while( node->next
1521                        && node->next->pkt->pkttype != PKT_USER_ID
1522                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1523                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1524                     delete_kbnode( node->next );
1525                     node = node->next;
1526                 }
1527             }
1528             else
1529                 nvalid++;
1530         }
1531         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1532                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1533             if( (node->flag & 2) || !(node->flag & 1) ) {
1534                 if( opt.verbose )
1535                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1536
1537                 delete_kbnode( node ); /* the subkey */
1538                 /* and all following signature packets */
1539                 while( node->next
1540                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1541                     delete_kbnode( node->next );
1542                     node = node->next;
1543                 }
1544             }
1545             else
1546               subkey_seen = 1;
1547         }
1548         else if( node->pkt->pkttype == PKT_SIGNATURE
1549                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1550                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1551             delete_kbnode( node ); /* build_packet() can't handle this */
1552         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1553                  !node->pkt->pkt.signature->flags.exportable &&
1554                  !(options&IMPORT_LOCAL_SIGS) &&
1555                  seckey_available( node->pkt->pkt.signature->keyid ) )
1556           {
1557             /* here we violate the rfc a bit by still allowing
1558              * to import non-exportable signature when we have the
1559              * the secret key used to create this signature - it
1560              * seems that this makes sense */
1561             if(opt.verbose)
1562               log_info( _("key %s: non exportable signature"
1563                           " (class 0x%02X) - skipped\n"),
1564                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1565             delete_kbnode( node );
1566           }
1567         else if( node->pkt->pkttype == PKT_SIGNATURE
1568                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1569             if( uid_seen )
1570               {
1571                 if(opt.verbose)
1572                   log_info( _("key %s: revocation certificate"
1573                               " at wrong place - skipped\n"),keystr(keyid));
1574                 delete_kbnode( node );
1575               }
1576             else {
1577               /* If the revocation cert is from a different key than
1578                  the one we're working on don't check it - it's
1579                  probably from a revocation key and won't be
1580                  verifiable with this key anyway. */
1581
1582               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1583                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1584                 {
1585                   int rc = check_key_signature( keyblock, node, NULL);
1586                   if( rc )
1587                     {
1588                       if(opt.verbose)
1589                         log_info( _("key %s: invalid revocation"
1590                                     " certificate: %s - skipped\n"),
1591                                   keystr(keyid), g10_errstr(rc));
1592                       delete_kbnode( node );
1593                     }
1594                 }
1595             }
1596         }
1597         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1598                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1599                   node->pkt->pkt.signature->sig_class == 0x28) &&
1600                  !subkey_seen )
1601           {
1602             if(opt.verbose)
1603               log_info( _("key %s: subkey signature"
1604                           " in wrong place - skipped\n"), keystr(keyid));
1605             delete_kbnode( node );
1606           }
1607         else if( node->pkt->pkttype == PKT_SIGNATURE
1608                  && !IS_CERT(node->pkt->pkt.signature))
1609           {
1610             if(opt.verbose)
1611               log_info(_("key %s: unexpected signature class (0x%02X) -"
1612                          " skipped\n"),keystr(keyid),
1613                        node->pkt->pkt.signature->sig_class);
1614             delete_kbnode(node);
1615           }
1616         else if( (node->flag & 4) ) /* marked for deletion */
1617           delete_kbnode( node );
1618     }
1619
1620     /* note: because keyblock is the public key, it is never marked
1621      * for deletion and so keyblock cannot change */
1622     commit_kbnode( &keyblock );
1623     return nvalid;
1624 }
1625
1626
1627 /****************
1628  * It may happen that the imported keyblock has duplicated user IDs.
1629  * We check this here and collapse those user IDs together with their
1630  * sigs into one.
1631  * Returns: True if the keyblock hash changed.
1632  */
1633 int
1634 collapse_uids( KBNODE *keyblock )
1635 {
1636     KBNODE n, n2;
1637     int in_uid;
1638     int any=0;
1639
1640   restart:
1641     for( n = *keyblock; n; n = n->next ) {
1642         if( n->pkt->pkttype != PKT_USER_ID )
1643             continue;
1644         for( n2 = n->next; n2; n2 = n2->next ) {
1645             if( n2->pkt->pkttype == PKT_USER_ID
1646                 && !cmp_user_ids( n->pkt->pkt.user_id,
1647                                   n2->pkt->pkt.user_id ) ) {
1648                 /* found a duplicate */
1649                 any = 1;
1650                 if( !n2->next
1651                     || n2->next->pkt->pkttype == PKT_USER_ID
1652                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1653                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1654                     /* no more signatures: delete the user ID
1655                      * and start over */
1656                     remove_kbnode( keyblock, n2 );
1657                 }
1658                 else {
1659                     /* The simple approach: Move one signature and
1660                      * then start over to delete the next one :-( */
1661                     move_kbnode( keyblock, n2->next, n->next );
1662                 }
1663                 goto restart;
1664             }
1665         }
1666     }
1667     if( !any )
1668         return 0;
1669
1670   restart_sig:
1671     /* now we may have duplicate signatures on one user ID: fix this */
1672     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1673         if( n->pkt->pkttype == PKT_USER_ID )
1674             in_uid = 1;
1675         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1676                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1677             in_uid = 0;
1678         else if( in_uid ) {
1679             n2 = n;
1680             do {
1681                 KBNODE ncmp = NULL;
1682                 for( ; n2; n2 = n2->next ) {
1683                     if(    n2->pkt->pkttype == PKT_USER_ID
1684                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1685                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1686                         break;
1687                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1688                         ;
1689                     else if( !ncmp )
1690                         ncmp = n2;
1691                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1692                                                 n2->pkt->pkt.signature )) {
1693                         remove_kbnode( keyblock, n2 );
1694                         goto restart_sig;
1695                     }
1696                 }
1697                 n2 = ncmp? ncmp->next : NULL;
1698             } while( n2 );
1699         }
1700     }
1701
1702     if(!opt.quiet)
1703       {
1704         const char *key="???";
1705
1706         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1707           key=keystr_from_pk(n->pkt->pkt.public_key);
1708         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1709           key=keystr_from_sk(n->pkt->pkt.secret_key);
1710
1711         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1712       }
1713
1714     return 1;
1715 }
1716
1717 /* Check for a 0x20 revocation from a revocation key that is not
1718    present.  This may be called without the benefit of merge_xxxx so
1719    you can't rely on pk->revkey and friends. */
1720 static void
1721 revocation_present(KBNODE keyblock)
1722 {
1723   KBNODE onode,inode;
1724   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1725
1726   for(onode=keyblock->next;onode;onode=onode->next)
1727     {
1728       /* If we reach user IDs, we're done. */
1729       if(onode->pkt->pkttype==PKT_USER_ID)
1730         break;
1731
1732       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1733          onode->pkt->pkt.signature->sig_class==0x1F &&
1734          onode->pkt->pkt.signature->revkey)
1735         {
1736           int idx;
1737           PKT_signature *sig=onode->pkt->pkt.signature;
1738
1739           for(idx=0;idx<sig->numrevkeys;idx++)
1740             {
1741               u32 keyid[2];
1742
1743               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1744                                      MAX_FINGERPRINT_LEN,keyid);
1745
1746               for(inode=keyblock->next;inode;inode=inode->next)
1747                 {
1748                   /* If we reach user IDs, we're done. */
1749                   if(inode->pkt->pkttype==PKT_USER_ID)
1750                     break;
1751
1752                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1753                      inode->pkt->pkt.signature->sig_class==0x20 &&
1754                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1755                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1756                     {
1757                       /* Okay, we have a revocation key, and a
1758                          revocation issued by it.  Do we have the key
1759                          itself? */
1760                       int rc;
1761
1762                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1763                                                    MAX_FINGERPRINT_LEN);
1764                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1765                         {
1766                           char *tempkeystr=m_strdup(keystr_from_pk(pk));
1767
1768                           /* No, so try and get it */
1769                           if(opt.keyserver
1770                              && (opt.keyserver_options.options
1771                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1772                             {
1773                               log_info(_("WARNING: key %s may be revoked:"
1774                                          " fetching revocation key %s\n"),
1775                                        tempkeystr,keystr(keyid));
1776                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1777                                                       MAX_FINGERPRINT_LEN,
1778                                                       opt.keyserver);
1779
1780                               /* Do we have it now? */
1781                               rc=get_pubkey_byfprint_fast (NULL,
1782                                                      sig->revkey[idx]->fpr,
1783                                                      MAX_FINGERPRINT_LEN);
1784                             }
1785
1786                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1787                             log_info(_("WARNING: key %s may be revoked:"
1788                                        " revocation key %s not present.\n"),
1789                                      tempkeystr,keystr(keyid));
1790
1791                           m_free(tempkeystr);
1792                         }
1793                     }
1794                 }
1795             }
1796         }
1797     }
1798 }
1799
1800 /****************
1801  * compare and merge the blocks
1802  *
1803  * o compare the signatures: If we already have this signature, check
1804  *   that they compare okay; if not, issue a warning and ask the user.
1805  * o Simply add the signature.  Can't verify here because we may not have
1806  *   the signature's public key yet; verification is done when putting it
1807  *   into the trustdb, which is done automagically as soon as this pubkey
1808  *   is used.
1809  * Note: We indicate newly inserted packets with flag bit 0
1810  */
1811 static int
1812 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1813               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1814 {
1815     KBNODE onode, node;
1816     int rc, found;
1817
1818     /* 1st: handle revocation certificates */
1819     for(node=keyblock->next; node; node=node->next ) {
1820         if( node->pkt->pkttype == PKT_USER_ID )
1821             break;
1822         else if( node->pkt->pkttype == PKT_SIGNATURE
1823                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1824             /* check whether we already have this */
1825             found = 0;
1826             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1827                 if( onode->pkt->pkttype == PKT_USER_ID )
1828                     break;
1829                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1830                          && onode->pkt->pkt.signature->sig_class == 0x20
1831                          && !cmp_signatures(onode->pkt->pkt.signature,
1832                                             node->pkt->pkt.signature))
1833                   {
1834                     found = 1;
1835                     break;
1836                   }
1837             }
1838             if( !found ) {
1839                 KBNODE n2 = clone_kbnode(node);
1840                 insert_kbnode( keyblock_orig, n2, 0 );
1841                 n2->flag |= 1;
1842                 ++*n_sigs;
1843                 if(!opt.quiet)
1844                   {
1845                     char *p=get_user_id_native (keyid);
1846                     log_info(_("key %s: \"%s\" revocation"
1847                                " certificate added\n"), keystr(keyid),p);
1848                     m_free(p);
1849                   }
1850             }
1851         }
1852     }
1853
1854     /* 2nd: merge in any direct key (0x1F) sigs */
1855     for(node=keyblock->next; node; node=node->next ) {
1856         if( node->pkt->pkttype == PKT_USER_ID )
1857             break;
1858         else if( node->pkt->pkttype == PKT_SIGNATURE
1859                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1860             /* check whether we already have this */
1861             found = 0;
1862             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1863                 if( onode->pkt->pkttype == PKT_USER_ID )
1864                     break;
1865                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1866                          && onode->pkt->pkt.signature->sig_class == 0x1F
1867                          && !cmp_signatures(onode->pkt->pkt.signature,
1868                                             node->pkt->pkt.signature)) {
1869                     found = 1;
1870                     break;
1871                 }
1872             }
1873             if( !found )
1874               {
1875                 KBNODE n2 = clone_kbnode(node);
1876                 insert_kbnode( keyblock_orig, n2, 0 );
1877                 n2->flag |= 1;
1878                 ++*n_sigs;
1879                 if(!opt.quiet)
1880                   log_info( _("key %s: direct key signature added\n"),
1881                             keystr(keyid));
1882               }
1883         }
1884     }
1885
1886     /* 3rd: try to merge new certificates in */
1887     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1888         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1889             /* find the user id in the imported keyblock */
1890             for(node=keyblock->next; node; node=node->next )
1891                 if( node->pkt->pkttype == PKT_USER_ID
1892                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1893                                           node->pkt->pkt.user_id ) )
1894                     break;
1895             if( node ) { /* found: merge */
1896                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1897                 if( rc )
1898                     return rc;
1899             }
1900         }
1901     }
1902
1903     /* 4th: add new user-ids */
1904     for(node=keyblock->next; node; node=node->next ) {
1905         if( node->pkt->pkttype == PKT_USER_ID) {
1906             /* do we have this in the original keyblock */
1907             for(onode=keyblock_orig->next; onode; onode=onode->next )
1908                 if( onode->pkt->pkttype == PKT_USER_ID
1909                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1910                                       node->pkt->pkt.user_id ) )
1911                     break;
1912             if( !onode ) { /* this is a new user id: append */
1913                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1914                 if( rc )
1915                     return rc;
1916                 ++*n_uids;
1917             }
1918         }
1919     }
1920
1921     /* 5th: add new subkeys */
1922     for(node=keyblock->next; node; node=node->next ) {
1923         onode = NULL;
1924         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1925             /* do we have this in the original keyblock? */
1926             for(onode=keyblock_orig->next; onode; onode=onode->next )
1927                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1928                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1929                                          node->pkt->pkt.public_key ) )
1930                     break;
1931             if( !onode ) { /* this is a new subkey: append */
1932                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1933                 if( rc )
1934                     return rc;
1935                 ++*n_subk;
1936             }
1937         }
1938         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1939             /* do we have this in the original keyblock? */
1940             for(onode=keyblock_orig->next; onode; onode=onode->next )
1941                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1942                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1943                                          node->pkt->pkt.secret_key ) )
1944                     break;
1945             if( !onode ) { /* this is a new subkey: append */
1946                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1947                 if( rc )
1948                     return rc;
1949                 ++*n_subk;
1950             }
1951         }
1952     }
1953
1954     /* 6th: merge subkey certificates */
1955     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1956         if( !(onode->flag & 1)
1957             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1958                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1959             /* find the subkey in the imported keyblock */
1960             for(node=keyblock->next; node; node=node->next ) {
1961                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1962                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1963                                           node->pkt->pkt.public_key ) )
1964                     break;
1965                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1966                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1967                                           node->pkt->pkt.secret_key ) )
1968                     break;
1969             }
1970             if( node ) { /* found: merge */
1971                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1972                 if( rc )
1973                     return rc;
1974             }
1975         }
1976     }
1977
1978
1979     return 0;
1980 }
1981
1982
1983 /****************
1984  * append the userid starting with NODE and all signatures to KEYBLOCK.
1985  */
1986 static int
1987 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1988                                           const char *fname, u32 *keyid )
1989 {
1990     KBNODE n, n_where=NULL;
1991
1992     assert(node->pkt->pkttype == PKT_USER_ID );
1993
1994     /* find the position */
1995     for( n = keyblock; n; n_where = n, n = n->next ) {
1996         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1997             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1998             break;
1999     }
2000     if( !n )
2001         n_where = NULL;
2002
2003     /* and append/insert */
2004     while( node ) {
2005         /* we add a clone to the original keyblock, because this
2006          * one is released first */
2007         n = clone_kbnode(node);
2008         if( n_where ) {
2009             insert_kbnode( n_where, n, 0 );
2010             n_where = n;
2011         }
2012         else
2013             add_kbnode( keyblock, n );
2014         n->flag |= 1;
2015         node->flag |= 1;
2016         if( n->pkt->pkttype == PKT_SIGNATURE )
2017             ++*n_sigs;
2018
2019         node = node->next;
2020         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2021             break;
2022     }
2023
2024     return 0;
2025 }
2026
2027
2028 /****************
2029  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2030  * (how should we handle comment packets here?)
2031  */
2032 static int
2033 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2034                                     const char *fname, u32 *keyid )
2035 {
2036     KBNODE n, n2;
2037     int found=0;
2038
2039     assert(dst->pkt->pkttype == PKT_USER_ID );
2040     assert(src->pkt->pkttype == PKT_USER_ID );
2041
2042     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2043         if( n->pkt->pkttype != PKT_SIGNATURE )
2044             continue;
2045         if( n->pkt->pkt.signature->sig_class == 0x18
2046             || n->pkt->pkt.signature->sig_class == 0x28 )
2047             continue; /* skip signatures which are only valid on subkeys */
2048         found = 0;
2049         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2050           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2051             {
2052               found++;
2053               break;
2054             }
2055         if( !found ) {
2056             /* This signature is new or newer, append N to DST.
2057              * We add a clone to the original keyblock, because this
2058              * one is released first */
2059             n2 = clone_kbnode(n);
2060             insert_kbnode( dst, n2, PKT_SIGNATURE );
2061             n2->flag |= 1;
2062             n->flag |= 1;
2063             ++*n_sigs;
2064         }
2065     }
2066
2067     return 0;
2068 }
2069
2070 /****************
2071  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2072  */
2073 static int
2074 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2075                                     const char *fname, u32 *keyid )
2076 {
2077     KBNODE n, n2;
2078     int found=0;
2079
2080     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2081            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2082
2083     for(n=src->next; n ; n = n->next ) {
2084         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2085             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2086             break;
2087         if( n->pkt->pkttype != PKT_SIGNATURE )
2088             continue;
2089         found = 0;
2090         for(n2=dst->next; n2; n2 = n2->next){
2091             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2092                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2093                 break;
2094             if( n2->pkt->pkttype == PKT_SIGNATURE
2095                 && n->pkt->pkt.signature->keyid[0]
2096                    == n2->pkt->pkt.signature->keyid[0]
2097                 && n->pkt->pkt.signature->keyid[1]
2098                    == n2->pkt->pkt.signature->keyid[1]
2099                 && n->pkt->pkt.signature->timestamp
2100                    <= n2->pkt->pkt.signature->timestamp
2101                 && n->pkt->pkt.signature->sig_class
2102                    == n2->pkt->pkt.signature->sig_class ) {
2103                 found++;
2104                 break;
2105             }
2106         }
2107         if( !found ) {
2108             /* This signature is new or newer, append N to DST.
2109              * We add a clone to the original keyblock, because this
2110              * one is released first */
2111             n2 = clone_kbnode(n);
2112             insert_kbnode( dst, n2, PKT_SIGNATURE );
2113             n2->flag |= 1;
2114             n->flag |= 1;
2115             ++*n_sigs;
2116         }
2117     }
2118
2119     return 0;
2120 }
2121
2122 /****************
2123  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2124  * Mark all new and copied packets by setting flag bit 0.
2125  */
2126 static int
2127 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2128                                           const char *fname, u32 *keyid )
2129 {
2130     KBNODE n;
2131
2132     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2133            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2134
2135     while(  node ) {
2136         /* we add a clone to the original keyblock, because this
2137          * one is released first */
2138         n = clone_kbnode(node);
2139         add_kbnode( keyblock, n );
2140         n->flag |= 1;
2141         node->flag |= 1;
2142         if( n->pkt->pkttype == PKT_SIGNATURE )
2143             ++*n_sigs;
2144
2145         node = node->next;
2146         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2147             break;
2148     }
2149
2150     return 0;
2151 }
2152
2153
2154
2155 /* Walk a public keyblock and produce a secret keyblock out of it.
2156    Instead of inserting the secret key parameters (which we don't
2157    have), we insert a stub.  */
2158 static KBNODE
2159 pub_to_sec_keyblock (KBNODE pub_keyblock)
2160 {
2161   KBNODE pubnode, secnode;
2162   KBNODE sec_keyblock = NULL;
2163   KBNODE walkctx = NULL;
2164
2165   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2166     {
2167       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2168           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2169         {
2170           /* Make a secret key.  We only need to convert enough to
2171              write the keyblock out. */
2172           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2173           PACKET *pkt = m_alloc_clear (sizeof *pkt);
2174           PKT_secret_key *sk = m_alloc_clear (sizeof *sk);
2175           int i, n;
2176           
2177           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2178             pkt->pkttype = PKT_SECRET_KEY;
2179           else
2180             pkt->pkttype = PKT_SECRET_SUBKEY;
2181           
2182           pkt->pkt.secret_key = sk;
2183
2184           copy_public_parts_to_secret_key ( pk, sk );
2185           sk->version     = pk->version;
2186           sk->timestamp   = pk->timestamp;
2187         
2188           n = pubkey_get_npkey (pk->pubkey_algo);
2189           if (!n)
2190             n = 1; /* Unknown number of parameters, however the data
2191                       is stored in the first mpi. */
2192           for (i=0; i < n; i++ )
2193             sk->skey[i] = mpi_copy (pk->pkey[i]);
2194   
2195           sk->is_protected = 1;
2196           sk->protect.s2k.mode = 1001;
2197   
2198           secnode = new_kbnode (pkt);
2199         }
2200       else
2201         {
2202           secnode = clone_kbnode (pubnode);
2203         }
2204       
2205       if(!sec_keyblock)
2206         sec_keyblock = secnode;
2207       else
2208         add_kbnode (sec_keyblock, secnode);
2209     }
2210
2211   return sec_keyblock;
2212 }
2213
2214
2215 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2216    stub keys with the serial number SNNUM of the card if one of the
2217    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2218    a duplicate (may happen in case of backed uped keys). 
2219    
2220    Returns: True if anything changed.
2221 */
2222 static int
2223 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2224                                    const unsigned char *fpr1,
2225                                    const unsigned char *fpr2,
2226                                    const unsigned char *fpr3,
2227                                    const char *serialnostr)
2228 {
2229   KBNODE node;
2230   KBNODE walkctx = NULL;
2231   PKT_secret_key *sk;
2232   byte array[MAX_FINGERPRINT_LEN];
2233   size_t n;
2234   int result = 0;
2235   const char *s;
2236
2237   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2238     {
2239       if (node->pkt->pkttype != PKT_SECRET_KEY
2240           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2241         continue;
2242       sk = node->pkt->pkt.secret_key;
2243       
2244       fingerprint_from_sk (sk, array, &n);
2245       if (n != 20)
2246         continue; /* Can't be a card key.  */
2247       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2248              || (fpr2 && !memcmp (array, fpr2, 20))
2249              || (fpr3 && !memcmp (array, fpr3, 20))) )
2250         continue;  /* No match.  */
2251
2252       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2253         {
2254           /* Standard case: migrate that stub to a key stub.  */
2255           sk->protect.s2k.mode = 1002;
2256           s = serialnostr;
2257           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2258                sk->protect.ivlen++, s += 2)
2259             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2260           result = 1;
2261         }
2262       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2263         {
2264           s = serialnostr;
2265           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2266                sk->protect.ivlen++, s += 2)
2267             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2268               {
2269                 log_info (_("NOTE: a key's S/N does not "
2270                             "match the card's one\n"));
2271                 break;
2272               }
2273         }
2274       else
2275         {
2276           if (node->pkt->pkttype != PKT_SECRET_KEY)
2277             log_info (_("NOTE: primary key is online and stored on card\n"));
2278           else
2279             log_info (_("NOTE: secondary key is online and stored on card\n"));
2280         }
2281     }
2282
2283   return result;
2284 }
2285
2286
2287
2288 /* Check whether a secret key stub exists for the public key PK.  If
2289    not create such a stub key and store it into the secring.  If it
2290    exists, add appropriate subkey stubs and update the secring.
2291    Return 0 if the key could be created. */
2292 int
2293 auto_create_card_key_stub ( const char *serialnostr, 
2294                             const unsigned char *fpr1,
2295                             const unsigned char *fpr2,
2296                             const unsigned char *fpr3)
2297 {
2298   KBNODE pub_keyblock;
2299   KBNODE sec_keyblock;
2300   KEYDB_HANDLE hd;
2301   int rc;
2302
2303   /* We only want to do this for an OpenPGP card.  */
2304   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2305       || strlen (serialnostr) != 32 )
2306     return G10ERR_GENERAL;
2307
2308   /* First get the public keyring from any of the provided fingerprints. */
2309   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2310        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2311        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2312     ;
2313   else
2314     return G10ERR_GENERAL;
2315  
2316   hd = keydb_new (1);
2317
2318   /* Now check whether there is a secret keyring.  */
2319   {
2320     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2321     byte afp[MAX_FINGERPRINT_LEN];
2322     size_t an;
2323
2324     fingerprint_from_pk (pk, afp, &an);
2325     memset (afp, 0, MAX_FINGERPRINT_LEN);
2326     rc = keydb_search_fpr (hd, afp);
2327   }
2328
2329   if (!rc)
2330     {
2331       rc = keydb_get_keyblock (hd, &sec_keyblock);
2332       if (rc)
2333         {
2334           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2335           rc = G10ERR_GENERAL;
2336         }
2337       else
2338         {
2339           merge_keys_and_selfsig (sec_keyblock);
2340           
2341           /* FIXME: We need to add new subkeys first.  */
2342           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2343                                                  fpr1, fpr2, fpr3,
2344                                                  serialnostr))
2345             {
2346               rc = keydb_update_keyblock (hd, sec_keyblock );
2347               if (rc)
2348                 log_error (_("error writing keyring `%s': %s\n"),
2349                            keydb_get_resource_name (hd), g10_errstr(rc) );
2350             }
2351         }
2352     }
2353   else  /* A secret key does not exists - create it.  */
2354     {
2355       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2356       update_sec_keyblock_with_cardinfo (sec_keyblock,
2357                                          fpr1, fpr2, fpr3,
2358                                          serialnostr);
2359
2360       rc = keydb_locate_writable (hd, NULL);
2361       if (rc)
2362         {
2363           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2364           rc = G10ERR_GENERAL;
2365         }
2366       else
2367         {
2368           rc = keydb_insert_keyblock (hd, sec_keyblock );
2369           if (rc)
2370             log_error (_("error writing keyring `%s': %s\n"),
2371                        keydb_get_resource_name (hd), g10_errstr(rc) );
2372         }
2373     }
2374     
2375   release_kbnode (sec_keyblock);
2376   release_kbnode (pub_keyblock);
2377   keydb_release (hd);
2378   return rc;
2379 }
2380