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