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