ready to release 0.4.3
[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 #define DEFINES_GETKEY_CTX 1
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 "i18n.h"
37
38 #define MAX_UNK_CACHE_ENTRIES 1000   /* we use a linked list - so I guess
39                                       * this is a reasonable limit */
40 #define MAX_PK_CACHE_ENTRIES    50
41 #define MAX_UID_CACHE_ENTRIES   50
42
43
44 struct getkey_ctx_s {
45     int mode;
46     int internal;
47     u32 keyid[2];
48     char *namebuf;
49     const char *name;
50     int primary;
51     KBNODE keyblock;
52     KBPOS kbpos;
53     int last_rc;
54     ulong count;
55 };
56
57
58
59
60
61
62 static struct {
63     int any;
64     int okay_count;
65     int nokey_count;
66     int error_count;
67 } lkup_stats[21];
68
69
70
71
72 #if MAX_UNK_CACHE_ENTRIES
73   typedef struct keyid_list {
74       struct keyid_list *next;
75       u32 keyid[2];
76   } *keyid_list_t;
77   static keyid_list_t unknown_keyids;
78   static int unk_cache_entries;   /* number of entries in unknown keys cache */
79   static int unk_cache_disabled;
80 #endif
81
82 #if MAX_PK_CACHE_ENTRIES
83   typedef struct pk_cache_entry {
84       struct pk_cache_entry *next;
85       u32 keyid[2];
86       PKT_public_key *pk;
87   } *pk_cache_entry_t;
88   static pk_cache_entry_t pk_cache;
89   static int pk_cache_entries;   /* number of entries in pk cache */
90   static int pk_cache_disabled;
91 #endif
92
93 #if MAX_UID_CACHE_ENTRIES < 5
94     #error we really need the userid cache
95 #endif
96 typedef struct user_id_db {
97     struct user_id_db *next;
98     u32 keyid[2];
99     int len;
100     char name[1];
101 } *user_id_db_t;
102 static user_id_db_t user_id_db;
103 static int uid_cache_entries;   /* number of entries in uid cache */
104
105
106
107 static int lookup( GETKEY_CTX *ctx, PKT_public_key *pk,
108                    int mode,  u32 *keyid, const char *name,
109                    KBNODE *ret_keyblock, int primary  );
110 static void lookup_close( GETKEY_CTX ctx );
111 static int  lookup_read( GETKEY_CTX ctx,
112                          PKT_public_key *pk, KBNODE *ret_keyblock );
113 static int lookup_sk( PKT_secret_key *sk,
114                    int mode,  u32 *keyid, const char *name, int primary );
115
116
117
118 static void
119 print_stats()
120 {
121     int i;
122     for(i=0; i < DIM(lkup_stats); i++ ) {
123         if( lkup_stats[i].any )
124             fprintf(stderr,
125                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
126                     i,
127                     lkup_stats[i].okay_count,
128                     lkup_stats[i].nokey_count,
129                     lkup_stats[i].error_count );
130     }
131 }
132
133
134
135 static void
136 cache_public_key( PKT_public_key *pk )
137 {
138   #if MAX_PK_CACHE_ENTRIES
139     pk_cache_entry_t ce;
140     u32 keyid[2];
141
142     if( pk_cache_disabled )
143         return;
144
145     if( is_ELGAMAL(pk->pubkey_algo)
146         || pk->pubkey_algo == PUBKEY_ALGO_DSA
147         || is_RSA(pk->pubkey_algo) ) {
148         keyid_from_pk( pk, keyid );
149     }
150     else
151         return; /* don't know how to get the keyid */
152
153     for( ce = pk_cache; ce; ce = ce->next )
154         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
155             if( DBG_CACHE )
156                 log_debug("cache_public_key: already in cache\n");
157             return;
158         }
159
160     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
161         /* fixme: use another algorithm to free some cache slots */
162         pk_cache_disabled=1;
163         log_info("too many entries in pk cache - disabled\n");
164         return;
165     }
166     pk_cache_entries++;
167     ce = m_alloc( sizeof *ce );
168     ce->next = pk_cache;
169     pk_cache = ce;
170     ce->pk = copy_public_key( NULL, pk );
171     ce->keyid[0] = keyid[0];
172     ce->keyid[1] = keyid[1];
173   #endif
174 }
175
176
177 /****************
178  * Store the association of keyid and userid
179  */
180 void
181 cache_user_id( PKT_user_id *uid, u32 *keyid )
182 {
183     user_id_db_t r;
184
185     for(r=user_id_db; r; r = r->next )
186         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
187             if( DBG_CACHE )
188                log_debug("cache_user_id: already in cache\n");
189             return;
190         }
191
192     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
193         /* fixme: use another algorithm to free some cache slots */
194         r = user_id_db;
195         user_id_db = r->next;
196         m_free(r);
197         uid_cache_entries--;
198     }
199     r = m_alloc( sizeof *r + uid->len-1 );
200     r->keyid[0] = keyid[0];
201     r->keyid[1] = keyid[1];
202     r->len = uid->len;
203     memcpy(r->name, uid->name, r->len);
204     r->next = user_id_db;
205     user_id_db = r;
206     uid_cache_entries++;
207 }
208
209
210
211 /****************
212  * Get a public key and store it into the allocated pk
213  * can be called with PK set to NULL to just read it into some
214  * internal structures.
215  */
216 int
217 get_pubkey( PKT_public_key *pk, u32 *keyid )
218 {
219     int internal = 0;
220     int rc = 0;
221
222   #if MAX_UNK_CACHE_ENTRIES
223     {   /* let's see whether we checked the keyid already */
224         keyid_list_t kl;
225         for( kl = unknown_keyids; kl; kl = kl->next )
226             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
227                 return G10ERR_NO_PUBKEY; /* already checked and not found */
228     }
229   #endif
230
231   #if MAX_PK_CACHE_ENTRIES
232     {   /* Try to get it from the cache */
233         pk_cache_entry_t ce;
234         for( ce = pk_cache; ce; ce = ce->next ) {
235             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
236                 if( pk )
237                     copy_public_key( pk, ce->pk );
238                 return 0;
239             }
240         }
241     }
242   #endif
243     /* more init stuff */
244     if( !pk ) {
245         pk = m_alloc_clear( sizeof *pk );
246         internal++;
247     }
248
249
250     /* do a lookup */
251     rc = lookup( NULL, pk, 11, keyid, NULL, NULL, 0 );
252     if( !rc )
253         goto leave;
254
255   #if MAX_UNK_CACHE_ENTRIES
256     /* not found: store it for future reference */
257     if( unk_cache_disabled )
258         ;
259     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
260         unk_cache_disabled = 1;
261         log_info("too many entries in unk cache - disabled\n");
262     }
263     else {
264         keyid_list_t kl;
265
266         kl = m_alloc( sizeof *kl );
267         kl->keyid[0] = keyid[0];
268         kl->keyid[1] = keyid[1];
269         kl->next = unknown_keyids;
270         unknown_keyids = kl;
271     }
272   #endif
273     rc = G10ERR_NO_PUBKEY;
274
275   leave:
276     if( !rc )
277         cache_public_key( pk );
278     if( internal )
279         free_public_key(pk);
280     return rc;
281 }
282
283
284 static int
285 hextobyte( const byte *s )
286 {
287     int c;
288
289     if( *s >= '0' && *s <= '9' )
290         c = 16 * (*s - '0');
291     else if( *s >= 'A' && *s <= 'F' )
292         c = 16 * (10 + *s - 'A');
293     else if( *s >= 'a' && *s <= 'f' )
294         c = 16 * (10 + *s - 'a');
295     else
296         return -1;
297     s++;
298     if( *s >= '0' && *s <= '9' )
299         c += *s - '0';
300     else if( *s >= 'A' && *s <= 'F' )
301         c += 10 + *s - 'A';
302     else if( *s >= 'a' && *s <= 'f' )
303         c += 10 + *s - 'a';
304     else
305         return -1;
306     return c;
307 }
308
309
310
311 /****************
312  * Return the type of the user id:
313  *
314  *  0 = Invalid user ID
315  *  1 = exact match
316  *  2 = match a substring
317  *  3 = match an email address
318  *  4 = match a substring of an email address
319  *  5 = match an email address, but compare from end
320  * 10 = it is a short KEYID (don't care about keyid[0])
321  * 11 = it is a long  KEYID
322  * 16 = it is a 16 byte fingerprint
323  * 20 = it is a 20 byte fingerprint
324  *
325  * if fprint is not NULL, it should be an array of at least 20 bytes.
326  *
327  * Rules used:
328  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
329  *   must be in the range 0..9), this is considered a keyid; depending
330  *   on the length a short or complete one.
331  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
332  *   must be in the range 0..9), this is considered a fingerprint.
333  * - If the username starts with a left angle, we assume it is a complete
334  *   email address and look only at this part.
335  * - If the username starts with a '.', we assume it is the ending
336  *   part of an email address
337  * - If the username starts with an '@', we assume it is a part of an
338  *   email address
339  * - If the userid start with an '=' an exact compare is done.
340  * - If the userid starts with a '*' a case insensitive substring search is
341  *   done (This is the default).
342  */
343
344 int
345 classify_user_id( const char *name, u32 *keyid, byte *fprint,
346                   const char **retstr, size_t *retlen )
347 {
348     const char *s;
349     int mode = 0;
350
351     /* check what kind of name it is */
352     for(s = name; *s && isspace(*s); s++ )
353         ;
354     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
355         int i, j;
356         char buf[9];
357
358         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
359             s += 2; /*kludge to allow 0x034343434 */
360         for(i=0; isxdigit(s[i]); i++ )
361             ;
362         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
363             return 0;
364         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
365             if( i==9 )
366                 s++;
367             if( keyid ) {
368                 keyid[0] = 0;
369                 keyid[1] = strtoul( s, NULL, 16 );
370             }
371             mode = 10;
372         }
373         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
374             if( i==17 )
375                 s++;
376             mem2str(buf, s, 9 );
377             keyid[0] = strtoul( buf, NULL, 16 );
378             keyid[1] = strtoul( s+8, NULL, 16 );
379             mode = 11;
380         }
381         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
382             if( i==33 )
383                 s++;
384             memset(fprint+16, 4, 0);
385             for(j=0; j < 16; j++, s+=2 ) {
386                 int c = hextobyte( s );
387                 if( c == -1 )
388                     return 0;
389                 fprint[j] = c;
390             }
391             mode = 16;
392         }
393         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
394             if( i==33 )
395                 s++;
396             for(j=0; j < 20; j++, s+=2 ) {
397                 int c = hextobyte( s );
398                 if( c == -1 )
399                     return 0;
400                 fprint[j] = c;
401             }
402             mode = 20;
403         }
404         else
405             return 0;
406     }
407     else if( *s == '=' ) { /* exact search */
408         mode = 1;
409         s++;
410     }
411     else if( *s == '*' ) { /* substring search */
412         mode = 2;
413         s++;
414     }
415     else if( *s == '<' ) { /* an email address */
416         mode = 3;
417     }
418     else if( *s == '@' ) { /* a part of an email address */
419         mode = 4;
420         s++;
421     }
422     else if( *s == '.' ) { /* an email address, compare from end */
423         mode = 5;
424         s++;
425     }
426     else if( *s == '#' ) { /* use local id */
427         return 0;
428     }
429     else if( !*s )  /* empty string */
430         return 0;
431     else
432         mode = 2;
433
434     if( retstr )
435         *retstr = s;
436     if( retlen )
437         *retlen = strlen(s);
438
439     return mode;
440 }
441
442
443
444 /****************
445  * Try to get the pubkey by the userid. This function looks for the
446  * first pubkey certificate which has the given name in a user_id.
447  * if pk has the pubkey algo set, the function will only return
448  * a pubkey with that algo.
449  */
450
451 static int
452 key_byname( int secret, GETKEY_CTX *retctx,
453             PKT_public_key *pk, PKT_secret_key *sk,
454             const char *name, KBNODE *ret_kb )
455 {
456     int internal = 0;
457     int rc = 0;
458     const char *s;
459     u32 keyid[2] = {0}; /* init to avoid compiler warning */
460     byte fprint[20];
461     int mode;
462
463     mode = classify_user_id( name, keyid, fprint, &s, NULL );
464     if( !mode ) {
465         rc = G10ERR_INV_USER_ID;
466         goto leave;
467     }
468
469     if( secret ) {
470         if( !sk ) {
471             sk = m_alloc_clear( sizeof *sk );
472             internal++;
473         }
474         rc = mode < 16? lookup_sk( sk, mode, keyid, s, 1 )
475                       : lookup_sk( sk, mode, keyid, fprint, 1 );
476     }
477     else {
478         if( !pk ) {
479             pk = m_alloc_clear( sizeof *pk );
480             internal++;
481         }
482         rc = mode < 16? lookup( retctx, pk, mode, keyid, s, ret_kb, 1 )
483                       : lookup( retctx, pk, mode, keyid, fprint, ret_kb, 1 );
484     }
485
486
487   leave:
488     if( internal && secret )
489         m_free( sk );
490     else if( internal )
491         m_free( pk );
492     return rc;
493 }
494
495 int
496 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
497                    const char *name, KBNODE *ret_keyblock )
498 {
499     int rc;
500
501     if( !pk ) {
502         /* fixme: key_byname should not need a pk in this case */
503         pk = m_alloc_clear( sizeof *pk );
504         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
505         free_public_key( pk );
506     }
507     else
508         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
509     return rc;
510 }
511
512 int
513 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
514 {
515     int rc;
516
517     if( !pk ) {
518         /* fixme: lookup_read should not need a pk in this case */
519         pk = m_alloc_clear( sizeof *pk );
520         rc = lookup_read( ctx, pk, ret_keyblock );
521         free_public_key( pk );
522     }
523     else
524         rc = lookup_read( ctx, pk, ret_keyblock );
525     return rc;
526 }
527
528 void
529 get_pubkey_end( GETKEY_CTX ctx )
530 {
531     if( ctx ) {
532         lookup_close( ctx );
533         m_free( ctx );
534     }
535 }
536
537 /****************
538  * Search for a key with the given fingerprint.
539  */
540 int
541 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
542 {
543     int rc;
544
545     if( fprint_len == 20 || fprint_len == 16 )
546         rc = lookup( NULL, pk, fprint_len, NULL, fprint, NULL, 0 );
547     else
548         rc = G10ERR_GENERAL; /* Oops */
549     return rc;
550 }
551
552 /****************
553  * Search for a key with the given fingerprint and return the
554  * complete keyblock which may have more than only this key.
555  */
556 int
557 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
558                                                 size_t fprint_len )
559 {
560     int rc;
561     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
562
563     if( fprint_len == 20 || fprint_len == 16 )
564         rc = lookup( NULL, pk, fprint_len, NULL, fprint, ret_keyblock, 0 );
565     else
566         rc = G10ERR_GENERAL; /* Oops */
567
568     free_public_key( pk );
569     return rc;
570 }
571
572 /****************
573  * Get a secret key and store it into sk
574  */
575 int
576 get_seckey( PKT_secret_key *sk, u32 *keyid )
577 {
578     int rc;
579
580     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
581     if( !rc ) {
582         /* check the secret key (this may prompt for a passprase to
583          * unlock the secret key
584          */
585         rc = check_secret_key( sk, 0 );
586     }
587
588     return rc;
589 }
590
591 /****************
592  * Check whether the secret key is available
593  * Returns: 0 := key is available
594  *          G10ERR_NO_SECKEY := not availabe
595  */
596 int
597 seckey_available( u32 *keyid )
598 {
599     PKT_secret_key *sk;
600     int rc;
601
602     sk = m_alloc_clear( sizeof *sk );
603     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
604     free_secret_key( sk );
605     return rc;
606 }
607
608
609
610 /****************
611  * Get a secret key by name and store it into sk
612  * If NAME is NULL use the default key
613  */
614 int
615 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
616 {
617     int rc;
618
619     if( !name && opt.def_secret_key && *opt.def_secret_key )
620         rc = key_byname( 1, NULL, NULL, sk, opt.def_secret_key, NULL );
621     else if( !name ) /* use the first one as default key */
622         rc = lookup_sk( sk, 15, NULL, NULL, 1 );
623     else
624         rc = key_byname( 1, NULL, NULL, sk, name, NULL );
625     if( !rc && unprotect )
626         rc = check_secret_key( sk, 0 );
627
628     return rc;
629 }
630
631
632 static int
633 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
634 {
635     int i;
636     const char *s, *se;
637
638     if( mode == 1 ) {  /* exact match */
639         for(i=0; name[i] && uidlen; i++, uidlen-- )
640             if( uid[i] != name[i] )
641                 break;
642         if( !uidlen && !name[i] )
643             return 0; /* found */
644     }
645     else if( mode == 2 ) { /* case insensitive substring */
646         if( memistr( uid, uidlen, name ) )
647             return 0;
648     }
649     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
650         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
651             ;
652         if( i < uidlen )  {
653             /* skip opening delim and one char and look for the closing one*/
654             s++; i++;
655             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
656                 ;
657             if( i < uidlen ) {
658                 i = se - s;
659                 if( mode == 3 ) { /* exact email address */
660                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
661                         return 0;
662                 }
663                 else if( mode == 4 ) {  /* email substring */
664                     if( memistr( s, i, name ) )
665                         return 0;
666                 }
667                 else { /* email from end */
668                     /* nyi */
669                 }
670             }
671         }
672     }
673     else
674         BUG();
675
676     return -1; /* not found */
677 }
678
679
680
681 /****************
682  * Assume that knode points to a public key packet  and keyblock is
683  * the entire keyblock.  This function adds all relevant information from
684  * a selfsignature to the public key.
685  */
686
687 static void
688 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode )
689 {
690     PKT_public_key *pk = knode->pkt->pkt.public_key;
691     PKT_signature *sig;
692     KBNODE k;
693     u32 kid[2];
694
695     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
696             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
697
698     if( pk->version < 4 )
699         return; /* this is only needed for version >=4 packets */
700
701     /* find the selfsignature */
702     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
703         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
704         if( !k )
705            BUG(); /* keyblock without primary key!!! */
706         keyid_from_pk( knode->pkt->pkt.public_key, kid );
707     }
708     else
709         keyid_from_pk( pk, kid );
710     for(k=keyblock; k; k = k->next ) {
711         if( k->pkt->pkttype == PKT_SIGNATURE
712             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
713             && sig->sig_class <= 0x30
714             && sig->keyid[0] == kid[0]
715             && sig->keyid[1] == kid[1]
716             && sig->version > 3 ) {
717             /* okay this is (the first) self-signature which can be used
718              * FIXME: We should only use this if the signature is valid
719              *        but this is time consuming - we must provide another
720              *        way to handle this
721              */
722             const byte *p;
723             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
724             pk->expiredate = p? buffer_to_u32(p):0;
725             /* fixme: add usage etc. to pk */
726             break;
727         }
728     }
729 }
730
731
732 /****************
733  * merge all selfsignatures with the keys.
734  */
735 void
736 merge_keys_and_selfsig( KBNODE keyblock )
737 {
738     PKT_public_key *pk = NULL;
739     PKT_secret_key *sk = NULL;
740     PKT_signature *sig;
741     KBNODE k;
742     u32 kid[2];
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             pk = k->pkt->pkt.public_key; sk = NULL;
748             if( pk->version < 4 )
749                 pk = NULL; /* not needed for old keys */
750             else
751                 keyid_from_pk( pk, kid );
752         }
753         else if( k->pkt->pkttype == PKT_SECRET_KEY
754             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
755             pk = NULL; sk = k->pkt->pkt.secret_key;
756             if( sk->version < 4 )
757                 sk = NULL;
758             else
759                 keyid_from_sk( sk, kid );
760         }
761         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
762                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
763                  && sig->sig_class <= 0x30 && sig->version > 3
764                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
765             /* okay this is (the first) self-signature which can be used
766              * FIXME: We should only use this if the signature is valid
767              *        but this is time consuming - we must provide another
768              *        way to handle this
769              */
770             const byte *p;
771             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
772             if( pk ) {
773                 pk->expiredate = p? buffer_to_u32(p):0;
774                 /* fixme: add usage etc. */
775                 pk = NULL; /* use only the first self signature */
776             }
777             else {
778                 sk->expiredate = p? buffer_to_u32(p):0;
779                 sk = NULL; /* use only the first self signature */
780             }
781         }
782     }
783 }
784
785
786 static KBNODE
787 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
788               int mode, byte *namehash, int *use_namehash )
789 {
790     KBNODE k, kk;
791
792     for(k=keyblock; k; k = k->next ) {
793         if( k->pkt->pkttype == PKT_USER_ID
794             && !compare_name( k->pkt->pkt.user_id->name,
795                               k->pkt->pkt.user_id->len, name, mode)) {
796             /* we found a matching name, look for the key */
797             for(kk=keyblock; kk; kk = kk->next ) {
798                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
799                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
800                     && ( !pk->pubkey_algo
801                          || pk->pubkey_algo
802                             == kk->pkt->pkt.public_key->pubkey_algo)
803                     && ( !pk->pubkey_usage
804                          || !check_pubkey_algo2(
805                                kk->pkt->pkt.public_key->pubkey_algo,
806                                                    pk->pubkey_usage ))
807                   )
808                     break;
809             }
810             if( kk ) {
811                 u32 aki[2];
812                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
813                 cache_user_id( k->pkt->pkt.user_id, aki );
814                 rmd160_hash_buffer( namehash,
815                                     k->pkt->pkt.user_id->name,
816                                     k->pkt->pkt.user_id->len );
817                 *use_namehash = 1;
818                 return kk;
819             }
820             else if( is_RSA(pk->pubkey_algo) )
821                 log_error("RSA key cannot be used in this version\n");
822             else
823                 log_error("No key for userid\n");
824         }
825     }
826     return NULL;
827 }
828
829
830 static KBNODE
831 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
832 {
833     KBNODE k;
834
835     if( DBG_CACHE )
836         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
837                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
838
839     for(k=keyblock; k; k = k->next ) {
840         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
841             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
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                 KBNODE kk;
855                 /* cache the userid */
856                 for(kk=keyblock; kk; kk = kk->next )
857                     if( kk->pkt->pkttype == PKT_USER_ID )
858                         break;
859                 if( kk )
860                     cache_user_id( kk->pkt->pkt.user_id, aki );
861                 else
862                     log_error("No userid for key\n");
863                 return k; /* found */
864             }
865         }
866     }
867     return NULL;
868 }
869
870
871 static KBNODE
872 find_first( KBNODE keyblock, PKT_public_key *pk )
873 {
874     KBNODE k;
875
876     for(k=keyblock; k; k = k->next ) {
877         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
878             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
879         {
880             if( !pk->pubkey_algo
881                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
882                 return k;
883         }
884     }
885     return NULL;
886 }
887
888
889 static KBNODE
890 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
891 {
892     KBNODE k;
893
894     for(k=keyblock; k; k = k->next ) {
895         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
896             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
897             byte afp[MAX_FINGERPRINT_LEN];
898             size_t an;
899
900             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
901
902             if( DBG_CACHE ) {
903                 u32 aki[2];
904                 keyid_from_pk( k->pkt->pkt.public_key, aki );
905                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
906                                 (ulong)aki[0], (ulong)aki[1],
907                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
908             }
909
910             if( an == mode
911                 && !memcmp( afp, name, an)
912                 && ( !pk->pubkey_algo
913                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
914                 return k;
915         }
916     }
917     return NULL;
918 }
919
920
921 static void
922 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
923                                                int use_namehash, int primary )
924 {
925     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
926             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
927     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
928     if( primary && !pk->pubkey_usage ) {
929         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
930                                       use_namehash? namehash:NULL);
931         merge_one_pk_and_selfsig( keyblock, keyblock );
932     }
933     else {
934         if( primary && pk->pubkey_usage
935             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
936                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
937             /* if the usage is not correct, try to use a subkey */
938             KBNODE save_k = k;
939
940             for( ; k; k = k->next ) {
941                 if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
942                     && !check_pubkey_algo2(
943                             k->pkt->pkt.public_key->pubkey_algo,
944                                              pk->pubkey_usage ) )
945                     break;
946             }
947             if( !k )
948                 k = save_k;
949             else
950                 log_info(_("using secondary key %08lX "
951                            "instead of primary key %08lX\n"),
952                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
953                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
954                         );
955         }
956
957         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
958                                       use_namehash? namehash:NULL);
959         merge_one_pk_and_selfsig( keyblock, k );
960     }
961 }
962
963 /****************
964  * Lookup a key by scanning all keyresources
965  *   mode 1 = lookup by NAME (exact)
966  *        2 = lookup by NAME (substring)
967  *        3 = lookup by NAME (email address)
968  *        4 = email address (substring)
969  *        5 = email address (compare from end)
970  *       10 = lookup by short KEYID (don't care about keyid[0])
971  *       11 = lookup by long  KEYID
972  *       15 = Get the first key.
973  *       16 = lookup by 16 byte fingerprint which is stored in NAME
974  *       20 = lookup by 20 byte fingerprint which is stored in NAME
975  * Caller must provide an empty PK, if the pubkey_algo is filled in, only
976  * a key of this algo will be returned.
977  * If ret_keyblock is not NULL, the complete keyblock is returned also
978  * and the caller must release it.
979  */
980 static int
981 lookup( GETKEY_CTX *retctx, PKT_public_key *pk, int mode, u32 *keyid,
982         const char *name, KBNODE *ret_keyblock, int primary )
983 {
984     struct getkey_ctx_s help_ctx;
985     GETKEY_CTX ctx;
986     int rc;
987
988     if( !retctx )
989         ctx = &help_ctx;
990     else {
991         ctx = m_alloc( sizeof *ctx );
992         *retctx = ctx;
993     }
994
995     memset( ctx, 0, sizeof *ctx );
996     ctx->mode = mode;
997     if( keyid ) {
998         ctx->keyid[0] = keyid[0];
999         ctx->keyid[1] = keyid[1];
1000     }
1001     if( retctx ) {
1002         ctx->namebuf = name? m_strdup(name) : NULL;
1003         ctx->name = ctx->namebuf;
1004     }
1005     else
1006         ctx->name = name;
1007     ctx->primary = primary;
1008     rc = lookup_read( ctx, pk, ret_keyblock );
1009     if( !retctx )
1010         lookup_close( ctx );
1011     return rc;
1012 }
1013
1014 static void
1015 lookup_close( GETKEY_CTX ctx )
1016 {
1017     enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
1018     m_free( ctx->namebuf );
1019 }
1020
1021 static int
1022 lookup_read( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1023 {
1024     int rc;
1025     KBNODE k;
1026     int oldmode = set_packet_list_mode(0);
1027     byte namehash[20];
1028     int use_namehash=0;
1029
1030     /* try the quick functions */
1031     if( !ctx->count ) {
1032         k = NULL;
1033         switch( ctx->mode ) {
1034           case 10:
1035           case 11:
1036             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1037                                                         ctx->mode==10, 0 );
1038             if( !rc )
1039                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1040             if( !rc )
1041                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1042             break;
1043
1044           case 16:
1045           case 20:
1046             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1047             if( !rc )
1048                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1049             if( !rc )
1050                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1051             break;
1052
1053           default: rc = G10ERR_UNSUPPORTED;
1054         }
1055         if( !rc ) {
1056             if( !k ) {
1057                 log_error("lookup: key has been located but was not found\n");
1058                 rc = G10ERR_INV_KEYRING;
1059             }
1060             else
1061                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1062         }
1063     }
1064     else
1065         rc = G10ERR_UNSUPPORTED;
1066
1067     /* if this was not possible, loop over all keyblocks
1068      * fixme: If one of the resources in the quick functions above
1069      *        works, but the key was not found, we will not find it
1070      *        in the other resources */
1071     if( rc == G10ERR_UNSUPPORTED ) {
1072         if( !ctx->count )
1073             rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1074         else
1075             rc = 0;
1076         if( !rc ) {
1077             while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1078                 /* fixme: we donĀ“t enum the complete keyblock, but
1079                  * use the first match and that continue with the next keyblock
1080                  */
1081                 if( ctx->mode < 10 )
1082                     k = find_by_name( ctx->keyblock, pk, ctx->name, ctx->mode,
1083                                                     namehash, &use_namehash);
1084                 else if( ctx->mode == 10 ||ctx-> mode == 11 )
1085                     k = find_by_keyid( ctx->keyblock, pk, ctx->keyid,
1086                                                                 ctx->mode );
1087                 else if( ctx->mode == 15 )
1088                     k = find_first( ctx->keyblock, pk );
1089                 else if( ctx->mode == 16 || ctx->mode == 20 )
1090                     k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1091                 else
1092                     BUG();
1093                 if( k ) {
1094                     finish_lookup( ctx->keyblock, pk, k, namehash,
1095                                                  use_namehash, ctx->primary );
1096                     break; /* found */
1097                 }
1098                 release_kbnode( ctx->keyblock );
1099                 ctx->keyblock = NULL;
1100             }
1101         }
1102         if( rc && rc != -1 )
1103             log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1104     }
1105
1106     if( !rc ) {
1107         if( ret_keyblock ) {
1108             *ret_keyblock = ctx->keyblock;
1109             ctx->keyblock = NULL;
1110         }
1111     }
1112     else if( rc == -1 )
1113         rc = G10ERR_NO_PUBKEY;
1114
1115     release_kbnode( ctx->keyblock );
1116     ctx->keyblock = NULL;
1117     set_packet_list_mode(oldmode);
1118     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1119         static int initialized;
1120
1121         if( !initialized ) {
1122             initialized = 1;
1123             atexit( print_stats );
1124         }
1125
1126         assert( ctx->mode < DIM(lkup_stats) );
1127         lkup_stats[ctx->mode].any = 1;
1128         if( !rc )
1129             lkup_stats[ctx->mode].okay_count++;
1130         else if ( rc == G10ERR_NO_PUBKEY )
1131             lkup_stats[ctx->mode].nokey_count++;
1132         else
1133             lkup_stats[ctx->mode].error_count++;
1134     }
1135
1136     ctx->last_rc = rc;
1137     ctx->count++;
1138     return rc;
1139 }
1140
1141
1142 /****************
1143  * Ditto for secret keys
1144  */
1145 static int
1146 lookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1147            int primary )
1148 {
1149     int rc;
1150     KBNODE keyblock = NULL;
1151     KBPOS kbpos;
1152     int oldmode = set_packet_list_mode(0);
1153
1154     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1155     if( rc ) {
1156         if( rc == -1 )
1157             rc = G10ERR_NO_SECKEY;
1158         else if( rc )
1159             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1160         goto leave;
1161     }
1162
1163     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1164         KBNODE k, kk;
1165         if( mode < 10 ) { /* name lookup */
1166             for(k=keyblock; k; k = k->next ) {
1167                 if( k->pkt->pkttype == PKT_USER_ID
1168                     && !compare_name( k->pkt->pkt.user_id->name,
1169                                       k->pkt->pkt.user_id->len, name, mode)) {
1170                     /* we found a matching name, look for the key */
1171                     for(kk=keyblock; kk; kk = kk->next ) {
1172                         if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1173                               || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1174                             && ( !sk->pubkey_algo
1175                                  || sk->pubkey_algo
1176                                     == kk->pkt->pkt.secret_key->pubkey_algo)
1177                             && ( !sk->pubkey_usage
1178                                  || !check_pubkey_algo2(
1179                                        kk->pkt->pkt.secret_key->pubkey_algo,
1180                                                            sk->pubkey_usage ))
1181                           )
1182                             break;
1183                     }
1184                     if( kk ) {
1185                         u32 aki[2];
1186                         keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1187                         cache_user_id( k->pkt->pkt.user_id, aki );
1188                         k = kk;
1189                         break;
1190                     }
1191                     else
1192                         log_error("No key for userid (in sk)\n");
1193                 }
1194             }
1195         }
1196         else { /* keyid or fingerprint lookup */
1197             if( DBG_CACHE && (mode== 10 || mode==11) ) {
1198                 log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1199                                 (ulong)keyid[0], (ulong)keyid[1],
1200                                  sk->pubkey_algo, mode );
1201             }
1202             for(k=keyblock; k; k = k->next ) {
1203                 if(    k->pkt->pkttype == PKT_SECRET_KEY
1204                     || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1205                     if( mode == 10 || mode == 11 ) {
1206                         u32 aki[2];
1207                         keyid_from_sk( k->pkt->pkt.secret_key, aki );
1208                         if( DBG_CACHE ) {
1209                             log_debug("             aki=%08lx%08lx algo=%d\n",
1210                                             (ulong)aki[0], (ulong)aki[1],
1211                                     k->pkt->pkt.secret_key->pubkey_algo    );
1212                         }
1213                         if( aki[1] == keyid[1]
1214                             && ( mode == 10 || aki[0] == keyid[0] )
1215                             && ( !sk->pubkey_algo
1216                                  || sk->pubkey_algo
1217                                     == k->pkt->pkt.secret_key->pubkey_algo) ){
1218                             /* cache the userid */
1219                             for(kk=keyblock; kk; kk = kk->next )
1220                                 if( kk->pkt->pkttype == PKT_USER_ID )
1221                                     break;
1222                             if( kk )
1223                                 cache_user_id( kk->pkt->pkt.user_id, aki );
1224                             else
1225                                 log_error("No userid for key\n");
1226                             break; /* found */
1227                         }
1228                     }
1229                     else if( mode == 15 ) { /* get the first key */
1230                         if( !sk->pubkey_algo
1231                             || sk->pubkey_algo
1232                                   == k->pkt->pkt.secret_key->pubkey_algo )
1233                             break;
1234                     }
1235                     else if( mode == 16 || mode == 20 ) {
1236                         size_t an;
1237                         byte afp[MAX_FINGERPRINT_LEN];
1238
1239                         fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1240                         if( an == mode && !memcmp( afp, name, an)
1241                             && ( !sk->pubkey_algo
1242                                  || sk->pubkey_algo
1243                                     == k->pkt->pkt.secret_key->pubkey_algo) ) {
1244                             break;
1245                         }
1246                     }
1247                     else
1248                         BUG();
1249                 } /* end compare secret keys */
1250             }
1251         }
1252         if( k ) { /* found */
1253             assert(    k->pkt->pkttype == PKT_SECRET_KEY
1254                     || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1255             assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1256             if( primary && !sk->pubkey_usage )
1257                 copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1258             else
1259                 copy_secret_key( sk, k->pkt->pkt.secret_key );
1260             break; /* enumeration */
1261         }
1262         release_kbnode( keyblock );
1263         keyblock = NULL;
1264     }
1265     if( rc == -1 )
1266         rc = G10ERR_NO_SECKEY;
1267     else if( rc )
1268         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1269
1270   leave:
1271     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1272     release_kbnode( keyblock );
1273     set_packet_list_mode(oldmode);
1274     return rc;
1275 }
1276
1277
1278
1279 /****************
1280  * Enumerate all primary secret keys.  Caller must use these procedure:
1281  *  1) create a void pointer and initialize it to NULL
1282  *  2) pass this void pointer by reference to this function
1283  *     and provide space for the secret key (pass a buffer for sk)
1284  *  3) call this function as long as it does not return -1
1285  *     to indicate EOF.
1286  *  4) Always call this function a last time with SK set to NULL,
1287  *     so that can free it's context.
1288  *
1289  *
1290  */
1291 int
1292 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1293 {
1294     int rc=0;
1295     PACKET pkt;
1296     int save_mode;
1297     struct {
1298         int eof;
1299         int sequence;
1300         const char *name;
1301         IOBUF iobuf;
1302     } *c = *context;
1303
1304
1305     if( !c ) { /* make a new context */
1306         c = m_alloc_clear( sizeof *c );
1307         *context = c;
1308         c->sequence = 0;
1309         c->name = enum_keyblock_resources( &c->sequence, 1 );
1310     }
1311
1312     if( !sk ) { /* free the context */
1313         if( c->iobuf )
1314             iobuf_close(c->iobuf);
1315         m_free( c );
1316         *context = NULL;
1317         return 0;
1318     }
1319
1320     if( c->eof )
1321         return -1;
1322
1323     /* FIXME: This assumes a plain keyring file */
1324     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1325         if( !c->iobuf ) {
1326             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1327                 log_error("enum_secret_keys: can't open '%s'\n", c->name );
1328                 continue; /* try next file */
1329             }
1330         }
1331
1332         save_mode = set_packet_list_mode(0);
1333         init_packet(&pkt);
1334         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1335             if( rc )
1336                 ; /* e.g. unknown packet */
1337             else if( pkt.pkttype == PKT_SECRET_KEY
1338                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1339                 copy_secret_key( sk, pkt.pkt.secret_key );
1340                 set_packet_list_mode(save_mode);
1341                 return 0; /* found */
1342             }
1343             free_packet(&pkt);
1344         }
1345         set_packet_list_mode(save_mode);
1346         iobuf_close(c->iobuf); c->iobuf = NULL;
1347     }
1348     c->eof = 1;
1349     return -1;
1350 }
1351
1352
1353 /****************
1354  * Return a string with a printable representation of the user_id.
1355  * this string must be freed by m_free.
1356  */
1357 char*
1358 get_user_id_string( u32 *keyid )
1359 {
1360     user_id_db_t r;
1361     char *p;
1362     int pass=0;
1363     /* try it two times; second pass reads from key resources */
1364     do {
1365         for(r=user_id_db; r; r = r->next )
1366             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1367                 p = m_alloc( r->len + 10 );
1368                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1369                 return p;
1370             }
1371     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1372     p = m_alloc( 15 );
1373     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1374     return p;
1375 }
1376
1377 char*
1378 get_user_id( u32 *keyid, size_t *rn )
1379 {
1380     user_id_db_t r;
1381     char *p;
1382     int pass=0;
1383     /* try it two times; second pass reads from key resources */
1384     do {
1385         for(r=user_id_db; r; r = r->next )
1386             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1387                 p = m_alloc( r->len );
1388                 memcpy(p, r->name, r->len );
1389                 *rn = r->len;
1390                 return p;
1391             }
1392     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1393     p = m_alloc( 19 );
1394     memcpy(p, "[User id not found]", 19 );
1395     *rn = 19;
1396     return p;
1397 }
1398
1399