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