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