* keygen.c (generate_keypair): Create an AUTHKEYTYPE entry for cards.
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <ctype.h>
28
29 #include "gpg.h"
30 #include "util.h"
31 #include "packet.h"
32 #include "memory.h"
33 #include "iobuf.h"
34 #include "keydb.h"
35 #include "options.h"
36 #include "main.h"
37 #include "trustdb.h"
38 #include "i18n.h"
39
40 #define MAX_PK_CACHE_ENTRIES   200
41 #define MAX_UID_CACHE_ENTRIES  200
42
43 #if MAX_PK_CACHE_ENTRIES < 2
44 #error We need the cache for key creation
45 #endif
46
47
48 struct getkey_ctx_s {
49     int exact;
50     KBNODE keyblock;
51     KBPOS  kbpos;
52     KBNODE found_key; /* pointer into some keyblock */
53     int last_rc;
54     int req_usage;
55     int req_algo;
56     KEYDB_HANDLE kr_handle;
57     int not_allocated;
58     int nitems;
59     KEYDB_SEARCH_DESC items[1];
60 };
61
62 #if 0
63 static struct {
64     int any;
65     int okay_count;
66     int nokey_count;
67     int error_count;
68 } lkup_stats[21];
69 #endif
70
71 typedef struct keyid_list {
72     struct keyid_list *next;
73     u32 keyid[2];
74 } *keyid_list_t;
75
76
77 #if MAX_PK_CACHE_ENTRIES
78   typedef struct pk_cache_entry {
79       struct pk_cache_entry *next;
80       u32 keyid[2];
81       PKT_public_key *pk;
82   } *pk_cache_entry_t;
83   static pk_cache_entry_t pk_cache;
84   static int pk_cache_entries;   /* number of entries in pk cache */
85   static int pk_cache_disabled;
86 #endif
87
88 #if MAX_UID_CACHE_ENTRIES < 5
89 #error we really need the userid cache
90 #endif
91 typedef struct user_id_db {
92     struct user_id_db *next;
93     keyid_list_t keyids;
94     int len;
95     char name[1];
96 } *user_id_db_t;
97 static user_id_db_t user_id_db;
98 static int uid_cache_entries;   /* number of entries in uid cache */
99
100 static void merge_selfsigs( KBNODE keyblock );
101 static int lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode );
102
103 #if 0
104 static void
105 print_stats()
106 {
107     int i;
108     for(i=0; i < DIM(lkup_stats); i++ ) {
109         if( lkup_stats[i].any )
110             fprintf(stderr,
111                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
112                     i,
113                     lkup_stats[i].okay_count,
114                     lkup_stats[i].nokey_count,
115                     lkup_stats[i].error_count );
116     }
117 }
118 #endif
119
120
121 void
122 cache_public_key( PKT_public_key *pk )
123 {
124 #if MAX_PK_CACHE_ENTRIES
125     pk_cache_entry_t ce;
126     u32 keyid[2];
127
128     if( pk_cache_disabled )
129         return;
130
131     if( pk->dont_cache )
132         return;
133
134     if( is_ELGAMAL(pk->pubkey_algo)
135         || pk->pubkey_algo == PUBKEY_ALGO_DSA
136         || is_RSA(pk->pubkey_algo) ) {
137         keyid_from_pk( pk, keyid );
138     }
139     else
140         return; /* don't know how to get the keyid */
141
142     for( ce = pk_cache; ce; ce = ce->next )
143         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
144             if( DBG_CACHE )
145                 log_debug("cache_public_key: already in cache\n");
146             return;
147         }
148
149     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
150         /* fixme: use another algorithm to free some cache slots */
151         pk_cache_disabled=1;
152         if( opt.verbose > 1 )
153             log_info(_("too many entries in pk cache - disabled\n"));
154         return;
155     }
156     pk_cache_entries++;
157     ce = xmalloc ( sizeof *ce );
158     ce->next = pk_cache;
159     pk_cache = ce;
160     ce->pk = copy_public_key( NULL, pk );
161     ce->keyid[0] = keyid[0];
162     ce->keyid[1] = keyid[1];
163 #endif
164 }
165
166
167 /*
168  * Return the user ID from the given keyblock.
169  * We use the primary uid flag which has been set by the merge_selfsigs
170  * function.  The returned value is only valid as long as then given
171  * keyblock is not changed
172  */
173 static const char *
174 get_primary_uid ( KBNODE keyblock, size_t *uidlen )
175 {
176     KBNODE k;
177     const char *s;
178
179     for (k=keyblock; k; k=k->next ) {
180         if ( k->pkt->pkttype == PKT_USER_ID
181              && !k->pkt->pkt.user_id->attrib_data
182              && k->pkt->pkt.user_id->is_primary ) {
183             *uidlen = k->pkt->pkt.user_id->len;
184             return k->pkt->pkt.user_id->name;
185         }
186     } 
187     /* fixme: returning translatable constants instead of a user ID is 
188      * not good because they are probably not utf-8 encoded. */
189     s = _("[User id not found]");
190     *uidlen = strlen (s);
191     return s;
192 }
193
194
195 static void
196 release_keyid_list ( keyid_list_t k )
197 {
198     while (  k ) {
199         keyid_list_t k2 = k->next;
200         xfree (k);
201         k = k2;
202     }
203 }
204
205 /****************
206  * Store the association of keyid and userid
207  * Feed only public keys to this function.
208  */
209 static void
210 cache_user_id( KBNODE keyblock )
211 {
212     user_id_db_t r;
213     const char *uid;
214     size_t uidlen;
215     keyid_list_t keyids = NULL;
216     KBNODE k;
217
218     for (k=keyblock; k; k = k->next ) {
219         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
220              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
221             keyid_list_t a = xcalloc (1, sizeof *a );
222             /* Hmmm: For a long list of keyids it might be an advantage
223              * to append the keys */
224             keyid_from_pk( k->pkt->pkt.public_key, a->keyid );
225             /* first check for duplicates */
226             for(r=user_id_db; r; r = r->next ) {
227                 keyid_list_t b = r->keyids;
228                 for ( b = r->keyids; b; b = b->next ) {
229                     if( b->keyid[0] == a->keyid[0]
230                         && b->keyid[1] == a->keyid[1] ) {
231                         if( DBG_CACHE )
232                             log_debug("cache_user_id: already in cache\n");
233                         release_keyid_list ( keyids );
234                         xfree ( a );
235                         return;
236                     }
237                 }
238             }
239             /* now put it into the cache */
240             a->next = keyids;
241             keyids = a;
242         }
243     }
244     if ( !keyids )
245         BUG (); /* No key no fun */
246
247
248     uid = get_primary_uid ( keyblock, &uidlen );
249
250     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
251         /* fixme: use another algorithm to free some cache slots */
252         r = user_id_db;
253         user_id_db = r->next;
254         release_keyid_list ( r->keyids );
255         xfree (r);
256         uid_cache_entries--;
257     }
258     r = xmalloc ( sizeof *r + uidlen-1 );
259     r->keyids = keyids;
260     r->len = uidlen;
261     memcpy(r->name, uid, r->len);
262     r->next = user_id_db;
263     user_id_db = r;
264     uid_cache_entries++;
265 }
266
267
268 void
269 getkey_disable_caches()
270 {
271 #if MAX_PK_CACHE_ENTRIES
272     {
273         pk_cache_entry_t ce, ce2;
274
275         for( ce = pk_cache; ce; ce = ce2 ) {
276             ce2 = ce->next;
277             free_public_key( ce->pk );
278             xfree ( ce );
279         }
280         pk_cache_disabled=1;
281         pk_cache_entries = 0;
282         pk_cache = NULL;
283     }
284 #endif
285     /* fixme: disable user id cache ? */
286 }
287
288
289 static void
290 pk_from_block ( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE keyblock )
291 {
292     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
293
294     assert ( a->pkt->pkttype == PKT_PUBLIC_KEY
295              ||  a->pkt->pkttype == PKT_PUBLIC_SUBKEY );
296      
297     copy_public_key ( pk, a->pkt->pkt.public_key );
298 }
299
300 static void
301 sk_from_block ( GETKEY_CTX ctx,
302                 PKT_secret_key *sk, KBNODE keyblock )
303 {
304     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
305
306     assert ( a->pkt->pkttype == PKT_SECRET_KEY
307              ||  a->pkt->pkttype == PKT_SECRET_SUBKEY );
308      
309     copy_secret_key( sk, a->pkt->pkt.secret_key);
310 }
311
312
313 /****************
314  * Get a public key and store it into the allocated pk
315  * can be called with PK set to NULL to just read it into some
316  * internal structures.
317  */
318 int
319 get_pubkey( PKT_public_key *pk, u32 *keyid )
320 {
321     int internal = 0;
322     int rc = 0;
323
324 #if MAX_PK_CACHE_ENTRIES
325     {   /* Try to get it from the cache */
326         pk_cache_entry_t ce;
327         for( ce = pk_cache; ce; ce = ce->next ) {
328             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
329                 if( pk )
330                     copy_public_key( pk, ce->pk );
331                 return 0;
332             }
333         }
334     }
335 #endif
336     /* more init stuff */
337     if( !pk ) {
338         pk = xcalloc (1, sizeof *pk );
339         internal++;
340     }
341
342
343     /* do a lookup */
344     {   struct getkey_ctx_s ctx;
345         KBNODE kb = NULL;
346         memset( &ctx, 0, sizeof ctx );
347         ctx.exact = 1; /* use the key ID exactly as given */
348         ctx.not_allocated = 1;
349         ctx.kr_handle = keydb_new (0);
350         ctx.nitems = 1;
351         ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
352         ctx.items[0].u.kid[0] = keyid[0];
353         ctx.items[0].u.kid[1] = keyid[1];
354         ctx.req_algo  = pk->req_algo;
355         ctx.req_usage = pk->req_usage;
356         rc = lookup( &ctx, &kb, 0 );
357         if ( !rc ) {
358             pk_from_block ( &ctx, pk, kb );
359         }
360         get_pubkey_end( &ctx );
361         release_kbnode ( kb );
362     }
363     if( !rc )
364         goto leave;
365
366     rc = GPG_ERR_NO_PUBKEY;
367
368   leave:
369     if( !rc )
370         cache_public_key( pk );
371     if( internal )
372         free_public_key(pk);
373     return rc;
374 }
375
376
377 /* Get a public key and store it into the allocated pk.  This function
378    differs from get_pubkey() in that it does not do a check of the key
379    to avoid recursion.  It should be used only in very certain cases.  */
380 int
381 get_pubkey_fast (PKT_public_key *pk, u32 *keyid)
382 {
383   int rc = 0;
384   KEYDB_HANDLE hd;
385   KBNODE keyblock;
386   
387   assert (pk);
388 #if MAX_PK_CACHE_ENTRIES
389   { /* Try to get it from the cache */
390     pk_cache_entry_t ce;
391
392     for (ce = pk_cache; ce; ce = ce->next)
393       {
394         if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
395           {
396             if (pk)
397               copy_public_key (pk, ce->pk);
398             return 0;
399           }
400       }
401   }
402 #endif
403
404   hd = keydb_new (0);
405   rc = keydb_search_kid (hd, keyid);
406   if (rc == -1)
407     {
408       keydb_release (hd);
409       return GPG_ERR_NO_PUBKEY;
410     }
411   rc = keydb_get_keyblock (hd, &keyblock);
412   keydb_release (hd);
413   if (rc) 
414     {
415       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
416       return GPG_ERR_NO_PUBKEY;
417     }
418   
419   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
420            ||  keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY );
421   copy_public_key (pk, keyblock->pkt->pkt.public_key );
422   release_kbnode (keyblock);
423
424   /* Not caching key here since it won't have all of the fields
425      properly set. */
426
427   return 0;
428 }
429
430
431
432 KBNODE
433 get_pubkeyblock( u32 *keyid )
434 {
435     struct getkey_ctx_s ctx;
436     int rc = 0;
437     KBNODE keyblock = NULL;
438
439     memset( &ctx, 0, sizeof ctx );
440     /* no need to set exact here because we want the entire block */
441     ctx.not_allocated = 1;
442     ctx.kr_handle = keydb_new (0);
443     ctx.nitems = 1;
444     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
445     ctx.items[0].u.kid[0] = keyid[0];
446     ctx.items[0].u.kid[1] = keyid[1];
447     rc = lookup( &ctx, &keyblock, 0 );
448     get_pubkey_end( &ctx );
449
450     return rc ? NULL : keyblock;
451 }
452
453
454
455
456 /****************
457  * Get a secret key and store it into sk
458  */
459 int
460 get_seckey( PKT_secret_key *sk, u32 *keyid )
461 {
462     int rc;
463     struct getkey_ctx_s ctx;
464     KBNODE kb = NULL;
465
466     memset( &ctx, 0, sizeof ctx );
467     ctx.exact = 1; /* use the key ID exactly as given */
468     ctx.not_allocated = 1;
469     ctx.kr_handle = keydb_new (1);
470     ctx.nitems = 1;
471     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
472     ctx.items[0].u.kid[0] = keyid[0];
473     ctx.items[0].u.kid[1] = keyid[1];
474     ctx.req_algo  = sk->req_algo;
475     ctx.req_usage = sk->req_usage;
476     rc = lookup( &ctx, &kb, 1 );
477     if ( !rc ) {
478         sk_from_block ( &ctx, sk, kb );
479     }
480     get_seckey_end( &ctx );
481     release_kbnode ( kb );
482
483     if( !rc ) {
484         /* check the secret key (this may prompt for a passprase to
485          * unlock the secret key
486          */
487         rc = check_secret_key( sk, 0 );
488     }
489
490     return rc;
491 }
492
493
494 /****************
495  * Check whether the secret key is available.  This is just a fast
496  * check and does not tell us whether the secret key is valid.  It
497  * merely tells other whether there is some secret key.
498  * Returns: 0 := key is available
499  * GPG_ERR_NO_SECKEY := not availabe
500  */
501 int
502 seckey_available( u32 *keyid )
503 {
504     int rc;
505     KEYDB_HANDLE hd = keydb_new (1);
506
507     rc = keydb_search_kid (hd, keyid);
508     if ( rc == -1 )
509         rc = GPG_ERR_NO_SECKEY;
510     keydb_release (hd);
511     return rc;
512 }
513
514
515 /****************
516  * Return the type of the user id:
517  *
518  * Please use the constants KEYDB_SERCH_MODE_xxx
519  *  0 = Invalid user ID
520  *  1 = exact match
521  *  2 = match a substring
522  *  3 = match an email address
523  *  4 = match a substring of an email address
524  *  5 = match an email address, but compare from end
525  *  6 = word match mode
526  * 10 = it is a short KEYID (don't care about keyid[0])
527  * 11 = it is a long  KEYID
528  * 12 = it is a trustdb index (keyid is looked up)
529  * 16 = it is a 16 byte fingerprint
530  * 20 = it is a 20 byte fingerprint
531  * 21 = Unified fingerprint :fpr:pk_algo:
532  *      (We don't use pk_algo yet)
533  *
534  * Rules used:
535  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
536  *   must be in the range 0..9), this is considered a keyid; depending
537  *   on the length a short or complete one.
538  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
539  *   must be in the range 0..9), this is considered a fingerprint.
540  * - If the username starts with a left angle, we assume it is a complete
541  *   email address and look only at this part.
542  * - If the username starts with a colon we assume it is a unified 
543  *   key specfification. 
544  * - If the username starts with a '.', we assume it is the ending
545  *   part of an email address
546  * - If the username starts with an '@', we assume it is a part of an
547  *   email address
548  * - If the userid start with an '=' an exact compare is done.
549  * - If the userid starts with a '*' a case insensitive substring search is
550  *   done (This is the default).
551  * - If the userid starts with a '+' we will compare individual words
552  *   and a match requires that all the words are in the userid.
553  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
554  *   (note that you can't search for these characters). Compare
555  *   is not case sensitive.
556  */
557
558 int
559 classify_user_id( const char *name, KEYDB_SEARCH_DESC *desc )
560 {
561     const char *s;
562     int hexprefix = 0;
563     int hexlength;
564     int mode = 0;   
565     KEYDB_SEARCH_DESC dummy_desc;
566
567     if (!desc)
568         desc = &dummy_desc;
569
570     /* clear the structure so that the mode field is set to zero unless
571      * we set it to the correct value right at the end of this function */
572     memset (desc, 0, sizeof *desc);
573
574     /* skip leading spaces.  Fixme: what is with trailing spaces? */
575     for(s = name; *s && isspace(*s); s++ )
576         ;
577
578     switch (*s) {
579         case 0:    /* empty string is an error */
580             return 0;
581
582         case '.':  /* an email address, compare from end */
583             mode = KEYDB_SEARCH_MODE_MAILEND;
584             s++;
585             desc->u.name = s;
586             break;
587
588         case '<':  /* an email address */
589             mode = KEYDB_SEARCH_MODE_MAIL;
590             desc->u.name = s;
591             break;
592
593         case '@':  /* part of an email address */
594             mode = KEYDB_SEARCH_MODE_MAILSUB;
595             s++;
596             desc->u.name = s;
597             break;
598
599         case '=':  /* exact compare */
600             mode = KEYDB_SEARCH_MODE_EXACT;
601             s++;
602             desc->u.name = s;
603             break;
604
605         case '*':  /* case insensitive substring search */
606             mode = KEYDB_SEARCH_MODE_SUBSTR;
607             s++;
608             desc->u.name = s;
609             break;
610
611         case '+':  /* compare individual words */
612             mode = KEYDB_SEARCH_MODE_WORDS;
613             s++;
614             desc->u.name = s;
615             break;
616
617         case '#':  /* local user id */
618             return 0; /* This is now obsolete and van't not be used anymore*/
619         
620         case ':': /*Unified fingerprint */
621             {  
622                 const char *se, *si;
623                 int i;
624                 
625                 se = strchr( ++s,':');
626                 if ( !se )
627                     return 0;
628                 for (i=0,si=s; si < se; si++, i++ ) {
629                     if ( !strchr("01234567890abcdefABCDEF", *si ) )
630                         return 0; /* invalid digit */
631                 }
632                 if (i != 32 && i != 40)
633                     return 0; /* invalid length of fpr*/
634                 for (i=0,si=s; si < se; i++, si +=2) 
635                     desc->u.fpr[i] = hextobyte(si);
636                 for ( ; i < 20; i++)
637                     desc->u.fpr[i]= 0;
638                 s = se + 1;
639                 mode = KEYDB_SEARCH_MODE_FPR;
640             } 
641             break;
642            
643         default:
644             if (s[0] == '0' && s[1] == 'x') {
645                 hexprefix = 1;
646                 s += 2;
647             }
648
649             hexlength = strspn(s, "0123456789abcdefABCDEF");
650             if (hexlength >= 8 && s[hexlength] =='!') {
651                 desc->exact = 1;
652                 hexlength++; /* just for the following check */
653             }
654
655             /* check if a hexadecimal number is terminated by EOS or blank */
656             if (hexlength && s[hexlength] && !isspace(s[hexlength])) {
657                 if (hexprefix)      /* a "0x" prefix without correct */
658                     return 0;       /* termination is an error */
659                 else                /* The first chars looked like */
660                     hexlength = 0;  /* a hex number, but really were not. */
661             }
662
663             if (desc->exact)
664                 hexlength--;
665
666             if (hexlength == 8
667                 || (!hexprefix && hexlength == 9 && *s == '0')){
668                 /* short keyid */
669                 if (hexlength == 9)
670                     s++;
671                 desc->u.kid[0] = 0;
672                 desc->u.kid[1] = strtoul( s, NULL, 16 );
673                 mode = KEYDB_SEARCH_MODE_SHORT_KID;
674             }
675             else if (hexlength == 16
676                      || (!hexprefix && hexlength == 17 && *s == '0')) {
677                 /* complete keyid */
678                 char buf[9];
679                 if (hexlength == 17)
680                     s++;
681                 mem2str(buf, s, 9 );
682                 desc->u.kid[0] = strtoul( buf, NULL, 16 );
683                 desc->u.kid[1] = strtoul( s+8, NULL, 16 );
684                 mode = KEYDB_SEARCH_MODE_LONG_KID;
685             }
686             else if (hexlength == 32 || (!hexprefix && hexlength == 33
687                                                             && *s == '0')) {
688                 /* md5 fingerprint */
689                 int i;
690                 if (hexlength == 33)
691                     s++;
692                 memset(desc->u.fpr+16, 0, 4); 
693                 for (i=0; i < 16; i++, s+=2) {
694                     int c = hextobyte(s);
695                     if (c == -1)
696                         return 0;
697                     desc->u.fpr[i] = c;
698                 }
699                 mode = KEYDB_SEARCH_MODE_FPR16;
700             }
701             else if (hexlength == 40 || (!hexprefix && hexlength == 41
702                                                               && *s == '0')) {
703                 /* sha1/rmd160 fingerprint */
704                 int i;
705                 if (hexlength == 41)
706                     s++;
707                 for (i=0; i < 20; i++, s+=2) {
708                     int c = hextobyte(s);
709                     if (c == -1)
710                         return 0;
711                     desc->u.fpr[i] = c;
712                 }
713                 mode = KEYDB_SEARCH_MODE_FPR20;
714             }
715             else {
716                 if (hexprefix)  /* This was a hex number with a prefix */
717                     return 0;   /* and a wrong length */
718
719                 desc->exact = 0;
720                 desc->u.name = s;
721                 mode = KEYDB_SEARCH_MODE_SUBSTR;   /* default mode */
722             }
723     }
724
725     desc->mode = mode;
726     return mode;
727 }
728
729
730 static int
731 skip_disabled(void *dummy,u32 *keyid)
732 {
733   int rc,disabled=0;
734   PKT_public_key *pk=xcalloc (1,sizeof(PKT_public_key));
735
736   rc = get_pubkey(pk, keyid);
737   if(rc)
738     {
739       log_error("error checking disabled status of %08lX: %s\n",
740                 (ulong)keyid[1],gpg_strerror (rc));
741       goto leave;
742     }
743  
744   disabled=pk_is_disabled(pk);
745
746  leave:
747   free_public_key(pk);
748   return disabled;
749 }
750
751 /****************
752  * Try to get the pubkey by the userid. This function looks for the
753  * first pubkey certificate which has the given name in a user_id.
754  * if pk/sk has the pubkey algo set, the function will only return
755  * a pubkey with that algo.
756  * The caller should provide storage for either the pk or the sk.
757  * If ret_kb is not NULL the function will return the keyblock there.
758  */
759
760 static int
761 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
762             PKT_public_key *pk, PKT_secret_key *sk,
763             int secmode, int include_disabled,
764             KBNODE *ret_kb, KEYDB_HANDLE *ret_kdbhd )
765 {
766     int rc = 0;
767     int n;
768     STRLIST r;
769     GETKEY_CTX ctx;
770     KBNODE help_kb = NULL;
771     
772     if( retctx ) {/* reset the returned context in case of error */
773         assert (!ret_kdbhd);  /* not allowed because the handle is
774                                  stored in the context */
775         *retctx = NULL;
776     }
777     if (ret_kdbhd)
778         *ret_kdbhd = NULL;
779
780     /* build the search context */
781     for(n=0, r=namelist; r; r = r->next )
782         n++;
783     ctx = xcalloc (1,sizeof *ctx + (n-1)*sizeof ctx->items );
784     ctx->nitems = n;
785
786     for(n=0, r=namelist; r; r = r->next, n++ ) {
787         classify_user_id (r->d, &ctx->items[n]);
788         
789         if (ctx->items[n].exact)
790             ctx->exact = 1;
791         if (!ctx->items[n].mode) {
792             xfree (ctx);
793             return GPG_ERR_INV_USER_ID;
794         }
795         if(!include_disabled
796            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_SHORT_KID
797            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_LONG_KID
798            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR16
799            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR20
800            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR)
801           ctx->items[n].skipfnc=skip_disabled;
802     }
803
804     ctx->kr_handle = keydb_new (secmode);
805     if ( !ret_kb ) 
806         ret_kb = &help_kb;
807
808     if( secmode ) {
809         if (sk) {
810             ctx->req_algo  = sk->req_algo;
811             ctx->req_usage = sk->req_usage;
812         }
813         rc = lookup( ctx, ret_kb, 1 );
814         if ( !rc && sk ) {
815             sk_from_block ( ctx, sk, *ret_kb );
816         }
817     }
818     else {
819         if (pk) {
820             ctx->req_algo  = pk->req_algo;
821             ctx->req_usage = pk->req_usage;
822         }
823         rc = lookup( ctx, ret_kb, 0 );
824         if ( !rc && pk ) {
825             pk_from_block ( ctx, pk, *ret_kb );
826         }
827     }
828
829     release_kbnode ( help_kb );
830
831     if (retctx) /* caller wants the context */
832         *retctx = ctx;
833     else {
834         if (ret_kdbhd) {
835             *ret_kdbhd = ctx->kr_handle;
836             ctx->kr_handle = NULL;
837         }
838         get_pubkey_end (ctx);
839     }
840
841     return rc;
842 }
843
844 /*
845  * Find a public key from NAME and returh the keyblock or the key.
846  * If ret_kdb is not NULL, the KEYDB handle used to locate this keyblock is
847  * returned and the caller is responsible for closing it.
848  */
849 int
850 get_pubkey_byname (PKT_public_key *pk,
851                    const char *name, KBNODE *ret_keyblock,
852                    KEYDB_HANDLE *ret_kdbhd, int include_disabled ) 
853 {
854     int rc;
855     STRLIST namelist = NULL;
856
857     add_to_strlist( &namelist, name );
858     rc = key_byname( NULL, namelist, pk, NULL, 0,
859                      include_disabled, ret_keyblock, ret_kdbhd);
860     free_strlist( namelist );
861     return rc;
862 }
863
864 int
865 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
866                     STRLIST names, KBNODE *ret_keyblock )
867 {
868     return key_byname( retctx, names, pk, NULL, 0, 1, ret_keyblock, NULL);
869 }
870
871 int
872 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
873 {
874     int rc;
875
876     rc = lookup( ctx, ret_keyblock, 0 );
877     if ( !rc && pk && ret_keyblock )
878         pk_from_block ( ctx, pk, *ret_keyblock );
879     
880     return rc;
881 }
882
883
884 void
885 get_pubkey_end( GETKEY_CTX ctx )
886 {
887     if( ctx ) {
888         memset (&ctx->kbpos, 0, sizeof ctx->kbpos);
889         keydb_release (ctx->kr_handle);
890         if( !ctx->not_allocated )
891             xfree ( ctx );
892     }
893 }
894
895
896
897
898 /****************
899  * Search for a key with the given fingerprint.
900  * FIXME:
901  * We should replace this with the _byname function.  This can be done
902  * by creating a userID conforming to the unified fingerprint style. 
903  */
904 int
905 get_pubkey_byfprint( PKT_public_key *pk,
906                      const byte *fprint, size_t fprint_len)
907 {
908     int rc;
909
910     if( fprint_len == 20 || fprint_len == 16 ) {
911         struct getkey_ctx_s ctx;
912         KBNODE kb = NULL;
913
914         memset( &ctx, 0, sizeof ctx );
915         ctx.exact = 1 ;
916         ctx.not_allocated = 1;
917         ctx.kr_handle = keydb_new (0);
918         ctx.nitems = 1;
919         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
920                                           : KEYDB_SEARCH_MODE_FPR20;
921         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
922         rc = lookup( &ctx, &kb, 0 );
923         if (!rc && pk )
924             pk_from_block ( &ctx, pk, kb );
925         release_kbnode ( kb );
926         get_pubkey_end( &ctx );
927     }
928     else
929         rc = GPG_ERR_GENERAL; /* Oops */
930     return rc;
931 }
932
933
934 /* Get a public key and store it into the allocated pk.  This function
935    differs from get_pubkey_byfprint() in that it does not do a check
936    of the key to avoid recursion.  It should be used only in very
937    certain cases.  PK may be NULL to check just for the existance of
938    the key. */
939 int
940 get_pubkey_byfprint_fast (PKT_public_key *pk,
941                           const byte *fprint, size_t fprint_len)
942 {
943   int rc = 0;
944   KEYDB_HANDLE hd;
945   KBNODE keyblock;
946   byte fprbuf[MAX_FINGERPRINT_LEN];
947   int i;
948   
949   for (i=0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
950     fprbuf[i] = fprint[i];
951   while (i < MAX_FINGERPRINT_LEN) 
952     fprbuf[i++] = 0;
953
954   hd = keydb_new (0);
955   rc = keydb_search_fpr (hd, fprbuf);
956   if (rc == -1)
957     {
958       keydb_release (hd);
959       return GPG_ERR_NO_PUBKEY;
960     }
961   rc = keydb_get_keyblock (hd, &keyblock);
962   keydb_release (hd);
963   if (rc) 
964     {
965       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
966       return GPG_ERR_NO_PUBKEY;
967     }
968   
969   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
970            ||  keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY );
971   if (pk)
972     copy_public_key (pk, keyblock->pkt->pkt.public_key );
973   release_kbnode (keyblock);
974
975   /* Not caching key here since it won't have all of the fields
976      properly set. */
977
978   return 0;
979 }
980
981 /****************
982  * Search for a key with the given fingerprint and return the
983  * complete keyblock which may have more than only this key.
984  */
985 int
986 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
987                                                 size_t fprint_len )
988 {
989     int rc;
990
991     if( fprint_len == 20 || fprint_len == 16 ) {
992         struct getkey_ctx_s ctx;
993
994         memset( &ctx, 0, sizeof ctx );
995         ctx.not_allocated = 1;
996         ctx.kr_handle = keydb_new (0);
997         ctx.nitems = 1;
998         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
999                                           : KEYDB_SEARCH_MODE_FPR20;
1000         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1001         rc = lookup( &ctx, ret_keyblock, 0 );
1002         get_pubkey_end( &ctx );
1003     }
1004     else
1005         rc = GPG_ERR_GENERAL; /* Oops */
1006
1007     return rc;
1008 }
1009
1010
1011 /****************
1012  * Get a secret key by name and store it into sk
1013  * If NAME is NULL use the default key
1014  */
1015 static int
1016 get_seckey_byname2( GETKEY_CTX *retctx,
1017                    PKT_secret_key *sk, const char *name, int unprotect,
1018                    KBNODE *retblock )
1019 {
1020     STRLIST namelist = NULL;
1021     int rc;
1022
1023     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
1024         add_to_strlist( &namelist, opt.def_secret_key );
1025         rc = key_byname( retctx, namelist, NULL, sk, 1, 1, retblock, NULL );
1026     }
1027     else if( !name ) { /* use the first one as default key */
1028         struct getkey_ctx_s ctx;
1029         KBNODE kb = NULL;
1030
1031         assert (!retctx ); /* do we need this at all */
1032         assert (!retblock);
1033         memset( &ctx, 0, sizeof ctx );
1034         ctx.not_allocated = 1;
1035         ctx.kr_handle = keydb_new (1);
1036         ctx.nitems = 1;
1037         ctx.items[0].mode = KEYDB_SEARCH_MODE_FIRST;
1038         rc = lookup( &ctx, &kb, 1 );
1039         if (!rc && sk )
1040             sk_from_block ( &ctx, sk, kb );
1041         release_kbnode ( kb );
1042         get_seckey_end( &ctx );
1043     }
1044     else {
1045         add_to_strlist( &namelist, name );
1046         rc = key_byname( retctx, namelist, NULL, sk, 1, 1, retblock, NULL );
1047     }
1048
1049     free_strlist( namelist );
1050
1051     if( !rc && unprotect )
1052         rc = check_secret_key( sk, 0 );
1053
1054     return rc;
1055 }
1056
1057 int 
1058 get_seckey_byname( PKT_secret_key *sk, const char *name, int unlock )
1059 {
1060     return get_seckey_byname2 ( NULL, sk, name, unlock, NULL );
1061 }
1062
1063
1064 int
1065 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
1066                     STRLIST names, KBNODE *ret_keyblock )
1067 {
1068     return key_byname( retctx, names, NULL, sk, 1, 1, ret_keyblock, NULL );
1069 }
1070
1071
1072 int
1073 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1074 {
1075     int rc;
1076
1077     rc = lookup( ctx, ret_keyblock, 1 );
1078     if ( !rc && sk && ret_keyblock )
1079         sk_from_block ( ctx, sk, *ret_keyblock );
1080
1081     return rc;
1082 }
1083
1084
1085 void
1086 get_seckey_end( GETKEY_CTX ctx )
1087 {
1088     get_pubkey_end( ctx );
1089 }
1090
1091
1092 /****************
1093  * Search for a key with the given fingerprint.
1094  * FIXME:
1095  * We should replace this with the _byname function.  Thiscsan be done
1096  * by creating a userID conforming to the unified fingerprint style. 
1097  */
1098 int
1099 get_seckey_byfprint( PKT_secret_key *sk,
1100                      const byte *fprint, size_t fprint_len)
1101 {
1102     int rc;
1103
1104     if( fprint_len == 20 || fprint_len == 16 ) {
1105         struct getkey_ctx_s ctx;
1106         KBNODE kb = NULL;
1107
1108         memset( &ctx, 0, sizeof ctx );
1109         ctx.exact = 1 ;
1110         ctx.not_allocated = 1;
1111         ctx.kr_handle = keydb_new (1);
1112         ctx.nitems = 1;
1113         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
1114                                           : KEYDB_SEARCH_MODE_FPR20;
1115         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1116         rc = lookup( &ctx, &kb, 1 );
1117         if (!rc && sk )
1118             sk_from_block ( &ctx, sk, kb );
1119         release_kbnode ( kb );
1120         get_pubkey_end( &ctx );
1121     }
1122     else
1123         rc = GPG_ERR_GENERAL; /* Oops */
1124     return rc;
1125 }
1126
1127 \f
1128 /************************************************
1129  ************* Merging stuff ********************
1130  ************************************************/
1131
1132 /****************
1133  * merge all selfsignatures with the keys.
1134  * FIXME: replace this at least for the public key parts
1135  *        by merge_selfsigs.
1136  *        It is still used in keyedit.c and
1137  *        at 2 or 3 other places - check whether it is really needed.
1138  *        It might be needed by the key edit and import stuff because
1139  *        the keylock is changed.
1140  */
1141 void
1142 merge_keys_and_selfsig( KBNODE keyblock )
1143 {
1144     PKT_public_key *pk = NULL;
1145     PKT_secret_key *sk = NULL;
1146     PKT_signature *sig;
1147     KBNODE k;
1148     u32 kid[2] = { 0, 0 };
1149     u32 sigdate = 0;
1150
1151     if (keyblock && keyblock->pkt->pkttype == PKT_PUBLIC_KEY ) {
1152         /* divert to our new function */
1153         merge_selfsigs (keyblock);
1154         return;
1155     }
1156     /* still need the old one because the new one can't handle secret keys */
1157
1158     for(k=keyblock; k; k = k->next ) {
1159         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1160             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1161             pk = k->pkt->pkt.public_key; sk = NULL;
1162             if( pk->version < 4 )
1163                 pk = NULL; /* not needed for old keys */
1164             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1165                 keyid_from_pk( pk, kid );
1166             else if( !pk->expiredate ) { /* and subkey */
1167                 /* insert the expiration date here */
1168                 /*FIXME!!! pk->expiredate = subkeys_expiretime( k, kid );*/
1169             }
1170             sigdate = 0;
1171         }
1172         else if( k->pkt->pkttype == PKT_SECRET_KEY
1173             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1174             pk = NULL; sk = k->pkt->pkt.secret_key;
1175             if( sk->version < 4 )
1176                 sk = NULL;
1177             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1178                 keyid_from_sk( sk, kid );
1179             sigdate = 0;
1180         }
1181         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1182                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1183                  && sig->sig_class <= 0x30 && sig->version > 3
1184                  && !(sig->sig_class == 0x18 || sig->sig_class == 0x28)
1185                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1186             /* okay this is a self-signature which can be used.
1187              * This is not used for subkey binding signature, becuase this
1188              * is done above.
1189              * FIXME: We should only use this if the signature is valid
1190              *        but this is time consuming - we must provide another
1191              *        way to handle this
1192              */
1193             const byte *p;
1194             u32 ed;
1195
1196             p = parse_sig_subpkt( sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL );
1197             if( pk ) {
1198                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1199                 if( sig->timestamp > sigdate ) {
1200                     pk->expiredate = ed;
1201                     sigdate = sig->timestamp;
1202                 }
1203             }
1204             else {
1205                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1206                 if( sig->timestamp > sigdate ) {
1207                     sk->expiredate = ed;
1208                     sigdate = sig->timestamp;
1209                 }
1210             }
1211         }
1212
1213         if(pk && (pk->expiredate==0 ||
1214                   (pk->max_expiredate && pk->expiredate>pk->max_expiredate)))
1215           pk->expiredate=pk->max_expiredate;
1216
1217         if(sk && (sk->expiredate==0 ||
1218                   (sk->max_expiredate && sk->expiredate>sk->max_expiredate)))
1219           sk->expiredate=sk->max_expiredate;
1220     }
1221 }
1222
1223 /*
1224  * Apply information from SIGNODE (which is the valid self-signature
1225  * associated with that UID) to the UIDNODE:
1226  * - wether the UID has been revoked
1227  * - assumed creation date of the UID
1228  * - temporary store the keyflags here
1229  * - temporary store the key expiration time here
1230  * - mark whether the primary user ID flag hat been set.
1231  * - store the preferences
1232  */
1233 static void
1234 fixup_uidnode ( KBNODE uidnode, KBNODE signode, u32 keycreated )
1235 {
1236     PKT_user_id   *uid = uidnode->pkt->pkt.user_id;
1237     PKT_signature *sig = signode->pkt->pkt.signature;
1238     const byte *p, *sym, *hash, *zip;
1239     size_t n, nsym, nhash, nzip;
1240
1241     uid->created = 0; /* not created == invalid */
1242     if ( IS_UID_REV ( sig ) ) {
1243         uid->is_revoked = 1;
1244         return; /* has been revoked */
1245     }
1246
1247     uid->created = sig->timestamp; /* this one is okay */
1248     uid->selfsigversion = sig->version;
1249     /* If we got this far, it's not expired :) */
1250     uid->is_expired = 0;
1251     uid->expiredate = sig->expiredate;
1252
1253     /* store the key flags in the helper variable for later processing */
1254     uid->help_key_usage = 0;
1255     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1256     if ( p && n ) {
1257         /* first octet of the keyflags */   
1258         if ( (*p & 3) )
1259             uid->help_key_usage |= PUBKEY_USAGE_SIG;
1260         if ( (*p & 12) )    
1261             uid->help_key_usage |= PUBKEY_USAGE_ENC;
1262         /* Note: we do not set the CERT flag here because it can be assumed
1263          * that thre is no real policy to set it. */
1264     }
1265
1266     /* ditto or the key expiration */
1267     uid->help_key_expire = 0;
1268     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1269     if ( p ) { 
1270         uid->help_key_expire = keycreated + buffer_to_u32(p);
1271     }
1272
1273     /* Set the primary user ID flag - we will later wipe out some
1274      * of them to only have one in our keyblock */
1275     uid->is_primary = 0;
1276     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL );
1277     if ( p && *p )
1278         uid->is_primary = 2;
1279     /* We could also query this from the unhashed area if it is not in
1280      * the hased area and then later try to decide which is the better
1281      * there should be no security problem with this.
1282      * For now we only look at the hashed one. 
1283      */
1284
1285     /* Now build the preferences list.  These must come from the
1286        hashed section so nobody can modify the ciphers a key is
1287        willing to accept. */
1288     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_SYM, &n );
1289     sym = p; nsym = p?n:0;
1290     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_HASH, &n );
1291     hash = p; nhash = p?n:0;
1292     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_COMPR, &n );
1293     zip = p; nzip = p?n:0;
1294     if (uid->prefs) 
1295         xfree (uid->prefs);
1296     n = nsym + nhash + nzip;
1297     if (!n)
1298         uid->prefs = NULL;
1299     else {
1300         uid->prefs = xmalloc (sizeof (*uid->prefs) * (n+1));
1301         n = 0;
1302         for (; nsym; nsym--, n++) {
1303             uid->prefs[n].type = PREFTYPE_SYM;
1304             uid->prefs[n].value = *sym++;
1305         }
1306         for (; nhash; nhash--, n++) {
1307             uid->prefs[n].type = PREFTYPE_HASH;
1308             uid->prefs[n].value = *hash++;
1309         }
1310         for (; nzip; nzip--, n++) {
1311             uid->prefs[n].type = PREFTYPE_ZIP;
1312             uid->prefs[n].value = *zip++;
1313         }
1314         uid->prefs[n].type = PREFTYPE_NONE; /* end of list marker */
1315         uid->prefs[n].value = 0;
1316     }
1317
1318     /* see whether we have the MDC feature */
1319     uid->mdc_feature = 0;
1320     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
1321     if (p && n && (p[0] & 0x01))
1322         uid->mdc_feature = 1;
1323
1324     /* and the keyserver modify flag */
1325     uid->ks_modify = 1;
1326     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n);
1327     if (p && n && (p[0] & 0x80))
1328         uid->ks_modify = 0;
1329 }
1330
1331 static void
1332 merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
1333 {
1334     PKT_public_key *pk = NULL;
1335     KBNODE k;
1336     u32 kid[2];
1337     u32 sigdate, uiddate, uiddate2;
1338     KBNODE signode, uidnode, uidnode2;
1339     u32 curtime = make_timestamp ();
1340     unsigned int key_usage = 0;
1341     u32 keytimestamp = 0;
1342     u32 key_expire = 0;
1343     int key_expire_seen = 0;
1344     byte sigversion = 0;
1345
1346     *r_revoked = 0;
1347     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1348         BUG ();
1349     pk = keyblock->pkt->pkt.public_key;
1350     keytimestamp = pk->timestamp;
1351
1352     keyid_from_pk( pk, kid );
1353     pk->main_keyid[0] = kid[0];
1354     pk->main_keyid[1] = kid[1];
1355
1356     if ( pk->version < 4 ) {
1357         /* before v4 the key packet itself contains the expiration
1358          * date and there was no way to change it, so we start with
1359          * the one from the key packet */
1360         key_expire = pk->max_expiredate;
1361         key_expire_seen = 1;
1362     }
1363
1364     /* first pass: find the latest direct key self-signature.
1365      * We assume that the newest one overrides all others
1366      */
1367
1368     /* In case this key was already merged */
1369     xfree (pk->revkey);
1370     pk->revkey=NULL;
1371     pk->numrevkeys=0;
1372
1373     signode = NULL;
1374     sigdate = 0; /* helper to find the latest signature */
1375     for(k=keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next ) {
1376         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1377             PKT_signature *sig = k->pkt->pkt.signature;
1378             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1379                 if ( check_key_signature( keyblock, k, NULL ) )
1380                     ; /* signature did not verify */
1381                 else if ( IS_KEY_REV (sig) ){
1382                     /* key has been revoked - there is no way to override
1383                      * such a revocation, so we theoretically can stop now.
1384                      * We should not cope with expiration times for revocations
1385                      * here because we have to assume that an attacker can
1386                      * generate all kinds of signatures.  However due to the
1387                      * fact that the key has been revoked it does not harm
1388                      * either and by continuing we gather some more info on 
1389                      * that key.
1390                      */ 
1391                     *r_revoked = 1;
1392                 }
1393                 else if ( IS_KEY_SIG (sig) ) {
1394                   /* Add any revocation keys onto the pk.  This is
1395                      particularly interesting since we normally only
1396                      get data from the most recent 1F signature, but
1397                      you need multiple 1F sigs to properly handle
1398                      revocation keys (PGP does it this way, and a
1399                      revocation key could be sensitive and hence in a
1400                      different signature). */
1401                   if(sig->revkey) {
1402                     int i;
1403
1404                     pk->revkey=
1405                       xrealloc(pk->revkey,sizeof(struct revocation_key)*
1406                                 (pk->numrevkeys+sig->numrevkeys));
1407
1408                     for(i=0;i<sig->numrevkeys;i++)
1409                       memcpy(&pk->revkey[pk->numrevkeys++],
1410                              sig->revkey[i],
1411                              sizeof(struct revocation_key));
1412                   }
1413
1414                   if( sig->timestamp >= sigdate ) {
1415                     if(sig->flags.expired)
1416                         ; /* signature has expired - ignore it */
1417                     else {
1418                         sigdate = sig->timestamp;
1419                         signode = k;
1420                         if( sig->version > sigversion )
1421                           sigversion = sig->version;
1422
1423                     }
1424                   }
1425                 }
1426             }
1427         }
1428     }
1429
1430     /* Remove dupes from the revocation keys */
1431
1432     if(pk->revkey)
1433       {
1434         int i,j,x,changed=0;
1435
1436         for(i=0;i<pk->numrevkeys;i++)
1437           {
1438             for(j=i+1;j<pk->numrevkeys;j++)
1439               {
1440                 if(memcmp(&pk->revkey[i],&pk->revkey[j],
1441                           sizeof(struct revocation_key))==0)
1442                   {
1443                     /* remove j */
1444
1445                     for(x=j;x<pk->numrevkeys-1;x++)
1446                       pk->revkey[x]=pk->revkey[x+1];
1447
1448                     pk->numrevkeys--;
1449                     j--;
1450                     changed=1;
1451                   }
1452               }
1453           }
1454
1455         if(changed)
1456           pk->revkey=xrealloc(pk->revkey,
1457                                pk->numrevkeys*sizeof(struct revocation_key));
1458       }
1459
1460     if ( signode ) {
1461         /* some information from a direct key signature take precedence
1462          * over the same information given in UID sigs.
1463          */
1464         PKT_signature *sig = signode->pkt->pkt.signature;
1465         const byte *p;
1466         size_t n;
1467         
1468         p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1469         if ( p && n ) {
1470             /* first octet of the keyflags */   
1471             if ( (*p & 3) )
1472                 key_usage |= PUBKEY_USAGE_SIG;
1473             if ( (*p & 12) )    
1474                 key_usage |= PUBKEY_USAGE_ENC;
1475         }
1476
1477         p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1478         if ( p ) {
1479           key_expire = keytimestamp + buffer_to_u32(p);
1480           key_expire_seen = 1;
1481         }
1482
1483         /* mark that key as valid: one direct key signature should 
1484          * render a key as valid */
1485         pk->is_valid = 1;
1486     }
1487
1488     /* pass 1.5: look for key revocation signatures that were not made
1489        by the key (i.e. did a revocation key issue a revocation for
1490        us?).  Only bother to do this if there is a revocation key in
1491        the first place. */
1492
1493     if(pk->revkey)
1494       for(k=keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next )
1495         {
1496           if ( k->pkt->pkttype == PKT_SIGNATURE )
1497             {
1498               PKT_signature *sig = k->pkt->pkt.signature;
1499
1500               if(IS_KEY_REV(sig) &&
1501                  (sig->keyid[0]!=kid[0] || sig->keyid[1]!=kid[1]))
1502                 { 
1503                   /* Failure here means the sig did not verify, is was
1504                      not issued by a revocation key, or a revocation
1505                      key loop was broken. */
1506
1507                   if(check_revocation_keys(pk,sig)==0)
1508                     *r_revoked=1;
1509
1510                   /* In the future handle subkey and cert revocations?
1511                      PGP doesn't, but it's in 2440. */
1512                 }
1513             }
1514         }
1515
1516     /* second pass: look at the self-signature of all user IDs */
1517     signode = uidnode = NULL;
1518     sigdate = 0; /* helper to find the latest signature in one user ID */
1519     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1520         if ( k->pkt->pkttype == PKT_USER_ID ) {
1521             if ( uidnode && signode ) 
1522               {
1523                 fixup_uidnode ( uidnode, signode, keytimestamp );
1524                 pk->is_valid=1;
1525               }
1526             uidnode = k;
1527             signode = NULL;
1528             sigdate = 0;
1529         }
1530         else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode ) {
1531             PKT_signature *sig = k->pkt->pkt.signature;
1532             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1533                 if ( check_key_signature( keyblock, k, NULL ) )
1534                     ; /* signature did not verify */
1535                 else if ( (IS_UID_SIG (sig) || IS_UID_REV (sig))
1536                           && sig->timestamp >= sigdate ) {
1537                     /* Note: we allow to invalidate cert revocations
1538                      * by a newer signature.  An attacker can't use this
1539                      * because a key should be revoced with a key revocation.
1540                      * The reason why we have to allow for that is that at
1541                      * one time an email address may become invalid but later
1542                      * the same email address may become valid again (hired,
1543                      * fired, hired again).
1544                      */
1545                     if(sig->flags.expired) {
1546                       /* Expired uids don't get to be primary unless
1547                          they are the only uid there is. */
1548                       uidnode->pkt->pkt.user_id->is_primary=0;
1549                       uidnode->pkt->pkt.user_id->is_expired=1;
1550                       uidnode->pkt->pkt.user_id->expiredate=sig->expiredate;
1551                     }
1552                     else {
1553                         sigdate = sig->timestamp;
1554                         signode = k;
1555                         if( sig->version > sigversion )
1556                           sigversion = sig->version;
1557                     }
1558                 }
1559             }
1560         }
1561     }
1562     if ( uidnode && signode ) {
1563         fixup_uidnode ( uidnode, signode, keytimestamp );
1564         pk->is_valid = 1;
1565     }
1566
1567     /* If the key isn't valid yet, and we have
1568        --allow-non-selfsigned-uid set, then force it valid. */
1569     if(!pk->is_valid && opt.allow_non_selfsigned_uid)
1570       {
1571         if(opt.verbose)
1572           log_info(_("Invalid key %08lX made valid by "
1573                      "--allow-non-selfsigned-uid\n"),
1574                    (ulong)keyid_from_pk(pk,NULL));
1575
1576         pk->is_valid = 1;
1577       }
1578
1579     /* The key STILL isn't valid, so try and find an ultimately
1580        trusted signature. */
1581     if(!pk->is_valid)
1582       {
1583         uidnode=NULL;
1584
1585         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k=k->next)
1586           {
1587             if ( k->pkt->pkttype == PKT_USER_ID )
1588               uidnode = k;
1589             else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode )
1590               {
1591                 PKT_signature *sig = k->pkt->pkt.signature;
1592                 u32 dummy;
1593                 int dum2;
1594
1595                 if(sig->keyid[0] != kid[0] || sig->keyid[1]!=kid[1])
1596                   {
1597                     PKT_public_key *ultimate_pk;
1598
1599                     ultimate_pk=xcalloc (1,sizeof(*ultimate_pk));
1600
1601                     /* We don't want to use the full get_pubkey to
1602                        avoid infinite recursion in certain cases.
1603                        There is no reason to check that an ultimately
1604                        trusted key is still valid - if it has been
1605                        revoked or the user should also renmove the
1606                        ultimate trust flag.  */
1607                     if(get_pubkey_fast(ultimate_pk,sig->keyid)==0
1608                        && check_key_signature2(keyblock,k,ultimate_pk,
1609                                                NULL,&dummy,&dum2)==0
1610                        && get_ownertrust(ultimate_pk)==TRUST_ULTIMATE)
1611                       {
1612                         free_public_key(ultimate_pk);
1613                         pk->is_valid=1;
1614                         break;
1615                       }
1616
1617                     free_public_key(ultimate_pk);
1618                   }
1619               }
1620           }
1621       }
1622
1623     /* Record the highest selfsig version so we know if this is a v3
1624        key through and through, or a v3 key with a v4 selfsig
1625        somewhere.  This is useful in a few places to know if the key
1626        must be treated as PGP2-style or OpenPGP-style.  Note that a
1627        selfsig revocation with a higher version number will also raise
1628        this value.  This is okay since such a revocation must be
1629        issued by the user (i.e. it cannot be issued by someone else to
1630        modify the key behavior.) */
1631
1632     pk->selfsigversion=sigversion;
1633
1634     /* Now that we had a look at all user IDs we can now get some information
1635      * from those user IDs.
1636      */
1637     
1638     if ( !key_usage ) {
1639         /* find the latest user ID with key flags set */
1640         uiddate = 0; /* helper to find the latest user ID */
1641         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1642             k = k->next ) {
1643             if ( k->pkt->pkttype == PKT_USER_ID ) {
1644                 PKT_user_id *uid = k->pkt->pkt.user_id;
1645                 if ( uid->help_key_usage && uid->created > uiddate ) {
1646                     key_usage = uid->help_key_usage;
1647                     uiddate = uid->created;
1648                 }
1649             }
1650         }
1651     }
1652     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1653         key_usage = openpgp_pk_algo_usage ( pk->pubkey_algo );
1654     }
1655     else { /* check that the usage matches the usage as given by the algo */
1656         int x = openpgp_pk_algo_usage ( pk->pubkey_algo );
1657         if ( x ) /* mask it down to the actual allowed usage */
1658             key_usage &= x; 
1659     }
1660     pk->pubkey_usage = key_usage;
1661
1662     if ( !key_expire_seen ) {
1663         /* find the latest valid user ID with a key expiration set 
1664          * Note, that this may be a different one from the above because
1665          * some user IDs may have no expiration date set */
1666         uiddate = 0; 
1667         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1668             k = k->next ) {
1669             if ( k->pkt->pkttype == PKT_USER_ID ) {
1670                 PKT_user_id *uid = k->pkt->pkt.user_id;
1671                 if ( uid->help_key_expire && uid->created > uiddate ) {
1672                     key_expire = uid->help_key_expire;
1673                     uiddate = uid->created;
1674                 }
1675             }
1676         }
1677     }
1678
1679     /* Currently only v3 keys have a maximum expiration date, but I'll
1680        bet v5 keys get this feature again. */
1681     if(key_expire==0 || (pk->max_expiredate && key_expire>pk->max_expiredate))
1682       key_expire=pk->max_expiredate;
1683
1684     pk->has_expired = key_expire >= curtime? 0 : key_expire;
1685     pk->expiredate = key_expire;
1686
1687     /* Fixme: we should see how to get rid of the expiretime fields  but
1688      * this needs changes at other places too. */
1689
1690     /* and now find the real primary user ID and delete all others */
1691     uiddate = uiddate2 = 0;
1692     uidnode = uidnode2 = NULL;
1693     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1694         if ( k->pkt->pkttype == PKT_USER_ID &&
1695              !k->pkt->pkt.user_id->attrib_data) {
1696             PKT_user_id *uid = k->pkt->pkt.user_id;
1697             if (uid->is_primary)
1698               {
1699                 if(uid->created > uiddate)
1700                   {
1701                     uiddate = uid->created;
1702                     uidnode = k;
1703                   }
1704                 else if(uid->created==uiddate && uidnode)
1705                   {
1706                     /* The dates are equal, so we need to do a
1707                        different (and arbitrary) comparison.  This
1708                        should rarely, if ever, happen.  It's good to
1709                        try and guarantee that two different GnuPG
1710                        users with two different keyrings at least pick
1711                        the same primary. */
1712                     if(cmp_user_ids(uid,uidnode->pkt->pkt.user_id)>0)
1713                       uidnode=k;
1714                   }
1715               }
1716             else
1717               {
1718                 if(uid->created > uiddate2)
1719                   {
1720                     uiddate2 = uid->created;
1721                     uidnode2 = k;
1722                   }
1723                 else if(uid->created==uiddate2 && uidnode2)
1724                   {
1725                     if(cmp_user_ids(uid,uidnode2->pkt->pkt.user_id)>0)
1726                       uidnode2=k;
1727                   }
1728               }
1729         }
1730     }
1731     if ( uidnode ) {
1732         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1733             k = k->next ) {
1734             if ( k->pkt->pkttype == PKT_USER_ID &&
1735                  !k->pkt->pkt.user_id->attrib_data) {
1736                 PKT_user_id *uid = k->pkt->pkt.user_id;
1737                 if ( k != uidnode ) 
1738                     uid->is_primary = 0;
1739             }
1740         }
1741     }
1742     else if( uidnode2 ) {
1743         /* none is flagged primary - use the latest user ID we have,
1744            and disambiguate with the arbitrary packet comparison. */
1745         uidnode2->pkt->pkt.user_id->is_primary = 1;
1746     }
1747     else
1748       {
1749         /* None of our uids were self-signed, so pick the one that
1750            sorts first to be the primary.  This is the best we can do
1751            here since there are no self sigs to date the uids. */
1752
1753         uidnode = NULL;
1754
1755         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1756             k = k->next )
1757           {
1758             if(k->pkt->pkttype==PKT_USER_ID
1759                && !k->pkt->pkt.user_id->attrib_data)
1760               {
1761                 if(!uidnode)
1762                   {
1763                     uidnode=k;
1764                     uidnode->pkt->pkt.user_id->is_primary=1;
1765                     continue;
1766                   }
1767                 else
1768                   {
1769                     if(cmp_user_ids(k->pkt->pkt.user_id,
1770                                     uidnode->pkt->pkt.user_id)>0)
1771                       {
1772                         uidnode->pkt->pkt.user_id->is_primary=0;
1773                         uidnode=k;
1774                         uidnode->pkt->pkt.user_id->is_primary=1;
1775                       }
1776                     else
1777                       k->pkt->pkt.user_id->is_primary=0; /* just to be
1778                                                             safe */
1779                   }
1780               }
1781           }
1782       }
1783 }
1784
1785
1786 static void
1787 merge_selfsigs_subkey( KBNODE keyblock, KBNODE subnode )
1788 {
1789     PKT_public_key *mainpk = NULL, *subpk = NULL;
1790     PKT_signature *sig;
1791     KBNODE k;
1792     u32 mainkid[2];
1793     u32 sigdate = 0;
1794     KBNODE signode;
1795     u32 curtime = make_timestamp ();
1796     unsigned int key_usage = 0;
1797     u32 keytimestamp = 0;
1798     u32 key_expire = 0;
1799     const byte *p;
1800     size_t n;
1801
1802     if ( subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1803         BUG ();
1804     mainpk = keyblock->pkt->pkt.public_key;
1805     if ( mainpk->version < 4 )
1806         return; /* (actually this should never happen) */
1807     keyid_from_pk( mainpk, mainkid );
1808     subpk = subnode->pkt->pkt.public_key;
1809     keytimestamp = subpk->timestamp;
1810
1811     subpk->is_valid = 0;
1812     subpk->main_keyid[0] = mainpk->main_keyid[0];
1813     subpk->main_keyid[1] = mainpk->main_keyid[1];
1814
1815     /* find the latest key binding self-signature. */
1816     signode = NULL;
1817     sigdate = 0; /* helper to find the latest signature */
1818     for(k=subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1819                                                         k = k->next ) {
1820         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1821             sig = k->pkt->pkt.signature;
1822             if ( sig->keyid[0] == mainkid[0] && sig->keyid[1]==mainkid[1] ) { 
1823                 if ( check_key_signature( keyblock, k, NULL ) )
1824                     ; /* signature did not verify */
1825                 else if ( IS_SUBKEY_REV (sig) ) {
1826                   /* Note that this means that the date on a
1827                      revocation sig does not matter - even if the
1828                      binding sig is dated after the revocation sig,
1829                      the subkey is still marked as revoked.  This
1830                      seems ok, as it is just as easy to make new
1831                      subkeys rather than re-sign old ones as the
1832                      problem is in the distribution.  Plus, PGP (7)
1833                      does this the same way.  */
1834                     subpk->is_revoked = 1;
1835                     /* although we could stop now, we continue to 
1836                      * figure out other information like the old expiration
1837                      * time */
1838                 }
1839                 else if ( IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate ) {
1840                     if(sig->flags.expired)
1841                         ; /* signature has expired - ignore it */
1842                     else {
1843                         sigdate = sig->timestamp;
1844                         signode = k;
1845                     }
1846                 }
1847             }
1848         }
1849     }
1850
1851     if ( !signode ) {
1852         return;  /* no valid key binding */
1853     }
1854
1855     subpk->is_valid = 1;
1856     sig = signode->pkt->pkt.signature;
1857         
1858     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1859     if ( p && n ) {
1860         /* first octet of the keyflags */   
1861         if ( (*p & 3) )
1862             key_usage |= PUBKEY_USAGE_SIG;
1863         if ( (*p & 12) )    
1864             key_usage |= PUBKEY_USAGE_ENC;
1865     }
1866     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1867         key_usage = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1868     }
1869     else { /* check that the usage matches the usage as given by the algo */
1870         int x = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1871         if ( x ) /* mask it down to the actual allowed usage */
1872             key_usage &= x; 
1873     }
1874     subpk->pubkey_usage = key_usage;
1875     
1876     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1877     if ( p ) 
1878         key_expire = keytimestamp + buffer_to_u32(p);
1879     else
1880         key_expire = 0;
1881     subpk->has_expired = key_expire >= curtime? 0 : key_expire;
1882     subpk->expiredate = key_expire;
1883 }
1884
1885
1886
1887 /* 
1888  * Merge information from the self-signatures with the key, so that
1889  * we can later use them more easy.
1890  * The function works by first applying the self signatures to the
1891  * primary key and the to each subkey.
1892  * Here are the rules we use to decide which inormation from which
1893  * self-signature is used:
1894  * We check all self signatures or validity and ignore all invalid signatures.
1895  * All signatures are then ordered by their creation date ....
1896  * For the primary key:
1897  *   FIXME the docs    
1898  */
1899 static void
1900 merge_selfsigs( KBNODE keyblock )
1901 {
1902     KBNODE k;
1903     int revoked;
1904     PKT_public_key *main_pk;
1905     prefitem_t *prefs;
1906     int mdc_feature;
1907
1908     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY ) {
1909         if (keyblock->pkt->pkttype == PKT_SECRET_KEY ) {
1910             log_error ("expected public key but found secret key "
1911                        "- must stop\n");
1912             /* we better exit here becuase a public key is expected at
1913                other places too.  FIXME: Figure this out earlier and
1914                don't get to here at all */
1915             g10_exit (1);
1916         }
1917         BUG ();
1918     }
1919
1920     merge_selfsigs_main ( keyblock, &revoked );
1921
1922     /* now merge in the data from each of the subkeys */
1923     for(k=keyblock; k; k = k->next ) {
1924         if (  k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1925             merge_selfsigs_subkey ( keyblock, k );
1926         }
1927     }
1928
1929     main_pk = keyblock->pkt->pkt.public_key;
1930     if ( revoked || main_pk->has_expired || !main_pk->is_valid ) {
1931         /* if the primary key is revoked, expired, or invalid we
1932          * better set the appropriate flags on that key and all
1933          * subkeys */
1934         for(k=keyblock; k; k = k->next ) {
1935             if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1936                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1937                 PKT_public_key *pk = k->pkt->pkt.public_key;
1938                 if(!main_pk->is_valid)
1939                   pk->is_valid = 0;
1940                 if(revoked)
1941                   pk->is_revoked = 1;
1942                 if(main_pk->has_expired)
1943                   pk->has_expired = main_pk->has_expired;
1944             }
1945         }
1946         return;
1947     }
1948
1949     /* set the preference list of all keys to those of the primary real
1950      * user ID.  Note: we use these preferences when we don't know by
1951      * which user ID the key has been selected.
1952      * fixme: we should keep atoms of commonly used preferences or
1953      * use reference counting to optimize the preference lists storage.
1954      * FIXME: it might be better to use the intersection of 
1955      * all preferences.
1956      * Do a similar thing for the MDC feature flag.
1957      */
1958     prefs = NULL;
1959     mdc_feature = 0;
1960     for (k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next) {
1961         if (k->pkt->pkttype == PKT_USER_ID
1962             && !k->pkt->pkt.user_id->attrib_data
1963             && k->pkt->pkt.user_id->is_primary) {
1964             prefs = k->pkt->pkt.user_id->prefs;
1965             mdc_feature = k->pkt->pkt.user_id->mdc_feature;
1966             break;
1967         }
1968     }    
1969     for(k=keyblock; k; k = k->next ) {
1970         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1971              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1972             PKT_public_key *pk = k->pkt->pkt.public_key;
1973             if (pk->prefs)
1974                 xfree (pk->prefs);
1975             pk->prefs = copy_prefs (prefs);
1976             pk->mdc_feature = mdc_feature;
1977         }
1978     }
1979 }
1980
1981
1982 /*
1983  * Merge the secret keys from secblock into the pubblock thereby
1984  * replacing the public (sub)keys with their secret counterparts Hmmm:
1985  * It might be better to get away from the concept of entire secret
1986  * keys at all and have a way to store just the real secret parts
1987  * from the key.
1988  */
1989 static void
1990 merge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
1991 {
1992     KBNODE pub;
1993
1994     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
1995     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
1996     
1997     for (pub=pubblock; pub; pub = pub->next ) {
1998         if ( pub->pkt->pkttype == PKT_PUBLIC_KEY ) {
1999              PKT_public_key *pk = pub->pkt->pkt.public_key;
2000              PKT_secret_key *sk = secblock->pkt->pkt.secret_key;
2001              assert ( pub == pubblock ); /* only in the first node */
2002              /* there is nothing to compare in this case, so just replace
2003               * some information */
2004              copy_public_parts_to_secret_key ( pk, sk );
2005              free_public_key ( pk );
2006              pub->pkt->pkttype = PKT_SECRET_KEY;
2007              pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2008         }
2009         else if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2010             KBNODE sec;
2011             PKT_public_key *pk = pub->pkt->pkt.public_key;
2012
2013             /* this is more complicated: it may happen that the sequence
2014              * of the subkeys dosn't match, so we have to find the
2015              * appropriate secret key */
2016             for (sec=secblock->next; sec; sec = sec->next ) {
2017                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2018                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2019                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2020                         copy_public_parts_to_secret_key ( pk, sk );
2021                         free_public_key ( pk );
2022                         pub->pkt->pkttype = PKT_SECRET_SUBKEY;
2023                         pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2024                         break;
2025                     }
2026                 }
2027             }
2028             if ( !sec ) 
2029                 BUG(); /* already checked in premerge */
2030         }
2031     }
2032 }
2033
2034 /* This function checks that for every public subkey a corresponding
2035  * secret subkey is available and deletes the public subkey otherwise.
2036  * We need this function because we can't delete it later when we
2037  * actually merge the secret parts into the pubring.
2038  * The function also plays some games with the node flags.
2039  */
2040 static void
2041 premerge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
2042 {
2043     KBNODE last, pub;
2044
2045     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
2046     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2047     
2048     for (pub=pubblock,last=NULL; pub; last = pub, pub = pub->next ) {
2049         pub->flag &= ~3; /* reset bits 0 and 1 */
2050         if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2051             KBNODE sec;
2052             PKT_public_key *pk = pub->pkt->pkt.public_key;
2053
2054             for (sec=secblock->next; sec; sec = sec->next ) {
2055                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2056                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2057                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2058                         if ( sk->protect.s2k.mode == 1001 ) {
2059                             /* The secret parts are not available so
2060                                we can't use that key for signing etc.
2061                                Fix the pubkey usage */
2062                             pk->pubkey_usage &= ~PUBKEY_USAGE_SIG;
2063                         }
2064                         /* transfer flag bits 0 and 1 to the pubblock */
2065                         pub->flag |= (sec->flag &3);
2066                         break;
2067                     }
2068                 }
2069             }
2070             if ( !sec ) {
2071                 KBNODE next, ll;
2072
2073                 if (opt.verbose)
2074                   log_info ( _("no secret subkey "
2075                                "for public subkey %08lX - ignoring\n"),  
2076                            (ulong)keyid_from_pk (pk,NULL) );
2077                 /* we have to remove the subkey in this case */
2078                 assert ( last );
2079                 /* find the next subkey */
2080                 for (next=pub->next,ll=pub;
2081                      next && pub->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2082                      ll = next, next = next->next ) 
2083                     ;
2084                 /* make new link */
2085                 last->next = next;
2086                 /* release this public subkey with all sigs */
2087                 ll->next = NULL;
2088                 release_kbnode( pub );
2089                 /* let the loop continue */
2090                 pub = last;
2091             }
2092         }
2093     }
2094     /* We need to copy the found bits (0 and 1) from the secret key to
2095        the public key.  This has already been done for the subkeys but
2096        got lost on the primary key - fix it here *. */
2097     pubblock->flag |= (secblock->flag & 3);
2098 }
2099
2100
2101
2102 \f
2103 /* See see whether the key fits
2104  * our requirements and in case we do not
2105  * request the primary key, we should select
2106  * a suitable subkey.
2107  * FIXME: Check against PGP 7 whether we still need a kludge
2108  *        to favor type 16 keys over type 20 keys when type 20
2109  *        has not been explitely requested.
2110  * Returns: True when a suitable key has been found.
2111  *
2112  * We have to distinguish four cases:  FIXME!
2113  *  1. No usage and no primary key requested
2114  *     Examples for this case are that we have a keyID to be used
2115  *     for decrytion or verification.
2116  *  2. No usage but primary key requested
2117  *     This is the case for all functions which work on an
2118  *     entire keyblock, e.g. for editing or listing
2119  *  3. Usage and primary key requested
2120  *     FXME
2121  *  4. Usage but no primary key requested
2122  *     FIXME
2123  * FIXME: Tell what is going to happen here and something about the rationale
2124  * Note: We don't use this function if no specific usage is requested;
2125  *       This way the getkey functions can be used for plain key listings.
2126  *
2127  * CTX ist the keyblock we are investigating, if FOUNDK is not NULL this
2128  * is the key we actually found by looking at the keyid or a fingerprint and
2129  * may eitehr point to the primary or one of the subkeys.
2130  */
2131
2132 static int
2133 finish_lookup (GETKEY_CTX ctx)
2134 {
2135     KBNODE keyblock = ctx->keyblock;
2136     KBNODE k;
2137     KBNODE foundk = NULL;
2138     PKT_user_id *foundu = NULL;
2139 #define USAGE_MASK  (PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC)
2140     unsigned int req_usage = ( ctx->req_usage & USAGE_MASK );
2141     /* Request the primary if we're certifying another key, and also
2142        if signing data while --pgp6 or --pgp7 is on since pgp 6 and 7
2143        do not understand signatures made by a signing subkey.  PGP 8
2144        does. */
2145     int req_prim = (ctx->req_usage & PUBKEY_USAGE_CERT) ||
2146       ((PGP6 || PGP7) && (ctx->req_usage & PUBKEY_USAGE_SIG));
2147     u32 latest_date;
2148     KBNODE latest_key;
2149     u32 curtime = make_timestamp ();
2150
2151     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
2152    
2153     ctx->found_key = NULL;
2154
2155     if (ctx->exact) {
2156         for (k=keyblock; k; k = k->next) {
2157             if ( (k->flag & 1) ) {
2158                 assert ( k->pkt->pkttype == PKT_PUBLIC_KEY
2159                          || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
2160                 foundk = k;
2161                 break;
2162             }
2163         }
2164     }
2165
2166     for (k=keyblock; k; k = k->next) {
2167         if ( (k->flag & 2) ) {
2168             assert (k->pkt->pkttype == PKT_USER_ID);
2169             foundu = k->pkt->pkt.user_id;
2170             break;
2171         }
2172     }
2173
2174     if ( DBG_CACHE )
2175         log_debug( "finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
2176                    (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL),
2177                    foundk? "one":"all", req_usage);
2178
2179     if (!req_usage) {
2180         latest_key = foundk? foundk:keyblock;
2181         goto found;
2182     }
2183     
2184     if (!req_usage) {
2185         PKT_public_key *pk = foundk->pkt->pkt.public_key;
2186         if (pk->user_id)
2187             free_user_id (pk->user_id);
2188         pk->user_id = scopy_user_id (foundu);
2189         ctx->found_key = foundk;
2190         cache_user_id( keyblock );
2191         return 1; /* found */
2192     }
2193     
2194     latest_date = 0;
2195     latest_key  = NULL;
2196     /* do not look at subkeys if a certification key is requested */
2197     if ((!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) && !req_prim) {
2198         KBNODE nextk;
2199         /* either start a loop or check just this one subkey */
2200         for (k=foundk?foundk:keyblock; k; k = nextk ) {
2201             PKT_public_key *pk;
2202             nextk = k->next;
2203             if ( k->pkt->pkttype != PKT_PUBLIC_SUBKEY )
2204                 continue;
2205             if ( foundk )
2206                 nextk = NULL;  /* what a hack */
2207             pk = k->pkt->pkt.public_key;
2208             if (DBG_CACHE)
2209                 log_debug( "\tchecking subkey %08lX\n",
2210                            (ulong)keyid_from_pk( pk, NULL));
2211             if ( !pk->is_valid ) {
2212                 if (DBG_CACHE)
2213                     log_debug( "\tsubkey not valid\n");
2214                 continue;
2215             }
2216             if ( pk->is_revoked ) {
2217                 if (DBG_CACHE)
2218                     log_debug( "\tsubkey has been revoked\n");
2219                 continue;
2220             }
2221             if ( pk->has_expired ) {
2222                 if (DBG_CACHE)
2223                     log_debug( "\tsubkey has expired\n");
2224                 continue;
2225             }
2226             if ( pk->timestamp > curtime && !opt.ignore_valid_from ) {
2227                 if (DBG_CACHE)
2228                     log_debug( "\tsubkey not yet valid\n");
2229                 continue;
2230             }
2231             
2232             if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2233                 if (DBG_CACHE)
2234                     log_debug( "\tusage does not match: want=%x have=%x\n",
2235                                req_usage, pk->pubkey_usage );
2236                 continue;
2237             }
2238
2239             if (DBG_CACHE)
2240                 log_debug( "\tsubkey looks fine\n");
2241             if ( pk->timestamp > latest_date ) {
2242                 latest_date = pk->timestamp;
2243                 latest_key  = k;
2244             }
2245         }
2246     }
2247
2248     /* Okay now try the primary key unless we want an exact 
2249      * key ID match on a subkey */
2250     if ((!latest_key && !(ctx->exact && foundk != keyblock)) || req_prim) {
2251         PKT_public_key *pk;
2252         if (DBG_CACHE && !foundk && !req_prim )
2253             log_debug( "\tno suitable subkeys found - trying primary\n");
2254         pk = keyblock->pkt->pkt.public_key;
2255         if ( !pk->is_valid ) {
2256             if (DBG_CACHE)
2257                 log_debug( "\tprimary key not valid\n");
2258         }
2259         else if ( pk->is_revoked ) {
2260             if (DBG_CACHE)
2261                 log_debug( "\tprimary key has been revoked\n");
2262         }
2263         else if ( pk->has_expired ) {
2264             if (DBG_CACHE)
2265                 log_debug( "\tprimary key has expired\n");
2266         }
2267         else  if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2268             if (DBG_CACHE)
2269                 log_debug( "\tprimary key usage does not match: "
2270                            "want=%x have=%x\n",
2271                            req_usage, pk->pubkey_usage );
2272         }
2273         else { /* okay */
2274             if (DBG_CACHE)
2275                 log_debug( "\tprimary key may be used\n");
2276             latest_key = keyblock;
2277             latest_date = pk->timestamp;
2278         }
2279     }
2280     
2281     if ( !latest_key ) {
2282         if (DBG_CACHE)
2283             log_debug("\tno suitable key found -  giving up\n");
2284         return 0;
2285     }
2286
2287  found:
2288     if (DBG_CACHE)
2289         log_debug( "\tusing key %08lX\n",
2290                 (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL) );
2291
2292     if (latest_key) {
2293         PKT_public_key *pk = latest_key->pkt->pkt.public_key;
2294         if (pk->user_id)
2295             free_user_id (pk->user_id);
2296         pk->user_id = scopy_user_id (foundu);
2297     }    
2298         
2299     ctx->found_key = latest_key;
2300
2301     if (latest_key != keyblock && opt.verbose) {
2302         log_info(_("using secondary key %08lX "
2303                    "instead of primary key %08lX\n"),
2304                  (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL),
2305                  (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL) );
2306     }
2307
2308     cache_user_id( keyblock );
2309     
2310     return 1; /* found */
2311 }
2312
2313
2314 static int
2315 lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
2316 {
2317     int rc;
2318     KBNODE secblock = NULL; /* helper */
2319     int no_suitable_key = 0;
2320     
2321     rc = 0;
2322     while (!(rc = keydb_search (ctx->kr_handle, ctx->items, ctx->nitems))) {
2323         /* If we are searching for the first key we have to make sure
2324            that the next interation does not no an implicit reset.
2325            This can be triggered by an empty key ring. */
2326         if (ctx->nitems && ctx->items->mode == KEYDB_SEARCH_MODE_FIRST)
2327             ctx->items->mode = KEYDB_SEARCH_MODE_NEXT;
2328
2329         rc = keydb_get_keyblock (ctx->kr_handle, &ctx->keyblock);
2330         if (rc) {
2331             log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
2332             rc = 0;
2333             goto skip;
2334         }
2335                        
2336         if ( secmode ) {
2337             /* find the correspondig public key and use this 
2338              * this one for the selection process */
2339             u32 aki[2];
2340             KBNODE k = ctx->keyblock;
2341             
2342             if (k->pkt->pkttype != PKT_SECRET_KEY)
2343                 BUG();
2344
2345             keyid_from_sk (k->pkt->pkt.secret_key, aki);
2346             k = get_pubkeyblock (aki);
2347             if( !k ) {
2348                 if (!opt.quiet)
2349                     log_info(_("key %08lX: secret key without public key "
2350                                "- skipped\n"),  (ulong)aki[1] );
2351                 goto skip;
2352             }
2353             secblock = ctx->keyblock;
2354             ctx->keyblock = k;
2355
2356             premerge_public_with_secret ( ctx->keyblock, secblock );
2357         }
2358
2359         /* warning: node flag bits 0 and 1 should be preserved by
2360          * merge_selfsigs.  For secret keys, premerge did tranfer the
2361          * keys to the keyblock */
2362         merge_selfsigs ( ctx->keyblock );
2363         if ( finish_lookup (ctx) ) {
2364             no_suitable_key = 0;
2365             if ( secmode ) {
2366                 merge_public_with_secret ( ctx->keyblock,
2367                                            secblock);
2368                 release_kbnode (secblock);
2369                 secblock = NULL;
2370             }
2371             goto found;
2372         }
2373         else
2374             no_suitable_key = 1;
2375         
2376       skip:
2377         /* release resources and continue search */
2378         if ( secmode ) {
2379             release_kbnode( secblock );
2380             secblock = NULL;
2381         }
2382         release_kbnode( ctx->keyblock );
2383         ctx->keyblock = NULL;
2384     }
2385
2386   found:
2387     if( rc && rc != -1 )
2388         log_error("keydb_search failed: %s\n", gpg_strerror (rc));
2389
2390     if( !rc ) {
2391         *ret_keyblock = ctx->keyblock; /* return the keyblock */
2392         ctx->keyblock = NULL;
2393     }
2394     else if (rc == -1 && no_suitable_key)
2395          rc = secmode ? GPG_ERR_UNUSABLE_SECKEY : GPG_ERR_UNUSABLE_PUBKEY;
2396     else if( rc == -1 )
2397         rc = secmode ? GPG_ERR_NO_SECKEY : GPG_ERR_NO_PUBKEY;
2398
2399     if ( secmode ) {
2400         release_kbnode( secblock );
2401         secblock = NULL;
2402     }
2403     release_kbnode( ctx->keyblock );
2404     ctx->keyblock = NULL;
2405
2406     ctx->last_rc = rc;
2407     return rc;
2408 }
2409
2410
2411
2412
2413 /****************
2414  * FIXME: Replace by the generic function 
2415  *        It does not work as it is right now - it is used at 
2416  *        2 places:  a) to get the key for an anonyous recipient
2417  *                   b) to get the ultimately trusted keys.
2418  *        The a) usage might have some problems.
2419  *
2420  * set with_subkeys true to include subkeys
2421  * set with_spm true to include secret-parts-missing keys
2422  *
2423  * Enumerate all primary secret keys.  Caller must use these procedure:
2424  *  1) create a void pointer and initialize it to NULL
2425  *  2) pass this void pointer by reference to this function
2426  *     and provide space for the secret key (pass a buffer for sk)
2427  *  3) call this function as long as it does not return -1
2428  *     to indicate EOF.
2429  *  4) Always call this function a last time with SK set to NULL,
2430  *     so that can free it's context.
2431  */
2432 int
2433 enum_secret_keys( void **context, PKT_secret_key *sk,
2434                   int with_subkeys, int with_spm )
2435 {
2436     int rc=0;
2437     struct {
2438         int eof;
2439         int first;
2440         KEYDB_HANDLE hd;
2441         KBNODE keyblock;
2442         KBNODE node;
2443     } *c = *context;
2444
2445
2446     if( !c ) { /* make a new context */
2447         c = xcalloc (1, sizeof *c );
2448         *context = c;
2449         c->hd = keydb_new (1);
2450         c->first = 1;
2451         c->keyblock = NULL;
2452         c->node = NULL;
2453     }
2454
2455     if( !sk ) { /* free the context */
2456         keydb_release (c->hd);
2457         release_kbnode (c->keyblock);
2458         xfree ( c );
2459         *context = NULL;
2460         return 0;
2461     }
2462
2463     if( c->eof )
2464         return -1;
2465
2466     do {
2467         /* get the next secret key from the current keyblock */
2468         for (; c->node; c->node = c->node->next) {
2469             if ((c->node->pkt->pkttype == PKT_SECRET_KEY
2470                 || (with_subkeys
2471                     && c->node->pkt->pkttype == PKT_SECRET_SUBKEY) )
2472                 && !(c->node->pkt->pkt.secret_key->protect.s2k.mode==1001
2473                      && !with_spm)) {
2474                 copy_secret_key (sk, c->node->pkt->pkt.secret_key );
2475                 c->node = c->node->next;
2476                 return 0; /* found */
2477             }
2478         }
2479         release_kbnode (c->keyblock);
2480         c->keyblock = c->node = NULL;
2481         
2482         rc = c->first? keydb_search_first (c->hd) : keydb_search_next (c->hd);
2483         c->first = 0;
2484         if (rc) {
2485             keydb_release (c->hd); c->hd = NULL;
2486             c->eof = 1;
2487             return -1; /* eof */
2488         }
2489         
2490         rc = keydb_get_keyblock (c->hd, &c->keyblock);
2491         c->node = c->keyblock;
2492     } while (!rc);
2493
2494     return rc; /* error */
2495 }
2496
2497
2498 \f
2499 /*********************************************
2500  ***********  user ID printing helpers *******
2501  *********************************************/
2502
2503 /****************
2504  * Return a string with a printable representation of the user_id.
2505  * this string must be freed by m_free.
2506  */
2507 char*
2508 get_user_id_string( u32 *keyid )
2509 {
2510     user_id_db_t r;
2511     char *p;
2512     int pass=0;
2513     /* try it two times; second pass reads from key resources */
2514     do {
2515         for(r=user_id_db; r; r = r->next ) {
2516             keyid_list_t a;
2517             for (a=r->keyids; a; a= a->next ) {
2518                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2519                     p = xmalloc ( r->len + 10 );
2520                     sprintf(p, "%08lX %.*s",
2521                             (ulong)keyid[1], r->len, r->name );
2522                     return p;
2523                 }
2524             }
2525         }
2526     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2527     p = xmalloc ( 15 );
2528     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
2529     return p;
2530 }
2531
2532
2533 char*
2534 get_user_id_string_printable ( u32 *keyid )
2535 {
2536     char *p = get_user_id_string( keyid );
2537     char *p2 = utf8_to_native( p, strlen(p), 0 );
2538     xfree (p);
2539     p = make_printable_string (p2, strlen (p2), 0);
2540     xfree (p2);
2541     return p;
2542 }
2543
2544
2545 char*
2546 get_long_user_id_string( u32 *keyid )
2547 {
2548     user_id_db_t r;
2549     char *p;
2550     int pass=0;
2551     /* try it two times; second pass reads from key resources */
2552     do {
2553         for(r=user_id_db; r; r = r->next ) {
2554             keyid_list_t a;
2555             for (a=r->keyids; a; a= a->next ) {
2556                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2557                     p = xmalloc ( r->len + 20 );
2558                     sprintf(p, "%08lX%08lX %.*s",
2559                             (ulong)keyid[0], (ulong)keyid[1],
2560                             r->len, r->name );
2561                     return p;
2562                 }
2563             }
2564         }
2565     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2566     p = xmalloc ( 25 );
2567     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2568     return p;
2569 }
2570
2571 char*
2572 get_user_id( u32 *keyid, size_t *rn )
2573 {
2574     user_id_db_t r;
2575     char *p;
2576     int pass=0;
2577
2578     /* try it two times; second pass reads from key resources */
2579     do {
2580         for(r=user_id_db; r; r = r->next ) {
2581             keyid_list_t a;
2582             for (a=r->keyids; a; a= a->next ) {
2583                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2584                     p = xmalloc ( r->len );
2585                     memcpy(p, r->name, r->len );
2586                     *rn = r->len;
2587                     return p;
2588                 }
2589             }
2590         }
2591     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2592     p = xstrdup ( _("[User id not found]") );
2593     *rn = strlen(p);
2594     return p;
2595 }
2596
2597 char*
2598 get_user_id_printable( u32 *keyid )
2599 {
2600     size_t rn;
2601     char *p = get_user_id( keyid, &rn );
2602     char *p2 = utf8_to_native( p, rn, 0 );
2603     xfree (p);
2604     p = make_printable_string (p2, strlen (p2), 0);
2605     xfree (p2);
2606     return p;
2607 }
2608
2609 KEYDB_HANDLE
2610 get_ctx_handle(GETKEY_CTX ctx)
2611 {
2612   return ctx->kr_handle;
2613 }