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