backup
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.h>
27 #include "util.h"
28 #include "packet.h"
29 #include "memory.h"
30 #include "iobuf.h"
31 #include "keydb.h"
32 #include "options.h"
33 #include "main.h"
34 #include "i18n.h"
35
36 #define MAX_UNK_CACHE_ENTRIES 1000
37 #define MAX_PK_CACHE_ENTRIES    50
38 #define MAX_UID_CACHE_ENTRIES   50
39
40
41 typedef struct enum_seckey_context {
42     int eof;
43     STRLIST sl;
44     IOBUF iobuf;
45 } enum_seckey_context_t;
46
47
48 static STRLIST keyrings;
49 static STRLIST secret_keyrings;
50
51 #if MAX_UNK_CACHE_ENTRIES
52   typedef struct keyid_list {
53       struct keyid_list *next;
54       u32 keyid[2];
55   } *keyid_list_t;
56   static keyid_list_t unknown_keyids;
57   static int unk_cache_entries;   /* number of entries in unknown keys cache */
58   static int unk_cache_disabled;
59 #endif
60
61 #if MAX_PK_CACHE_ENTRIES
62   typedef struct pk_cache_entry {
63       struct pk_cache_entry *next;
64       u32 keyid[2];
65       PKT_public_key *pk;
66   } *pk_cache_entry_t;
67   static pk_cache_entry_t pk_cache;
68   static int pk_cache_entries;   /* number of entries in pk cache */
69   static int pk_cache_disabled;
70 #endif
71
72 #if MAX_UID_CACHE_ENTRIES < 5
73     #error we really need the userid cache
74 #endif
75 typedef struct user_id_db {
76     struct user_id_db *next;
77     u32 keyid[2];
78     int len;
79     char name[1];
80 } *user_id_db_t;
81 static user_id_db_t user_id_db;
82 static int uid_cache_entries;   /* number of entries in uid cache */
83
84
85
86 static int lookup( PKT_public_key *pk,
87                    int mode,  u32 *keyid, const char *name,
88                    KBNODE *ret_keyblock, int primary  );
89 static int lookup_sk( PKT_secret_key *sk,
90                    int mode,  u32 *keyid, const char *name, int primary );
91
92 /* note this function may be called before secure memory is
93  * available
94  * The first keyring which is added by this function is
95  * created if it does not exist.
96  */
97 void
98 add_keyring( const char *name )
99 {
100     STRLIST sl;
101     int rc, force = !keyrings;
102
103     if( *name != '/' ) { /* do tilde expansion etc */
104         char *p ;
105
106         if( strchr(name, '/') )
107             p = make_filename(name, NULL);
108         else
109             p = make_filename(opt.homedir, name, NULL);
110         sl = append_to_strlist( &keyrings, p );
111         m_free(p);
112     }
113     else
114         sl = append_to_strlist( &keyrings, name );
115
116     /* fixme: We should remove much out of this module and
117      * combine it with the keyblock stuff from ringedit.c
118      * For now we will simple add the filename as keyblock resource
119      */
120     rc = add_keyblock_resource( sl->d, force, 0 );
121     if( rc )
122         log_error("keyblock resource '%s': %s\n", sl->d, g10_errstr(rc) );
123 }
124
125
126 /****************
127  * Get the name of the keyrings, start with a sequence number of 0.
128  */
129 const char *
130 get_keyring( int sequence )
131 {
132     STRLIST sl;
133
134     for(sl = keyrings; sl && sequence; sl = sl->next, sequence-- )
135         ;
136     return sl? sl->d : NULL;
137 }
138
139 const char *
140 get_secret_keyring( int sequence )
141 {
142     STRLIST sl;
143
144     for(sl = secret_keyrings; sl && sequence; sl = sl->next, sequence-- )
145         ;
146     return sl? sl->d : NULL;
147 }
148
149
150 void
151 add_secret_keyring( const char *name )
152 {
153     STRLIST sl;
154     int rc, force = !secret_keyrings;
155
156     if( *name != '/' ) { /* do tilde expansion etc */
157         char *p ;
158
159         if( strchr(name, '/') )
160             p = make_filename(name, NULL);
161         else
162             p = make_filename(opt.homedir, name, NULL);
163         sl = append_to_strlist( &secret_keyrings, p );
164         m_free(p);
165     }
166     else
167         sl = append_to_strlist( &secret_keyrings, name );
168
169     /* fixme: We should remove much out of this module and
170      * combine it with the keyblock stuff from ringedit.c
171      * For now we will simple add the filename as keyblock resource
172      */
173     rc = add_keyblock_resource( sl->d, force, 1 );
174     if( rc )
175         log_error("secret keyblock resource '%s': %s\n", sl->d, g10_errstr(rc));
176 }
177
178
179 static void
180 cache_public_key( PKT_public_key *pk )
181 {
182   #if MAX_PK_CACHE_ENTRIES
183     pk_cache_entry_t ce;
184     u32 keyid[2];
185
186     if( pk_cache_disabled )
187         return;
188
189     if( is_ELGAMAL(pk->pubkey_algo)
190         || pk->pubkey_algo == PUBKEY_ALGO_DSA
191         || is_RSA(pk->pubkey_algo) ) {
192         keyid_from_pk( pk, keyid );
193     }
194     else
195         return; /* don't know how to get the keyid */
196
197     for( ce = pk_cache; ce; ce = ce->next )
198         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
199             if( DBG_CACHE )
200                 log_debug("cache_public_key: already in cache\n");
201             return;
202         }
203
204     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
205         /* fixme: use another algorithm to free some cache slots */
206         pk_cache_disabled=1;
207         log_info("too many entries in pk cache - disabled\n");
208         return;
209     }
210     pk_cache_entries++;
211     ce = m_alloc( sizeof *ce );
212     ce->next = pk_cache;
213     pk_cache = ce;
214     ce->pk = copy_public_key( NULL, pk );
215     ce->keyid[0] = keyid[0];
216     ce->keyid[1] = keyid[1];
217   #endif
218 }
219
220
221 /****************
222  * Store the association of keyid and userid
223  */
224 void
225 cache_user_id( PKT_user_id *uid, u32 *keyid )
226 {
227     user_id_db_t r;
228
229     for(r=user_id_db; r; r = r->next )
230         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
231             if( DBG_CACHE )
232                log_debug("cache_user_id: already in cache\n");
233             return;
234         }
235
236     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
237         /* fixme: use another algorithm to free some cache slots */
238         r = user_id_db;
239         user_id_db = r->next;
240         m_free(r);
241         uid_cache_entries--;
242     }
243     r = m_alloc( sizeof *r + uid->len-1 );
244     r->keyid[0] = keyid[0];
245     r->keyid[1] = keyid[1];
246     r->len = uid->len;
247     memcpy(r->name, uid->name, r->len);
248     r->next = user_id_db;
249     user_id_db = r;
250     uid_cache_entries++;
251 }
252
253
254
255 /****************
256  * Get a public key and store it into the allocated pk
257  * can be called with PK set to NULL to just read it into some
258  * internal structures.
259  */
260 int
261 get_pubkey( PKT_public_key *pk, u32 *keyid )
262 {
263     int internal = 0;
264     int rc = 0;
265
266   #if MAX_UNK_CACHE_ENTRIES
267     {   /* let's see whether we checked the keyid already */
268         keyid_list_t kl;
269         for( kl = unknown_keyids; kl; kl = kl->next )
270             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
271                 return G10ERR_NO_PUBKEY; /* already checked and not found */
272     }
273   #endif
274
275   #if MAX_PK_CACHE_ENTRIES
276     {   /* Try to get it from the cache */
277         pk_cache_entry_t ce;
278         for( ce = pk_cache; ce; ce = ce->next ) {
279             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
280                 if( pk )
281                     copy_public_key( pk, ce->pk );
282                 return 0;
283             }
284         }
285     }
286   #endif
287     /* more init stuff */
288     if( !pk ) {
289         pk = m_alloc_clear( sizeof *pk );
290         internal++;
291     }
292
293
294     /* do a lookup */
295     rc = lookup( pk, 11, keyid, NULL, NULL, 0 );
296     if( !rc )
297         goto leave;
298
299   #if MAX_UNK_CACHE_ENTRIES
300     /* not found: store it for future reference */
301     if( unk_cache_disabled )
302         ;
303     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
304         unk_cache_disabled = 1;
305         log_info("too many entries in unk cache - disabled\n");
306     }
307     else {
308         keyid_list_t kl;
309
310         kl = m_alloc( sizeof *kl );
311         kl->keyid[0] = keyid[0];
312         kl->keyid[1] = keyid[1];
313         kl->next = unknown_keyids;
314         unknown_keyids = kl;
315     }
316   #endif
317     rc = G10ERR_NO_PUBKEY;
318
319   leave:
320     if( !rc )
321         cache_public_key( pk );
322     if( internal )
323         m_free(pk);
324     return rc;
325 }
326
327
328 static int
329 hextobyte( const byte *s )
330 {
331     int c;
332
333     if( *s >= '0' && *s <= '9' )
334         c = 16 * (*s - '0');
335     else if( *s >= 'A' && *s <= 'F' )
336         c = 16 * (10 + *s - 'A');
337     else if( *s >= 'a' && *s <= 'f' )
338         c = 16 * (10 + *s - 'a');
339     else
340         return -1;
341     s++;
342     if( *s >= '0' && *s <= '9' )
343         c += *s - '0';
344     else if( *s >= 'A' && *s <= 'F' )
345         c += 10 + *s - 'A';
346     else if( *s >= 'a' && *s <= 'f' )
347         c += 10 + *s - 'a';
348     else
349         return -1;
350     return c;
351 }
352
353
354 /****************
355  * Try to get the pubkey by the userid. This function looks for the
356  * first pubkey certificate which has the given name in a user_id.
357  * if pk has the pubkey algo set, the function will only return
358  * a pubkey with that algo.
359  *
360  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
361  *   must be in the range 0..9), this is considered a keyid; depending
362  *   on the length a short or complete one.
363  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
364  *   must be in the range 0..9), this is considered a fingerprint.
365  * - If the username starts with a left angle, we assume it is a complete
366  *   email address and look only at this part.
367  * - If the username starts with a '.', we assume it is the ending
368  *   part of an email address
369  * - If the username starts with an '@', we assume it is a part of an
370  *   email address
371  * - If the userid start with an '=' an exact compare is done.
372  * - If the userid starts with a '*' a case insensitive substring search is
373  *   done (This is also the default).
374  */
375
376
377 static int
378 key_byname( int secret,
379             PKT_public_key *pk, PKT_secret_key *sk, const char *name )
380 {
381     int internal = 0;
382     int rc = 0;
383     const char *s;
384     u32 keyid[2] = {0}; /* init to avoid compiler warning */
385     byte fprint[20];
386     int mode = 0;
387
388     /* check what kind of name it is */
389     for(s = name; *s && isspace(*s); s++ )
390         ;
391     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
392         int i, j;
393         char buf[9];
394
395         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
396             s += 2; /*kludge to allow 0x034343434 */
397         for(i=0; isxdigit(s[i]); i++ )
398             ;
399         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
400             rc = G10ERR_INV_USER_ID;
401         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
402             if( i==9 )
403                 s++;
404             keyid[1] = strtoul( s, NULL, 16 );
405             mode = 10;
406         }
407         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
408             if( i==17 )
409                 s++;
410             mem2str(buf, s, 9 );
411             keyid[0] = strtoul( buf, NULL, 16 );
412             keyid[1] = strtoul( s+8, NULL, 16 );
413             mode = 11;
414         }
415         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
416             if( i==33 )
417                 s++;
418             memset(fprint+16, 4, 0);
419             for(j=0; !rc && j < 16; j++, s+=2 ) {
420                 int c = hextobyte( s );
421                 if( c == -1 )
422                     rc = G10ERR_INV_USER_ID;
423                 else
424                     fprint[j] = c;
425             }
426             mode = 16;
427         }
428         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
429             if( i==33 )
430                 s++;
431             for(j=0; !rc && j < 20; j++, s+=2 ) {
432                 int c = hextobyte( s );
433                 if( c == -1 )
434                     rc = G10ERR_INV_USER_ID;
435                 else
436                     fprint[j] = c;
437             }
438             mode = 20;
439         }
440         else
441             rc = G10ERR_INV_USER_ID;
442     }
443     else if( *s == '=' ) { /* exact search */
444         mode = 1;
445         s++;
446     }
447     else if( *s == '*' ) { /* substring search */
448         mode = 2;
449         s++;
450     }
451     else if( *s == '<' ) { /* an email address */
452         mode = 3;
453     }
454     else if( *s == '@' ) { /* a part of an email address */
455         mode = 4;
456         s++;
457     }
458     else if( *s == '.' ) { /* an email address, compare from end */
459         mode = 5;
460         s++;
461     }
462     else if( *s == '#' ) { /* use local id */
463         rc = G10ERR_INV_USER_ID; /* not yet implemented */
464     }
465     else if( !*s )  /* empty string */
466         rc = G10ERR_INV_USER_ID;
467     else
468         mode = 2;
469
470     if( rc )
471         goto leave;
472
473     if( secret ) {
474         if( !sk ) {
475             sk = m_alloc_clear( sizeof *sk );
476             internal++;
477         }
478         rc = mode < 16? lookup_sk( sk, mode, keyid, s, 1 )
479                       : lookup_sk( sk, mode, keyid, fprint, 1 );
480     }
481     else {
482         if( !pk ) {
483             pk = m_alloc_clear( sizeof *pk );
484             internal++;
485         }
486         rc = mode < 16? lookup( pk, mode, keyid, s, NULL, 1 )
487                       : lookup( pk, mode, keyid, fprint, NULL, 1 );
488     }
489
490
491   leave:
492     if( internal && secret )
493         m_free( sk );
494     else if( internal )
495         m_free( pk );
496     return rc;
497 }
498
499 int
500 get_pubkey_byname( PKT_public_key *pk, const char *name )
501 {
502     return key_byname( 0, pk, NULL, name );
503 }
504
505
506 /****************
507  * Search for a key with the given fingerprint.
508  */
509 int
510 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
511 {
512     int rc;
513
514     if( fprint_len == 20 || fprint_len == 16 )
515         rc = lookup( pk, fprint_len, NULL, fprint, NULL, 0 );
516     else
517         rc = G10ERR_GENERAL; /* Oops */
518     return rc;
519 }
520
521 /****************
522  * Search for a key with the given fingerprint and return the
523  * complete keyblock which may have more than only this key.
524  */
525 int
526 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
527                                                 size_t fprint_len )
528 {
529     int rc;
530     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
531
532     if( fprint_len == 20 || fprint_len == 16 )
533         rc = lookup( pk, fprint_len, NULL, fprint, ret_keyblock, 0 );
534     else
535         rc = G10ERR_GENERAL; /* Oops */
536
537     free_public_key( pk );
538     return rc;
539 }
540
541 /****************
542  * Get a secret key and store it into sk
543  */
544 int
545 get_seckey( PKT_secret_key *sk, u32 *keyid )
546 {
547     int rc;
548
549     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
550     if( !rc ) {
551         /* check the secret key (this may prompt for a passprase to
552          * unlock the secret key
553          */
554         rc = check_secret_key( sk, 0 );
555     }
556
557     return rc;
558 }
559
560 /****************
561  * Check whether the secret key is available
562  * Returns: 0 := key is available
563  *          G10ERR_NO_SECKEY := not availabe
564  */
565 int
566 seckey_available( u32 *keyid )
567 {
568     PKT_secret_key *sk;
569     int rc;
570
571     sk = m_alloc_clear( sizeof *sk );
572     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
573     free_secret_key( sk );
574     return rc;
575 }
576
577
578
579 /****************
580  * Get a secret key by name and store it into sk
581  * If NAME is NULL use the default key
582  */
583 int
584 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
585 {
586     int rc;
587
588     if( !name && opt.def_secret_key && *opt.def_secret_key )
589         rc = key_byname( 1, NULL, sk, opt.def_secret_key );
590     else if( !name ) /* use the first one as default key */
591         rc = lookup_sk( sk, 15, NULL, NULL, 1 );
592     else
593         rc = key_byname( 1, NULL, sk, name );
594     if( !rc && unprotect )
595         rc = check_secret_key( sk, 0 );
596
597     return rc;
598 }
599
600
601 static int
602 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
603 {
604     int i;
605     const char *s, *se;
606
607     if( mode == 1 ) {  /* exact match */
608         for(i=0; name[i] && uidlen; i++, uidlen-- )
609             if( uid[i] != name[i] )
610                 break;
611         if( !uidlen && !name[i] )
612             return 0; /* found */
613     }
614     else if( mode == 2 ) { /* case insensitive substring */
615         if( memistr( uid, uidlen, name ) )
616             return 0;
617     }
618     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
619         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
620             ;
621         if( i < uidlen )  {
622             /* skip opening delim and one char and look for the closing one*/
623             s++; i++;
624             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
625                 ;
626             if( i < uidlen ) {
627                 i = se - s;
628                 if( mode == 3 ) { /* exact email address */
629                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
630                         return 0;
631                 }
632                 else if( mode == 4 ) {  /* email substring */
633                     if( memistr( s, i, name ) )
634                         return 0;
635                 }
636                 else { /* email from end */
637                     /* nyi */
638                 }
639             }
640         }
641     }
642     else
643         BUG();
644
645     return -1; /* not found */
646 }
647
648
649
650 /****************
651  * Assume that knode points to a public key packet  and keyblock is
652  * the entire keyblock.  This function adds all relevant information from
653  * a selfsignature to the public key.
654  */
655
656 static void
657 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode )
658 {
659     PKT_public_key *pk = knode->pkt->pkt.public_key;
660     PKT_signature *sig;
661     KBNODE k;
662     u32 kid[2];
663
664     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
665             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
666
667     if( pk->version < 4 )
668         return; /* this is only needed for version >=4 packets */
669
670     /* find the selfsignature */
671     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
672         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
673         if( !k )
674            BUG(); /* keyblock without primary key!!! */
675         keyid_from_pk( knode->pkt->pkt.public_key, kid );
676     }
677     else
678         keyid_from_pk( pk, kid );
679     for(k=keyblock; k; k = k->next ) {
680         if( k->pkt->pkttype == PKT_SIGNATURE
681             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
682             && sig->sig_class <= 0x13
683             && sig->keyid[0] == kid[0]
684             && sig->keyid[1] == kid[1]
685             && sig->version > 3 ) {
686             /* okay this is (the first) self-signature which can be used
687              * FIXME: We should only use this if the signature is valid
688              *        but this is time consuming - we must provide another
689              *        way to handle this
690              */
691             const byte *p;
692             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
693             pk->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
694             /* fixme: add usage etc. to pk */
695             break;
696         }
697     }
698 }
699
700
701 /****************
702  * merge all selfsignatures with the keys.
703  */
704 void
705 merge_keys_and_selfsig( KBNODE keyblock )
706 {
707     PKT_public_key *pk = NULL;
708     PKT_secret_key *sk = NULL;
709     PKT_signature *sig;
710     KBNODE k;
711     u32 kid[2];
712
713     for(k=keyblock; k; k = k->next ) {
714         if( k->pkt->pkttype == PKT_PUBLIC_KEY
715             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
716             pk = k->pkt->pkt.public_key; sk = NULL;
717             if( pk->version < 4 )
718                 pk = NULL; /* not needed for old keys */
719             else
720                 keyid_from_pk( pk, kid );
721         }
722         else if( k->pkt->pkttype == PKT_SECRET_KEY
723             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
724             pk = NULL; sk = k->pkt->pkt.secret_key;
725             if( sk->version < 4 )
726                 sk = NULL;
727             else
728                 keyid_from_sk( sk, kid );
729         }
730         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
731                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
732                  && sig->sig_class <= 0x13 && sig->version > 3
733                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
734             /* okay this is (the first) self-signature which can be used
735              * FIXME: We should only use this if the signature is valid
736              *        but this is time consuming - we must provide another
737              *        way to handle this
738              */
739             const byte *p;
740             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
741             if( pk ) {
742                 pk->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
743                 /* fixme: add usage etc. */
744                 pk = NULL; /* use only the first self signature */
745             }
746             else {
747                 sk->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
748                 sk = NULL; /* use only the first self signature */
749             }
750         }
751     }
752 }
753
754
755
756
757
758 /****************
759  * Lookup a key by scanning all keyrings
760  *   mode 1 = lookup by NAME (exact)
761  *        2 = lookup by NAME (substring)
762  *        3 = lookup by NAME (email address)
763  *        4 = email address (substring)
764  *        5 = email address (compare from end)
765  *       10 = lookup by short KEYID (don't care about keyid[0])
766  *       11 = lookup by long  KEYID
767  *       15 = Get the first key.
768  *       16 = lookup by 16 byte fingerprint which is stored in NAME
769  *       20 = lookup by 20 byte fingerprint which is stored in NAME
770  * Caller must provide an empty PK, if the pubkey_algo is filled in, only
771  * a key of this algo will be returned.
772  * If ret_keyblock is not NULL, the complete keyblock is returned also
773  * and the caller must release it.
774  */
775 static int
776 lookup( PKT_public_key *pk, int mode,  u32 *keyid,
777         const char *name, KBNODE *ret_keyblock, int primary )
778 {
779     int rc;
780     KBNODE keyblock = NULL;
781     KBPOS kbpos;
782     int oldmode = set_packet_list_mode(0);
783     byte namehash[20];
784     int use_namehash=0;
785
786     rc = enum_keyblocks( 0, &kbpos, &keyblock );
787     if( rc ) {
788         if( rc == -1 )
789             rc = G10ERR_NO_PUBKEY;
790         else if( rc )
791             log_error("enum_keyblocks(open) failed: %s\n", g10_errstr(rc) );
792         goto leave;
793     }
794
795     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
796         KBNODE k, kk;
797         if( mode < 10 ) { /* name lookup */
798             for(k=keyblock; k; k = k->next ) {
799                 if( k->pkt->pkttype == PKT_USER_ID
800                     && !compare_name( k->pkt->pkt.user_id->name,
801                                       k->pkt->pkt.user_id->len, name, mode)) {
802                     /* we found a matching name, look for the key */
803                     for(kk=keyblock; kk; kk = kk->next ) {
804                         if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
805                               || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
806                             && ( !pk->pubkey_algo
807                                  || pk->pubkey_algo
808                                     == kk->pkt->pkt.public_key->pubkey_algo)
809                             && ( !pk->pubkey_usage
810                                  || !check_pubkey_algo2(
811                                        kk->pkt->pkt.public_key->pubkey_algo,
812                                                            pk->pubkey_usage ))
813                           )
814                             break;
815                     }
816                     if( kk ) {
817                         u32 aki[2];
818                         keyid_from_pk( kk->pkt->pkt.public_key, aki );
819                         cache_user_id( k->pkt->pkt.user_id, aki );
820                         rmd160_hash_buffer( namehash,
821                                             k->pkt->pkt.user_id->name,
822                                             k->pkt->pkt.user_id->len );
823                         use_namehash = 1;
824                         k = kk;
825                         break;
826                     }
827                     else
828                         log_error("No key for userid\n");
829                 }
830             }
831         }
832         else { /* keyid or fingerprint lookup */
833             if( DBG_CACHE && (mode== 10 || mode==11) ) {
834                 log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
835                                 (ulong)keyid[0], (ulong)keyid[1],
836                                  pk->pubkey_algo, mode );
837             }
838             for(k=keyblock; k; k = k->next ) {
839                 if(    k->pkt->pkttype == PKT_PUBLIC_KEY
840                     || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
841                     if( mode == 10 || mode == 11 ) {
842                         u32 aki[2];
843                         keyid_from_pk( k->pkt->pkt.public_key, aki );
844                         if( DBG_CACHE ) {
845                             log_debug("         aki=%08lx%08lx algo=%d\n",
846                                             (ulong)aki[0], (ulong)aki[1],
847                                     k->pkt->pkt.public_key->pubkey_algo    );
848                         }
849                         if( aki[1] == keyid[1]
850                             && ( mode == 10 || aki[0] == keyid[0] )
851                             && ( !pk->pubkey_algo
852                                  || pk->pubkey_algo
853                                     == k->pkt->pkt.public_key->pubkey_algo) ){
854                             /* cache the userid */
855                             for(kk=keyblock; kk; kk = kk->next )
856                                 if( kk->pkt->pkttype == PKT_USER_ID )
857                                     break;
858                             if( kk )
859                                 cache_user_id( kk->pkt->pkt.user_id, aki );
860                             else
861                                 log_error("No userid for key\n");
862                             break; /* found */
863                         }
864                     }
865                     else if( mode == 15 ) { /* get the first key */
866                         if( !pk->pubkey_algo
867                             || pk->pubkey_algo
868                                   == k->pkt->pkt.public_key->pubkey_algo )
869                             break;
870                     }
871                     else if( mode == 16 || mode == 20 ) {
872                         byte afp[MAX_FINGERPRINT_LEN];
873                         size_t an;
874
875                         fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
876
877                         if( DBG_CACHE ) {
878                             u32 aki[2];
879                             keyid_from_pk( k->pkt->pkt.public_key, aki );
880                             log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
881                                             (ulong)aki[0], (ulong)aki[1],
882                                     k->pkt->pkt.public_key->pubkey_algo,
883                                                         mode, an );
884                         }
885                         if( an == mode && !memcmp( afp, name, an)
886                             && ( !pk->pubkey_algo
887                                  || pk->pubkey_algo
888                                     == k->pkt->pkt.public_key->pubkey_algo) ) {
889                             break;
890                         }
891                     }
892                     else
893                         BUG();
894                 } /* end compare public keys */
895             }
896         }
897         if( k ) { /* found */
898             assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
899                     || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
900             assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
901             if( primary && !pk->pubkey_usage ) {
902                 copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
903                                               use_namehash? namehash:NULL);
904                 merge_one_pk_and_selfsig( keyblock, keyblock );
905             }
906             else {
907                 if( primary && pk->pubkey_usage
908                     && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
909                                pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
910                     /* if the usage is not correct, try to use a subkey */
911                     KBNODE save_k = k;
912
913                     for( ; k; k = k->next ) {
914                         if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
915                             && !check_pubkey_algo2(
916                                     k->pkt->pkt.public_key->pubkey_algo,
917                                                      pk->pubkey_usage ) )
918                             break;
919                     }
920                     if( !k )
921                         k = save_k;
922                     else
923                         log_info(_("using secondary key %08lX "
924                                    "instead of primary key %08lX\n"),
925                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
926                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
927                                 );
928                 }
929
930                 copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
931                                               use_namehash? namehash:NULL);
932                 merge_one_pk_and_selfsig( keyblock, k );
933             }
934             if( ret_keyblock ) {
935                 *ret_keyblock = keyblock;
936                 keyblock = NULL;
937             }
938             break; /* enumeration */
939         }
940         release_kbnode( keyblock );
941         keyblock = NULL;
942     }
943     if( rc == -1 )
944         rc = G10ERR_NO_PUBKEY;
945     else if( rc )
946         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
947
948   leave:
949     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
950     release_kbnode( keyblock );
951     set_packet_list_mode(oldmode);
952     return rc;
953 }
954
955 /****************
956  * Ditto for secret keys
957  */
958 static int
959 lookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
960            int primary )
961 {
962     int rc;
963     KBNODE keyblock = NULL;
964     KBPOS kbpos;
965     int oldmode = set_packet_list_mode(0);
966
967     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
968     if( rc ) {
969         if( rc == -1 )
970             rc = G10ERR_NO_SECKEY;
971         else if( rc )
972             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
973         goto leave;
974     }
975
976     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
977         KBNODE k, kk;
978         if( mode < 10 ) { /* name lookup */
979             for(k=keyblock; k; k = k->next ) {
980                 if( k->pkt->pkttype == PKT_USER_ID
981                     && !compare_name( k->pkt->pkt.user_id->name,
982                                       k->pkt->pkt.user_id->len, name, mode)) {
983                     /* we found a matching name, look for the key */
984                     for(kk=keyblock; kk; kk = kk->next ) {
985                         if( (    kk->pkt->pkttype == PKT_SECRET_KEY
986                               || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
987                             && ( !sk->pubkey_algo
988                                  || sk->pubkey_algo
989                                     == kk->pkt->pkt.secret_key->pubkey_algo)
990                             && ( !sk->pubkey_usage
991                                  || !check_pubkey_algo2(
992                                        kk->pkt->pkt.secret_key->pubkey_algo,
993                                                            sk->pubkey_usage ))
994                           )
995                             break;
996                     }
997                     if( kk ) {
998                         u32 aki[2];
999                         keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1000                         cache_user_id( k->pkt->pkt.user_id, aki );
1001                         k = kk;
1002                         break;
1003                     }
1004                     else
1005                         log_error("No key for userid (in sk)\n");
1006                 }
1007             }
1008         }
1009         else { /* keyid or fingerprint lookup */
1010             if( DBG_CACHE && (mode== 10 || mode==11) ) {
1011                 log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1012                                 (ulong)keyid[0], (ulong)keyid[1],
1013                                  sk->pubkey_algo, mode );
1014             }
1015             for(k=keyblock; k; k = k->next ) {
1016                 if(    k->pkt->pkttype == PKT_SECRET_KEY
1017                     || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1018                     if( mode == 10 || mode == 11 ) {
1019                         u32 aki[2];
1020                         keyid_from_sk( k->pkt->pkt.secret_key, aki );
1021                         if( DBG_CACHE ) {
1022                             log_debug("             aki=%08lx%08lx algo=%d\n",
1023                                             (ulong)aki[0], (ulong)aki[1],
1024                                     k->pkt->pkt.secret_key->pubkey_algo    );
1025                         }
1026                         if( aki[1] == keyid[1]
1027                             && ( mode == 10 || aki[0] == keyid[0] )
1028                             && ( !sk->pubkey_algo
1029                                  || sk->pubkey_algo
1030                                     == k->pkt->pkt.secret_key->pubkey_algo) ){
1031                             /* cache the userid */
1032                             for(kk=keyblock; kk; kk = kk->next )
1033                                 if( kk->pkt->pkttype == PKT_USER_ID )
1034                                     break;
1035                             if( kk )
1036                                 cache_user_id( kk->pkt->pkt.user_id, aki );
1037                             else
1038                                 log_error("No userid for key\n");
1039                             break; /* found */
1040                         }
1041                     }
1042                     else if( mode == 15 ) { /* get the first key */
1043                         if( !sk->pubkey_algo
1044                             || sk->pubkey_algo
1045                                   == k->pkt->pkt.secret_key->pubkey_algo )
1046                             break;
1047                     }
1048                     else if( mode == 16 || mode == 20 ) {
1049                         size_t an;
1050                         byte afp[MAX_FINGERPRINT_LEN];
1051
1052                         fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1053                         if( an == mode && !memcmp( afp, name, an)
1054                             && ( !sk->pubkey_algo
1055                                  || sk->pubkey_algo
1056                                     == k->pkt->pkt.secret_key->pubkey_algo) ) {
1057                             break;
1058                         }
1059                     }
1060                     else
1061                         BUG();
1062                 } /* end compare secret keys */
1063             }
1064         }
1065         if( k ) { /* found */
1066             assert(    k->pkt->pkttype == PKT_SECRET_KEY
1067                     || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1068             assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1069             if( primary && !sk->pubkey_usage )
1070                 copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1071             else
1072                 copy_secret_key( sk, k->pkt->pkt.secret_key );
1073             break; /* enumeration */
1074         }
1075         release_kbnode( keyblock );
1076         keyblock = NULL;
1077     }
1078     if( rc == -1 )
1079         rc = G10ERR_NO_SECKEY;
1080     else if( rc )
1081         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1082
1083   leave:
1084     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1085     release_kbnode( keyblock );
1086     set_packet_list_mode(oldmode);
1087     return rc;
1088 }
1089
1090
1091
1092 /****************
1093  * Enumerate all primary secret keys.  Caller must use these procedure:
1094  *  1) create a void pointer and initialize it to NULL
1095  *  2) pass this void pointer by reference to this function
1096  *     and provide space for the secret key (pass a buffer for sk)
1097  *  3) call this function as long as it does not return -1
1098  *     to indicate EOF.
1099  *  4) Always call this function a last time with SK set to NULL,
1100  *     so that can free it's context.
1101  *
1102  *
1103  */
1104 int
1105 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1106 {
1107     int rc=0;
1108     PACKET pkt;
1109     int save_mode;
1110     enum_seckey_context_t *c = *context;
1111
1112     if( !c ) { /* make a new context */
1113         c = m_alloc_clear( sizeof *c );
1114         *context = c;
1115         c->sl = secret_keyrings;
1116     }
1117
1118     if( !sk ) { /* free the context */
1119         if( c->iobuf )
1120             iobuf_close(c->iobuf);
1121         m_free( c );
1122         *context = NULL;
1123         return 0;
1124     }
1125
1126     if( c->eof )
1127         return -1;
1128
1129     for( ; c->sl; c->sl = c->sl->next ) {
1130         if( !c->iobuf ) {
1131             if( !(c->iobuf = iobuf_open( c->sl->d ) ) ) {
1132                 log_error("enum_secret_keys: can't open '%s'\n", c->sl->d );
1133                 continue; /* try next file */
1134             }
1135         }
1136
1137         save_mode = set_packet_list_mode(0);
1138         init_packet(&pkt);
1139         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1140             if( rc )
1141                 ; /* e.g. unknown packet */
1142             else if( pkt.pkttype == PKT_SECRET_KEY
1143                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1144                 copy_secret_key( sk, pkt.pkt.secret_key );
1145                 set_packet_list_mode(save_mode);
1146                 return 0; /* found */
1147             }
1148             free_packet(&pkt);
1149         }
1150         set_packet_list_mode(save_mode);
1151         iobuf_close(c->iobuf); c->iobuf = NULL;
1152     }
1153     c->eof = 1;
1154     return -1;
1155 }
1156
1157
1158 /****************
1159  * Return a string with a printable representation of the user_id.
1160  * this string must be freed by m_free.
1161  */
1162 char*
1163 get_user_id_string( u32 *keyid )
1164 {
1165     user_id_db_t r;
1166     char *p;
1167     int pass=0;
1168     /* try it two times; second pass reads from keyrings */
1169     do {
1170         for(r=user_id_db; r; r = r->next )
1171             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1172                 p = m_alloc( r->len + 10 );
1173                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1174                 return p;
1175             }
1176     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1177     p = m_alloc( 15 );
1178     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1179     return p;
1180 }
1181
1182 char*
1183 get_user_id( u32 *keyid, size_t *rn )
1184 {
1185     user_id_db_t r;
1186     char *p;
1187     int pass=0;
1188     /* try it two times; second pass reads from keyrings */
1189     do {
1190         for(r=user_id_db; r; r = r->next )
1191             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1192                 p = m_alloc( r->len );
1193                 memcpy(p, r->name, r->len );
1194                 *rn = r->len;
1195                 return p;
1196             }
1197     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1198     p = m_alloc( 19 );
1199     memcpy(p, "[User id not found]", 19 );
1200     *rn = 19;
1201     return p;
1202 }
1203
1204