770aa5811b11291fe77f99a6491298f9191b0db6
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998, 1999 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   /* we use a linked list - so I guess
37                                       * this is a reasonable limit */
38 #define MAX_PK_CACHE_ENTRIES    50
39 #define MAX_UID_CACHE_ENTRIES   50
40
41 /* Aa map of the all characters valid used for word_match()
42  * Valid characters are in in this table converted to uppercase.
43  * becuase the upper 128 bytes have special meanin, we assume
44  * that they are all valid.
45  * Note: We must use numerical values here in case that this program
46  * will be converted to those little blue HAL9000s with their strange
47  * EBCDIC character set (user ids are UTF-8). */
48 static const byte word_match_chars[256] = {
49   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
50   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
51   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
52   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
53   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
54   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
55   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
56   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
57   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
58   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
59   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
60   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
61   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
62   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
63   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
64   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
65   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
66   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
67   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
68   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
69   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
70   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
71   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
72   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
73   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
74   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
75   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
76   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
77   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
78   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
79   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
80   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
81 };
82
83 typedef struct {
84     int mode;
85     u32 keyid[2];
86     byte fprint[20];
87     char *namebuf;
88     const char *name;
89 } getkey_item_t;
90
91 struct getkey_ctx_s {
92     /* make an array or a linked list from dome fields */
93     int primary;
94     KBNODE keyblock;
95     KBPOS kbpos;
96     int last_rc;
97     ulong count;
98     int nitems;
99     getkey_item_t items[1];
100 };
101
102
103
104
105
106 #if 0
107 static struct {
108     int any;
109     int okay_count;
110     int nokey_count;
111     int error_count;
112 } lkup_stats[21];
113 #endif
114
115
116
117 #if MAX_UNK_CACHE_ENTRIES
118   typedef struct keyid_list {
119       struct keyid_list *next;
120       u32 keyid[2];
121   } *keyid_list_t;
122   static keyid_list_t unknown_keyids;
123   static int unk_cache_entries;   /* number of entries in unknown keys cache */
124   static int unk_cache_disabled;
125 #endif
126
127 #if MAX_PK_CACHE_ENTRIES
128   typedef struct pk_cache_entry {
129       struct pk_cache_entry *next;
130       u32 keyid[2];
131       PKT_public_key *pk;
132   } *pk_cache_entry_t;
133   static pk_cache_entry_t pk_cache;
134   static int pk_cache_entries;   /* number of entries in pk cache */
135   static int pk_cache_disabled;
136 #endif
137
138 #if MAX_UID_CACHE_ENTRIES < 5
139     #error we really need the userid cache
140 #endif
141 typedef struct user_id_db {
142     struct user_id_db *next;
143     u32 keyid[2];
144     int len;
145     char name[1];
146 } *user_id_db_t;
147 static user_id_db_t user_id_db;
148 static int uid_cache_entries;   /* number of entries in uid cache */
149
150
151
152 static char* prepare_word_match( const byte *name );
153 static int lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_kb );
154 static int lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_kb );
155
156
157 #if 0
158 static void
159 print_stats()
160 {
161     int i;
162     for(i=0; i < DIM(lkup_stats); i++ ) {
163         if( lkup_stats[i].any )
164             fprintf(stderr,
165                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
166                     i,
167                     lkup_stats[i].okay_count,
168                     lkup_stats[i].nokey_count,
169                     lkup_stats[i].error_count );
170     }
171 }
172 #endif
173
174
175 static void
176 cache_public_key( PKT_public_key *pk )
177 {
178   #if MAX_PK_CACHE_ENTRIES
179     pk_cache_entry_t ce;
180     u32 keyid[2];
181
182     if( pk_cache_disabled )
183         return;
184
185     if( is_ELGAMAL(pk->pubkey_algo)
186         || pk->pubkey_algo == PUBKEY_ALGO_DSA
187         || is_RSA(pk->pubkey_algo) ) {
188         keyid_from_pk( pk, keyid );
189     }
190     else
191         return; /* don't know how to get the keyid */
192
193     for( ce = pk_cache; ce; ce = ce->next )
194         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
195             if( DBG_CACHE )
196                 log_debug("cache_public_key: already in cache\n");
197             return;
198         }
199
200     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
201         /* fixme: use another algorithm to free some cache slots */
202         pk_cache_disabled=1;
203         if( opt.verbose > 1 )
204             log_info(_("too many entries in pk cache - disabled\n"));
205         return;
206     }
207     pk_cache_entries++;
208     ce = m_alloc( sizeof *ce );
209     ce->next = pk_cache;
210     pk_cache = ce;
211     ce->pk = copy_public_key( NULL, pk );
212     ce->keyid[0] = keyid[0];
213     ce->keyid[1] = keyid[1];
214   #endif
215 }
216
217
218 /****************
219  * Store the association of keyid and userid
220  */
221 void
222 cache_user_id( PKT_user_id *uid, u32 *keyid )
223 {
224     user_id_db_t r;
225
226     for(r=user_id_db; r; r = r->next )
227         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
228             if( DBG_CACHE )
229                log_debug("cache_user_id: already in cache\n");
230             return;
231         }
232
233     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
234         /* fixme: use another algorithm to free some cache slots */
235         r = user_id_db;
236         user_id_db = r->next;
237         m_free(r);
238         uid_cache_entries--;
239     }
240     r = m_alloc( sizeof *r + uid->len-1 );
241     r->keyid[0] = keyid[0];
242     r->keyid[1] = keyid[1];
243     r->len = uid->len;
244     memcpy(r->name, uid->name, r->len);
245     r->next = user_id_db;
246     user_id_db = r;
247     uid_cache_entries++;
248 }
249
250
251 void
252 getkey_disable_caches()
253 {
254   #if MAX_UNK_CACHE_ENTRIES
255     {
256         keyid_list_t kl, kl2;
257         for( kl = unknown_keyids; kl; kl = kl2 ) {
258             kl2 = kl->next;
259             m_free(kl);
260         }
261         unknown_keyids = NULL;
262         unk_cache_disabled = 1;
263     }
264   #endif
265   #if MAX_PK_CACHE_ENTRIES
266     {
267         pk_cache_entry_t ce, ce2;
268
269         for( ce = pk_cache; ce; ce = ce2 ) {
270             ce2 = ce->next;
271             free_public_key( ce->pk );
272             m_free( ce );
273         }
274         pk_cache_disabled=1;
275         pk_cache_entries = 0;
276         pk_cache = NULL;
277     }
278   #endif
279     /* fixme: disable user id cache ? */
280 }
281
282
283 /****************
284  * Get a public key and store it into the allocated pk
285  * can be called with PK set to NULL to just read it into some
286  * internal structures.
287  */
288 int
289 get_pubkey( PKT_public_key *pk, u32 *keyid )
290 {
291     int internal = 0;
292     int rc = 0;
293
294   #if MAX_UNK_CACHE_ENTRIES
295     {   /* let's see whether we checked the keyid already */
296         keyid_list_t kl;
297         for( kl = unknown_keyids; kl; kl = kl->next )
298             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
299                 return G10ERR_NO_PUBKEY; /* already checked and not found */
300     }
301   #endif
302
303   #if MAX_PK_CACHE_ENTRIES
304     {   /* Try to get it from the cache */
305         pk_cache_entry_t ce;
306         for( ce = pk_cache; ce; ce = ce->next ) {
307             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
308                 if( pk )
309                     copy_public_key( pk, ce->pk );
310                 return 0;
311             }
312         }
313     }
314   #endif
315     /* more init stuff */
316     if( !pk ) {
317         pk = m_alloc_clear( sizeof *pk );
318         internal++;
319     }
320
321
322     /* do a lookup */
323     {   struct getkey_ctx_s ctx;
324         memset( &ctx, 0, sizeof ctx );
325         ctx.nitems = 1;
326         ctx.items[0].mode = 11;
327         ctx.items[0].keyid[0] = keyid[0];
328         ctx.items[0].keyid[1] = keyid[1];
329         rc = lookup_pk( &ctx, pk, NULL );
330     }
331     if( !rc )
332         goto leave;
333
334   #if MAX_UNK_CACHE_ENTRIES
335     /* not found: store it for future reference */
336     if( unk_cache_disabled )
337         ;
338     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
339         unk_cache_disabled = 1;
340         if( opt.verbose > 1 )
341             log_info(_("too many entries in unk cache - disabled\n"));
342     }
343     else {
344         keyid_list_t kl;
345
346         kl = m_alloc( sizeof *kl );
347         kl->keyid[0] = keyid[0];
348         kl->keyid[1] = keyid[1];
349         kl->next = unknown_keyids;
350         unknown_keyids = kl;
351     }
352   #endif
353     rc = G10ERR_NO_PUBKEY;
354
355   leave:
356     if( !rc )
357         cache_public_key( pk );
358     if( internal )
359         free_public_key(pk);
360     return rc;
361 }
362
363
364 /****************
365  * Get a secret key and store it into sk
366  */
367 int
368 get_seckey( PKT_secret_key *sk, u32 *keyid )
369 {
370     int rc;
371     struct getkey_ctx_s ctx;
372
373     memset( &ctx, 0, sizeof ctx );
374     ctx.nitems = 1;
375     ctx.items[0].mode = 11;
376     ctx.items[0].keyid[0] = keyid[0];
377     ctx.items[0].keyid[1] = keyid[1];
378     rc = lookup_sk( &ctx, sk, NULL );
379     if( !rc ) {
380         /* check the secret key (this may prompt for a passprase to
381          * unlock the secret key
382          */
383         rc = check_secret_key( sk, 0 );
384     }
385
386     return rc;
387 }
388
389
390 /****************
391  * Get the primary secret key and store it into sk
392  * Note: This function does not unprotect the key!
393  */
394 int
395 get_primary_seckey( PKT_secret_key *sk, u32 *keyid )
396 {
397     struct getkey_ctx_s ctx;
398
399     memset( &ctx, 0, sizeof ctx );
400     ctx.primary = 1;
401     ctx.nitems = 1;
402     ctx.items[0].mode = 11;
403     ctx.items[0].keyid[0] = keyid[0];
404     ctx.items[0].keyid[1] = keyid[1];
405     return lookup_sk( &ctx, sk, NULL );
406 }
407
408
409
410 /****************
411  * Check whether the secret key is available
412  * Returns: 0 := key is available
413  *          G10ERR_NO_SECKEY := not availabe
414  */
415 int
416 seckey_available( u32 *keyid )
417 {
418     int rc;
419     struct getkey_ctx_s ctx;
420     PKT_secret_key *sk;
421
422     sk = m_alloc_clear( sizeof *sk );
423     memset( &ctx, 0, sizeof ctx );
424     ctx.nitems = 1;
425     ctx.items[0].mode = 11;
426     ctx.items[0].keyid[0] = keyid[0];
427     ctx.items[0].keyid[1] = keyid[1];
428     rc = lookup_sk( &ctx, sk, NULL );
429     free_secret_key( sk );
430     return rc;
431 }
432
433
434
435 static int
436 hextobyte( const byte *s )
437 {
438     int c;
439
440     if( *s >= '0' && *s <= '9' )
441         c = 16 * (*s - '0');
442     else if( *s >= 'A' && *s <= 'F' )
443         c = 16 * (10 + *s - 'A');
444     else if( *s >= 'a' && *s <= 'f' )
445         c = 16 * (10 + *s - 'a');
446     else
447         return -1;
448     s++;
449     if( *s >= '0' && *s <= '9' )
450         c += *s - '0';
451     else if( *s >= 'A' && *s <= 'F' )
452         c += 10 + *s - 'A';
453     else if( *s >= 'a' && *s <= 'f' )
454         c += 10 + *s - 'a';
455     else
456         return -1;
457     return c;
458 }
459
460
461
462 /****************
463  * Return the type of the user id:
464  *
465  *  0 = Invalid user ID
466  *  1 = exact match
467  *  2 = match a substring
468  *  3 = match an email address
469  *  4 = match a substring of an email address
470  *  5 = match an email address, but compare from end
471  *  6 = word match mode
472  * 10 = it is a short KEYID (don't care about keyid[0])
473  * 11 = it is a long  KEYID
474  * 16 = it is a 16 byte fingerprint
475  * 20 = it is a 20 byte fingerprint
476  *
477  * if fprint is not NULL, it should be an array of at least 20 bytes.
478  *
479  * Rules used:
480  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
481  *   must be in the range 0..9), this is considered a keyid; depending
482  *   on the length a short or complete one.
483  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
484  *   must be in the range 0..9), this is considered a fingerprint.
485  * - If the username starts with a left angle, we assume it is a complete
486  *   email address and look only at this part.
487  * - If the username starts with a '.', we assume it is the ending
488  *   part of an email address
489  * - If the username starts with an '@', we assume it is a part of an
490  *   email address
491  * - If the userid start with an '=' an exact compare is done.
492  * - If the userid starts with a '*' a case insensitive substring search is
493  *   done (This is the default).
494  * - If the userid starts with a '+' we will compare individual words
495  *   and a match requires that all the words are in the userid.
496  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
497  *   (note that you can't search for these characters). Compare
498  *   is not case sensitive.
499  */
500
501 int
502 classify_user_id( const char *name, u32 *keyid, byte *fprint,
503                   const char **retstr, size_t *retlen )
504 {
505     const char *s;
506     int mode = 0;
507
508     /* check what kind of name it is */
509     for(s = name; *s && isspace(*s); s++ )
510         ;
511     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
512         int i, j;
513         char buf[9];
514
515         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
516             s += 2; /*kludge to allow 0x034343434 */
517         for(i=0; isxdigit(s[i]); i++ )
518             ;
519         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
520             return 0;
521         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
522             if( i==9 )
523                 s++;
524             if( keyid ) {
525                 keyid[0] = 0;
526                 keyid[1] = strtoul( s, NULL, 16 );
527             }
528             mode = 10;
529         }
530         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
531             if( i==17 )
532                 s++;
533             mem2str(buf, s, 9 );
534             keyid[0] = strtoul( buf, NULL, 16 );
535             keyid[1] = strtoul( s+8, NULL, 16 );
536             mode = 11;
537         }
538         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
539             if( i==33 )
540                 s++;
541             if( fprint ) {
542                 memset(fprint+16, 4, 0);
543                 for(j=0; j < 16; j++, s+=2 ) {
544                     int c = hextobyte( s );
545                     if( c == -1 )
546                         return 0;
547                     fprint[j] = c;
548                 }
549             }
550             mode = 16;
551         }
552         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
553             if( i==33 )
554                 s++;
555             if( fprint ) {
556                 for(j=0; j < 20; j++, s+=2 ) {
557                     int c = hextobyte( s );
558                     if( c == -1 )
559                         return 0;
560                     fprint[j] = c;
561                 }
562             }
563             mode = 20;
564         }
565         else
566             return 0;
567     }
568     else if( *s == '=' ) { /* exact search */
569         mode = 1;
570         s++;
571     }
572     else if( *s == '*' ) { /* substring search */
573         mode = 2;
574         s++;
575     }
576     else if( *s == '<' ) { /* an email address */
577         mode = 3;
578     }
579     else if( *s == '@' ) { /* a part of an email address */
580         mode = 4;
581         s++;
582     }
583     else if( *s == '.' ) { /* an email address, compare from end */
584         mode = 5;
585         s++;
586     }
587     else if( *s == '+' ) { /* word match mode */
588         mode = 6;
589         s++;
590     }
591     else if( *s == '#' ) { /* use local id */
592         return 0;
593     }
594     else if( !*s )  /* empty string */
595         return 0;
596     else
597         mode = 2;
598
599     if( retstr )
600         *retstr = s;
601     if( retlen )
602         *retlen = strlen(s);
603
604     return mode;
605 }
606
607
608
609 /****************
610  * Try to get the pubkey by the userid. This function looks for the
611  * first pubkey certificate which has the given name in a user_id.
612  * if pk/sk has the pubkey algo set, the function will only return
613  * a pubkey with that algo.
614  * The caller must provide provide storage for either the pk or the sk.
615  * If ret_kb is not NULL the funtion will return the keyblock there.
616  */
617
618 static int
619 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
620             PKT_public_key *pk, PKT_secret_key *sk, KBNODE *ret_kb )
621 {
622     int rc = 0;
623     int n;
624     STRLIST r;
625     GETKEY_CTX ctx;
626
627     assert( !pk ^ !sk );
628
629     /* build the search context */
630     /* Performance hint: Use a static buffer if there is only one name */
631     /*                   and we don't have mode 6 */
632     for(n=0, r=namelist; r; r = r->next )
633         n++;
634     ctx = m_alloc_clear( sizeof *ctx + (n-1)*sizeof ctx->items );
635     ctx->nitems = n;
636
637     for(n=0, r=namelist; r; r = r->next, n++ ) {
638         ctx->items[n].mode = classify_user_id( r->d,
639                                               ctx->items[n].keyid,
640                                               ctx->items[n].fprint,
641                                               &ctx->items[n].name,
642                                               NULL );
643         if( !ctx->items[n].mode ) {
644             m_free( ctx );
645             return G10ERR_INV_USER_ID;
646         }
647         if( ctx->items[n].mode == 6 ) {
648             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
649             ctx->items[n].name = ctx->items[n].namebuf;
650         }
651     }
652
653     /* and call the lookup function */
654     ctx->primary = 1; /* we want to look for the primary key only */
655     if( sk )
656         rc = lookup_sk( ctx, sk, NULL );
657     else
658         rc = lookup_pk( ctx, pk, NULL );
659
660     if( retctx ) /* caller wants the context */
661         *retctx = ctx;
662     else {
663         for(n=0; n < ctx->nitems; n++ )
664             m_free( ctx->items[n].namebuf );
665         m_free( ctx );
666     }
667
668     return rc;
669 }
670
671 int
672 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
673                    const char *name, KBNODE *ret_keyblock )
674 {
675     int rc;
676     STRLIST namelist = NULL;
677
678     add_to_strlist( &namelist, name );
679
680     if( !pk ) {
681         /* Performance Hint: key_byname should not need a pk here */
682         pk = m_alloc_clear( sizeof *pk );
683         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
684         free_public_key( pk );
685     }
686     else
687         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
688
689     free_strlist( namelist );
690     return rc;
691 }
692
693 int
694 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
695                     STRLIST names, KBNODE *ret_keyblock )
696 {
697     int rc;
698
699     if( !pk ) {
700         /* Performance Hint: key_byname should not need a pk here */
701         pk = m_alloc_clear( sizeof *pk );
702         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
703         free_public_key( pk );
704     }
705     else
706         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
707
708     return rc;
709 }
710
711 int
712 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
713 {
714     int rc;
715
716     if( !pk ) {
717         /* Performance Hint: lookup_read should not need a pk in this case */
718         pk = m_alloc_clear( sizeof *pk );
719         rc = lookup_pk( ctx, pk, ret_keyblock );
720         free_public_key( pk );
721     }
722     else
723         rc = lookup_pk( ctx, pk, ret_keyblock );
724     return rc;
725 }
726
727 void
728 get_pubkey_end( GETKEY_CTX ctx )
729 {
730     if( ctx ) {
731         int n;
732
733         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
734         for(n=0; n < ctx->nitems; n++ )
735             m_free( ctx->items[n].namebuf );
736         m_free( ctx );
737     }
738 }
739
740 /****************
741  * Search for a key with the given fingerprint.
742  */
743 int
744 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
745 {
746     int rc;
747
748     if( fprint_len == 20 || fprint_len == 16 ) {
749         struct getkey_ctx_s ctx;
750         memset( &ctx, 0, sizeof ctx );
751         ctx.nitems = 1;
752         ctx.items[0].mode = fprint_len;
753         memcpy( ctx.items[0].fprint, fprint, fprint_len );
754         rc = lookup_pk( &ctx, pk, NULL );
755     }
756     else
757         rc = G10ERR_GENERAL; /* Oops */
758     return rc;
759 }
760
761 /****************
762  * Search for a key with the given fingerprint and return the
763  * complete keyblock which may have more than only this key.
764  */
765 int
766 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
767                                                 size_t fprint_len )
768 {
769     int rc;
770     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
771
772     if( fprint_len == 20 || fprint_len == 16 ) {
773         struct getkey_ctx_s ctx;
774         memset( &ctx, 0, sizeof ctx );
775         ctx.nitems = 1;
776         ctx.items[0].mode = fprint_len;
777         memcpy( ctx.items[0].fprint, fprint, fprint_len );
778         rc = lookup_pk( &ctx, pk, ret_keyblock );
779     }
780     else
781         rc = G10ERR_GENERAL; /* Oops */
782
783     free_public_key( pk );
784     return rc;
785 }
786
787
788
789
790
791 /****************
792  * Get a secret key by name and store it into sk
793  * If NAME is NULL use the default key
794  */
795 int
796 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
797 {
798     STRLIST namelist = NULL;
799     int rc;
800
801     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
802         add_to_strlist( &namelist, opt.def_secret_key );
803         rc = key_byname( NULL, namelist, NULL, sk, NULL );
804     }
805     else if( !name ) { /* use the first one as default key */
806         struct getkey_ctx_s ctx;
807
808         memset( &ctx, 0, sizeof ctx );
809         ctx.primary = 1;
810         ctx.nitems = 1;
811         ctx.items[0].mode = 15;
812         rc = lookup_sk( &ctx, sk, NULL );
813     }
814     else {
815         add_to_strlist( &namelist, name );
816         rc = key_byname( NULL, namelist, NULL, sk, NULL );
817     }
818
819     free_strlist( namelist );
820
821     if( !rc && unprotect )
822         rc = check_secret_key( sk, 0 );
823
824     return rc;
825 }
826
827 int
828 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
829                     STRLIST names, KBNODE *ret_keyblock )
830 {
831     int rc;
832
833     if( !sk ) {
834         /* Performance Hint: key_byname should not need a sk here */
835         sk = m_alloc_secure_clear( sizeof *sk );
836         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
837         free_secret_key( sk );
838     }
839     else
840         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
841
842     return rc;
843 }
844
845
846 int
847 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
848 {
849     int rc;
850
851     if( !sk ) {
852         /* Performance Hint: lookup_read should not need a pk in this case */
853         sk = m_alloc_secure_clear( sizeof *sk );
854         rc = lookup_sk( ctx, sk, ret_keyblock );
855         free_secret_key( sk );
856     }
857     else
858         rc = lookup_sk( ctx, sk, ret_keyblock );
859     return rc;
860 }
861
862 void
863 get_seckey_end( GETKEY_CTX ctx )
864 {
865     if( ctx ) {
866         int n;
867
868         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
869         for(n=0; n < ctx->nitems; n++ )
870             m_free( ctx->items[n].namebuf );
871         m_free( ctx );
872     }
873 }
874
875
876
877 /****************
878  * Do a word match (original user id starts with a '+').
879  * The pattern is already tokenized to a more suitable format:
880  * There are only the real words in it delimited by one space
881  * and all converted to uppercase.
882  *
883  * Returns: 0 if all words match.
884  *
885  * Note: This algorithm is a straightforward one and not very
886  *       fast.  It works for UTF-8 strings.  The uidlen should
887  *       be removed but due to the fact that old versions of
888  *       pgp don't use UTF-8 we still use the length; this should
889  *       be fixed in parse-packet (and replace \0 by some special
890  *       UTF-8 encoding)
891  */
892 static int
893 word_match( const byte *uid, size_t uidlen, const byte *pattern )
894 {
895     size_t wlen, n;
896     const byte *p;
897     const byte *s;
898
899     for( s=pattern; *s; ) {
900         do {
901             /* skip leading delimiters */
902             while( uidlen && !word_match_chars[*uid] )
903                 uid++, uidlen--;
904             /* get length of the word */
905             n = uidlen; p = uid;
906             while( n && word_match_chars[*p] )
907                 p++, n--;
908             wlen = p - uid;
909             /* and compare against the current word from pattern */
910             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
911                 if( word_match_chars[*p] != s[n] )
912                     break;
913             }
914             if( n == wlen && (s[n] == ' ' || !s[n]) )
915                 break; /* found */
916             uid += wlen;
917             uidlen -= wlen;
918         } while( uidlen );
919         if( !uidlen )
920             return -1; /* not found */
921
922         /* advance to next word in pattern */
923         for(; *s != ' ' && *s ; s++ )
924             ;
925         if( *s )
926             s++ ;
927     }
928     return 0; /* found */
929 }
930
931 /****************
932  * prepare word word_match; that is parse the name and
933  * build the pattern.
934  * caller has to free the returned pattern
935  */
936 static char*
937 prepare_word_match( const byte *name )
938 {
939     byte *pattern, *p;
940     int c;
941
942     /* the original length is always enough for the pattern */
943     p = pattern = m_alloc(strlen(name)+1);
944     do {
945         /* skip leading delimiters */
946         while( *name && !word_match_chars[*name] )
947             name++;
948         /* copy as long as we don't have a delimiter and convert
949          * to uppercase.
950          * fixme: how can we handle utf8 uppercasing */
951         for( ; *name &&  (c=word_match_chars[*name]); name++ )
952             *p++ = c;
953         *p++ = ' '; /* append pattern delimiter */
954     } while( *name );
955     p[-1] = 0; /* replace last pattern delimiter by EOS */
956
957     return pattern;
958 }
959
960
961
962
963
964 static int
965 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
966 {
967     int i;
968     const char *s, *se;
969
970     if( mode == 1 ) {  /* exact match */
971         for(i=0; name[i] && uidlen; i++, uidlen-- )
972             if( uid[i] != name[i] )
973                 break;
974         if( !uidlen && !name[i] )
975             return 0; /* found */
976     }
977     else if( mode == 2 ) { /* case insensitive substring */
978         if( memistr( uid, uidlen, name ) )
979             return 0;
980     }
981     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
982         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
983             ;
984         if( i < uidlen )  {
985             /* skip opening delim and one char and look for the closing one*/
986             s++; i++;
987             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
988                 ;
989             if( i < uidlen ) {
990                 i = se - s;
991                 if( mode == 3 ) { /* exact email address */
992                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
993                         return 0;
994                 }
995                 else if( mode == 4 ) {  /* email substring */
996                     if( memistr( s, i, name ) )
997                         return 0;
998                 }
999                 else { /* email from end */
1000                     /* nyi */
1001                 }
1002             }
1003         }
1004     }
1005     else if( mode == 6 )
1006         return word_match( uid, uidlen, name );
1007     else
1008         BUG();
1009
1010     return -1; /* not found */
1011 }
1012
1013
1014
1015 /****************
1016  * Assume that knode points to a public key packet  and keyblock is
1017  * the entire keyblock.  This function adds all relevant information from
1018  * a selfsignature to the public key.
1019  */
1020
1021 static void
1022 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode,
1023                           PKT_public_key *orig_pk )
1024 {
1025     PKT_public_key *pk = knode->pkt->pkt.public_key;
1026     PKT_signature *sig;
1027     KBNODE k;
1028     u32 kid[2];
1029     u32 sigdate = 0;
1030
1031     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
1032             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1033
1034     if( pk->version < 4 )
1035         return; /* this is only needed for version >=4 packets */
1036
1037
1038     /* find the selfsignature */
1039     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1040         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1041         if( !k )
1042            BUG(); /* keyblock without primary key!!! */
1043         keyid_from_pk( knode->pkt->pkt.public_key, kid );
1044     }
1045     else
1046         keyid_from_pk( pk, kid );
1047
1048     for(k=knode->next; k; k = k->next ) {
1049         if( k->pkt->pkttype == PKT_SIGNATURE
1050             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1051             && sig->sig_class <= 0x30
1052             && sig->keyid[0] == kid[0]
1053             && sig->keyid[1] == kid[1]
1054             && sig->version > 3 ) {
1055             /* okay this is a self-signature which can be used.
1056              * We use the latest self-signature.
1057              * FIXME: We should only use this if the signature is valid
1058              *        but this is time consuming - we must provide another
1059              *        way to handle this
1060              */
1061             const byte *p;
1062             u32 ed;
1063
1064             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1065             ed = p? pk->timestamp + buffer_to_u32(p):0;
1066             /* use the latest self signature */
1067             if( sig->timestamp > sigdate ) {
1068                 pk->expiredate = ed;
1069                 orig_pk->expiredate = ed;
1070                 sigdate = sig->timestamp;
1071             }
1072             /* fixme: add usage etc. to pk */
1073         }
1074         else if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1075             break; /* stop here */
1076     }
1077 }
1078
1079
1080 /****************
1081  * merge all selfsignatures with the keys.
1082  */
1083 void
1084 merge_keys_and_selfsig( KBNODE keyblock )
1085 {
1086     PKT_public_key *pk = NULL;
1087     PKT_secret_key *sk = NULL;
1088     PKT_signature *sig;
1089     KBNODE k;
1090     u32 kid[2] = { 0, 0 };
1091     u32 sigdate = 0;
1092
1093     for(k=keyblock; k; k = k->next ) {
1094         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1095             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1096             pk = k->pkt->pkt.public_key; sk = NULL;
1097             if( pk->version < 4 )
1098                 pk = NULL; /* not needed for old keys */
1099             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1100                 keyid_from_pk( pk, kid );
1101             sigdate = 0;
1102         }
1103         else if( k->pkt->pkttype == PKT_SECRET_KEY
1104             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1105             pk = NULL; sk = k->pkt->pkt.secret_key;
1106             if( sk->version < 4 )
1107                 sk = NULL;
1108             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1109                 keyid_from_sk( sk, kid );
1110             sigdate = 0;
1111         }
1112         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1113                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1114                  && sig->sig_class <= 0x30 && sig->version > 3
1115                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1116             /* okay this is a self-signature which can be used.
1117              * FIXME: We should only use this if the signature is valid
1118              *        but this is time consuming - we must provide another
1119              *        way to handle this
1120              */
1121             const byte *p;
1122             u32 ed;
1123
1124             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1125             if( pk ) {
1126                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1127                 if( sig->timestamp > sigdate ) {
1128                     pk->expiredate = ed;
1129                     sigdate = sig->timestamp;
1130                 }
1131             }
1132             else {
1133                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1134                 if( sig->timestamp > sigdate ) {
1135                     sk->expiredate = ed;
1136                     sigdate = sig->timestamp;
1137                 }
1138             }
1139         }
1140     }
1141 }
1142
1143
1144 static KBNODE
1145 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
1146               int mode, byte *namehash, int *use_namehash )
1147 {
1148     KBNODE k, kk;
1149
1150     for(k=keyblock; k; k = k->next ) {
1151         if( k->pkt->pkttype == PKT_USER_ID
1152             && !compare_name( k->pkt->pkt.user_id->name,
1153                               k->pkt->pkt.user_id->len, name, mode)) {
1154             /* we found a matching name, look for the key */
1155             for(kk=keyblock; kk; kk = kk->next ) {
1156                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
1157                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1158                     && ( !pk->pubkey_algo
1159                          || pk->pubkey_algo
1160                             == kk->pkt->pkt.public_key->pubkey_algo)
1161                     && ( !pk->pubkey_usage
1162                          || !check_pubkey_algo2(
1163                                kk->pkt->pkt.public_key->pubkey_algo,
1164                                                    pk->pubkey_usage ))
1165                   )
1166                     break;
1167             }
1168             if( kk ) {
1169                 u32 aki[2];
1170                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
1171                 cache_user_id( k->pkt->pkt.user_id, aki );
1172                 rmd160_hash_buffer( namehash,
1173                                     k->pkt->pkt.user_id->name,
1174                                     k->pkt->pkt.user_id->len );
1175                 *use_namehash = 1;
1176                 return kk;
1177             }
1178             else if( is_RSA(pk->pubkey_algo) )
1179                 log_error("RSA key cannot be used in this version\n");
1180             else
1181                 log_error("No key for userid\n");
1182         }
1183     }
1184     return NULL;
1185 }
1186
1187 static KBNODE
1188 find_by_name_sk( KBNODE keyblock, PKT_secret_key *sk, const char *name,
1189                  int mode )
1190 {
1191     KBNODE k, kk;
1192
1193     for(k=keyblock; k; k = k->next ) {
1194         if( k->pkt->pkttype == PKT_USER_ID
1195             && !compare_name( k->pkt->pkt.user_id->name,
1196                               k->pkt->pkt.user_id->len, name, mode)) {
1197             /* we found a matching name, look for the key */
1198             for(kk=keyblock; kk; kk = kk->next ) {
1199                 if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1200                       || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1201                     && ( !sk->pubkey_algo
1202                          || sk->pubkey_algo
1203                             == kk->pkt->pkt.secret_key->pubkey_algo)
1204                     && ( !sk->pubkey_usage
1205                          || !check_pubkey_algo2(
1206                                kk->pkt->pkt.secret_key->pubkey_algo,
1207                                                    sk->pubkey_usage ))
1208                   )
1209                     break;
1210             }
1211             if( kk ) {
1212                 u32 aki[2];
1213                 keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1214                 cache_user_id( k->pkt->pkt.user_id, aki );
1215                 return kk;
1216             }
1217             else if( is_RSA(sk->pubkey_algo) )
1218                 log_error("RSA key cannot be used in this version\n");
1219             else
1220                 log_error("No key for userid\n");
1221         }
1222     }
1223     return NULL;
1224 }
1225
1226
1227 static KBNODE
1228 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
1229 {
1230     KBNODE k;
1231
1232     if( DBG_CACHE )
1233         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
1234                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
1235
1236     for(k=keyblock; k; k = k->next ) {
1237         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1238             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1239             u32 aki[2];
1240             keyid_from_pk( k->pkt->pkt.public_key, aki );
1241             if( DBG_CACHE )
1242                 log_debug("         aki=%08lx%08lx algo=%d\n",
1243                                 (ulong)aki[0], (ulong)aki[1],
1244                                  k->pkt->pkt.public_key->pubkey_algo    );
1245
1246             if( aki[1] == keyid[1]
1247                 && ( mode == 10 || aki[0] == keyid[0] )
1248                 && ( !pk->pubkey_algo
1249                      || pk->pubkey_algo
1250                         == k->pkt->pkt.public_key->pubkey_algo) ){
1251                 KBNODE kk;
1252                 /* cache the userid */
1253                 for(kk=keyblock; kk; kk = kk->next )
1254                     if( kk->pkt->pkttype == PKT_USER_ID )
1255                         break;
1256                 if( kk )
1257                     cache_user_id( kk->pkt->pkt.user_id, aki );
1258                 else
1259                     log_error("No userid for key\n");
1260                 return k; /* found */
1261             }
1262         }
1263     }
1264     return NULL;
1265 }
1266
1267 static KBNODE
1268 find_by_keyid_sk( KBNODE keyblock, PKT_secret_key *sk, u32 *keyid, int mode )
1269 {
1270     KBNODE k;
1271
1272     if( DBG_CACHE )
1273         log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1274                    (ulong)keyid[0], (ulong)keyid[1], sk->pubkey_algo, mode );
1275
1276     for(k=keyblock; k; k = k->next ) {
1277         if(    k->pkt->pkttype == PKT_SECRET_KEY
1278             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1279             u32 aki[2];
1280             keyid_from_sk( k->pkt->pkt.secret_key, aki );
1281             if( DBG_CACHE )
1282                 log_debug("         aki=%08lx%08lx algo=%d\n",
1283                                 (ulong)aki[0], (ulong)aki[1],
1284                                  k->pkt->pkt.secret_key->pubkey_algo    );
1285
1286             if( aki[1] == keyid[1]
1287                 && ( mode == 10 || aki[0] == keyid[0] )
1288                 && ( !sk->pubkey_algo
1289                      || sk->pubkey_algo
1290                         == k->pkt->pkt.secret_key->pubkey_algo) ){
1291                 KBNODE kk;
1292                 /* cache the userid */
1293                 for(kk=keyblock; kk; kk = kk->next )
1294                     if( kk->pkt->pkttype == PKT_USER_ID )
1295                         break;
1296                 if( kk )
1297                     cache_user_id( kk->pkt->pkt.user_id, aki );
1298                 else
1299                     log_error("No userid for key\n");
1300                 return k; /* found */
1301             }
1302         }
1303     }
1304     return NULL;
1305 }
1306
1307
1308 static KBNODE
1309 find_first( KBNODE keyblock, PKT_public_key *pk )
1310 {
1311     KBNODE k;
1312
1313     for(k=keyblock; k; k = k->next ) {
1314         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1315             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1316         {
1317             if( !pk->pubkey_algo
1318                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
1319                 return k;
1320         }
1321     }
1322     return NULL;
1323 }
1324
1325 static KBNODE
1326 find_first_sk( KBNODE keyblock, PKT_secret_key *sk )
1327 {
1328     KBNODE k;
1329
1330     for(k=keyblock; k; k = k->next ) {
1331         if(    k->pkt->pkttype == PKT_SECRET_KEY
1332             || k->pkt->pkttype == PKT_SECRET_SUBKEY )
1333         {
1334             if( !sk->pubkey_algo
1335                 || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo )
1336                 return k;
1337         }
1338     }
1339     return NULL;
1340 }
1341
1342
1343 static KBNODE
1344 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
1345 {
1346     KBNODE k;
1347
1348     for(k=keyblock; k; k = k->next ) {
1349         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1350             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1351             byte afp[MAX_FINGERPRINT_LEN];
1352             size_t an;
1353
1354             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1355
1356             if( DBG_CACHE ) {
1357                 u32 aki[2];
1358                 keyid_from_pk( k->pkt->pkt.public_key, aki );
1359                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1360                                 (ulong)aki[0], (ulong)aki[1],
1361                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
1362             }
1363
1364             if( an == mode
1365                 && !memcmp( afp, name, an)
1366                 && ( !pk->pubkey_algo
1367                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
1368                 return k;
1369         }
1370     }
1371     return NULL;
1372 }
1373
1374 static KBNODE
1375 find_by_fpr_sk( KBNODE keyblock, PKT_secret_key *sk,
1376                                  const char *name, int mode )
1377 {
1378     KBNODE k;
1379
1380     for(k=keyblock; k; k = k->next ) {
1381         if(    k->pkt->pkttype == PKT_SECRET_KEY
1382             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1383             byte afp[MAX_FINGERPRINT_LEN];
1384             size_t an;
1385
1386             fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1387
1388             if( DBG_CACHE ) {
1389                 u32 aki[2];
1390                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
1391                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1392                                 (ulong)aki[0], (ulong)aki[1],
1393                         k->pkt->pkt.secret_key->pubkey_algo, mode, an );
1394             }
1395
1396             if( an == mode
1397                 && !memcmp( afp, name, an)
1398                 && ( !sk->pubkey_algo
1399                      || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo) )
1400                 return k;
1401         }
1402     }
1403     return NULL;
1404 }
1405
1406
1407 static void
1408 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
1409                                                int use_namehash, int primary )
1410 {
1411     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
1412             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1413     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1414     if( primary && !pk->pubkey_usage ) {
1415         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
1416                                       use_namehash? namehash:NULL);
1417         merge_one_pk_and_selfsig( keyblock, keyblock, pk );
1418     }
1419     else {
1420         if( primary && pk->pubkey_usage
1421             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
1422                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1423             /* if the usage is not correct, try to use a subkey */
1424             KBNODE save_k = k;
1425
1426             k = NULL;
1427             /* kludge for pgp 5: which doesn't accept type 20:
1428              * try to use a type 16 subkey instead */
1429             if( pk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1430                 for( k = save_k; k; k = k->next ) {
1431                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1432                         && k->pkt->pkt.public_key->pubkey_algo
1433                             == PUBKEY_ALGO_ELGAMAL_E
1434                         && !check_pubkey_algo2(
1435                                 k->pkt->pkt.public_key->pubkey_algo,
1436                                                  pk->pubkey_usage ) )
1437                         break;
1438                 }
1439             }
1440
1441             if( !k ) {
1442                 for(k = save_k ; k; k = k->next ) {
1443                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1444                         && !check_pubkey_algo2(
1445                                 k->pkt->pkt.public_key->pubkey_algo,
1446                                                  pk->pubkey_usage ) )
1447                         break;
1448                 }
1449             }
1450             if( !k )
1451                 k = save_k;
1452             else
1453                 log_info(_("using secondary key %08lX "
1454                            "instead of primary key %08lX\n"),
1455                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
1456                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
1457                         );
1458         }
1459
1460         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
1461                                       use_namehash? namehash:NULL);
1462         merge_one_pk_and_selfsig( keyblock, k, pk );
1463     }
1464 }
1465
1466 static void
1467 finish_lookup_sk( KBNODE keyblock, PKT_secret_key *sk, KBNODE k, int primary )
1468 {
1469     assert(    k->pkt->pkttype == PKT_SECRET_KEY
1470             || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1471     assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1472     if( primary && !sk->pubkey_usage ) {
1473         copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1474     }
1475     else {
1476         if( primary && sk->pubkey_usage
1477             && check_pubkey_algo2( k->pkt->pkt.secret_key->pubkey_algo,
1478                        sk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1479             /* if the usage is not correct, try to use a subkey */
1480             KBNODE save_k = k;
1481
1482             k = NULL;
1483             /* kludge for pgp 5: which doesn't accept type 20:
1484              * try to use a type 16 subkey instead */
1485             if( sk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1486                 for( k = save_k; k; k = k->next ) {
1487                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1488                         && k->pkt->pkt.secret_key->pubkey_algo
1489                             == PUBKEY_ALGO_ELGAMAL_E
1490                         && !check_pubkey_algo2(
1491                                 k->pkt->pkt.secret_key->pubkey_algo,
1492                                                  sk->pubkey_usage ) )
1493                         break;
1494                 }
1495             }
1496
1497             if( !k ) {
1498                 for(k = save_k ; k; k = k->next ) {
1499                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1500                         && !check_pubkey_algo2(
1501                                 k->pkt->pkt.secret_key->pubkey_algo,
1502                                                  sk->pubkey_usage ) )
1503                         break;
1504                 }
1505             }
1506             if( !k )
1507                 k = save_k;
1508             else
1509                 log_info(_("using secondary key %08lX "
1510                            "instead of primary key %08lX\n"),
1511                       (ulong)keyid_from_sk( k->pkt->pkt.secret_key, NULL),
1512                       (ulong)keyid_from_sk( save_k->pkt->pkt.secret_key, NULL)
1513                         );
1514         }
1515
1516         copy_secret_key( sk, k->pkt->pkt.secret_key );
1517     }
1518 }
1519
1520
1521 /****** old code from lookup_read ******/
1522 #if 0 /* can't use it anymore - invent a more general approach */
1523     /* try the quick functions */
1524     if( !ctx->count ) {
1525         k = NULL;
1526         switch( ctx->mode ) {
1527           case 10:
1528           case 11:
1529             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1530                                                         ctx->mode==10, 0 );
1531             if( !rc )
1532                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1533             if( !rc )
1534                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1535             break;
1536
1537           case 16:
1538           case 20:
1539             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1540             if( !rc )
1541                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1542             if( !rc )
1543                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1544             break;
1545
1546           default: rc = G10ERR_UNSUPPORTED;
1547         }
1548         if( !rc ) {
1549             if( !k ) {
1550                 log_error("lookup: key has been located but was not found\n");
1551                 rc = G10ERR_INV_KEYRING;
1552             }
1553             else
1554                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1555         }
1556     }
1557     else
1558         rc = G10ERR_UNSUPPORTED;
1559
1560     /* if this was not possible, loop over all keyblocks
1561      * fixme: If one of the resources in the quick functions above
1562      *        works, but the key was not found, we will not find it
1563      *        in the other resources */
1564     if( rc == G10ERR_UNSUPPORTED ) {
1565     }
1566 #endif
1567
1568
1569 static int
1570 lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1571 {
1572     int rc;
1573     KBNODE k;
1574     int oldmode = set_packet_list_mode(0);
1575     byte namehash[20];
1576     int use_namehash=0;
1577
1578     if( !ctx->count ) /* first time */
1579         rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1580     else
1581         rc = 0;
1582     if( !rc ) {
1583         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1584             int n;
1585             getkey_item_t *item;
1586             /* fixme: we don't enum the complete keyblock, but
1587              * use the first match and then continue with the next keyblock
1588              */
1589             /* loop over all the user ids we want to look for */
1590             item = ctx->items;
1591             for(n=0; n < ctx->nitems; n++, item++ ) {
1592                 if( item->mode < 10 )
1593                     k = find_by_name( ctx->keyblock, pk,
1594                                       item->name, item->mode,
1595                                       namehash, &use_namehash );
1596                 else if( item->mode == 10 || item->mode == 11 )
1597                     k = find_by_keyid( ctx->keyblock, pk,
1598                                        item->keyid, item->mode );
1599                 else if( item->mode == 15 )
1600                     k = find_first( ctx->keyblock, pk );
1601                 else if( item->mode == 16 || item->mode == 20 )
1602                     k = find_by_fpr( ctx->keyblock, pk,
1603                                      item->name, item->mode );
1604                 else
1605                     BUG();
1606                 if( k ) {
1607                     finish_lookup( ctx->keyblock, pk, k, namehash,
1608                                                  use_namehash, ctx->primary );
1609                     goto found;
1610                 }
1611             }
1612             release_kbnode( ctx->keyblock );
1613             ctx->keyblock = NULL;
1614         }
1615       found: ;
1616     }
1617     if( rc && rc != -1 )
1618         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1619
1620     if( !rc ) {
1621         if( ret_keyblock ) {
1622             *ret_keyblock = ctx->keyblock;
1623             ctx->keyblock = NULL;
1624         }
1625     }
1626     else if( rc == -1 )
1627         rc = G10ERR_NO_PUBKEY;
1628
1629     release_kbnode( ctx->keyblock );
1630     ctx->keyblock = NULL;
1631     set_packet_list_mode(oldmode);
1632   #if 0
1633     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1634         static int initialized;
1635
1636         if( !initialized ) {
1637             initialized = 1;
1638             atexit( print_stats );
1639         }
1640
1641         assert( ctx->mode < DIM(lkup_stats) );
1642         lkup_stats[ctx->mode].any = 1;
1643         if( !rc )
1644             lkup_stats[ctx->mode].okay_count++;
1645         else if ( rc == G10ERR_NO_PUBKEY )
1646             lkup_stats[ctx->mode].nokey_count++;
1647         else
1648             lkup_stats[ctx->mode].error_count++;
1649     }
1650    #endif
1651
1652     ctx->last_rc = rc;
1653     ctx->count++;
1654     return rc;
1655 }
1656
1657
1658
1659 static int
1660 lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1661 {
1662     int rc;
1663     KBNODE k;
1664     int oldmode = set_packet_list_mode(0);
1665
1666     if( !ctx->count ) /* first time */
1667         rc = enum_keyblocks( 5, &ctx->kbpos, &ctx->keyblock );
1668     else
1669         rc = 0;
1670     if( !rc ) {
1671         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1672             int n;
1673             getkey_item_t *item;
1674             /* fixme: we don't enum the complete keyblock, but
1675              * use the first match and then continue with the next keyblock
1676              */
1677             /* loop over all the user ids we want to look for */
1678             item = ctx->items;
1679             for(n=0; n < ctx->nitems; n++, item++ ) {
1680                 if( item->mode < 10 )
1681                     k = find_by_name_sk( ctx->keyblock, sk,
1682                                          item->name, item->mode );
1683                 else if( item->mode == 10 || item->mode == 11 )
1684                     k = find_by_keyid_sk( ctx->keyblock, sk,
1685                                           item->keyid, item->mode );
1686                 else if( item->mode == 15 )
1687                     k = find_first_sk( ctx->keyblock, sk );
1688                 else if( item->mode == 16 || item->mode == 20 )
1689                     k = find_by_fpr_sk( ctx->keyblock, sk,
1690                                         item->name, item->mode );
1691                 else
1692                     BUG();
1693                 if( k ) {
1694                     finish_lookup_sk( ctx->keyblock, sk, k, ctx->primary );
1695                     goto found;
1696                 }
1697             }
1698             release_kbnode( ctx->keyblock );
1699             ctx->keyblock = NULL;
1700         }
1701       found: ;
1702     }
1703     if( rc && rc != -1 )
1704         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1705
1706     if( !rc ) {
1707         if( ret_keyblock ) {
1708             *ret_keyblock = ctx->keyblock;
1709             ctx->keyblock = NULL;
1710         }
1711     }
1712     else if( rc == -1 )
1713         rc = G10ERR_NO_PUBKEY;
1714
1715     release_kbnode( ctx->keyblock );
1716     ctx->keyblock = NULL;
1717     set_packet_list_mode(oldmode);
1718
1719     ctx->last_rc = rc;
1720     ctx->count++;
1721     return rc;
1722 }
1723
1724
1725 #if 0
1726 OLD/************
1727 OLD * Ditto for secret keys WORK!!!!!!
1728 OLD */
1729 OLDstatic int
1730 OLDlookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1731 OLD           int primary )
1732 OLD{
1733 OLD    int rc;
1734 OLD    KBNODE keyblock = NULL;
1735 OLD    KBPOS kbpos;
1736 OLD    int oldmode = set_packet_list_mode(0);
1737 OLD
1738 OLD    rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1739 OLD    if( rc ) {
1740 OLD        if( rc == -1 )
1741 OLD            rc = G10ERR_NO_SECKEY;
1742 OLD        else if( rc )
1743 OLD            log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1744 OLD        goto leave;
1745 OLD    }
1746 OLD
1747 OLD    while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1748 OLD        KBNODE k, kk;
1749 OLD        if( mode < 10 ) { /* name lookup */
1750 OLD            for(k=keyblock; k; k = k->next ) {
1751 OLD                if( k->pkt->pkttype == PKT_USER_ID
1752 OLD                    && !compare_name( k->pkt->pkt.user_id->name,
1753 OLD                                      k->pkt->pkt.user_id->len, name, mode)) {
1754 OLD                    /* we found a matching name, look for the key */
1755 OLD                    for(kk=keyblock; kk; kk = kk->next ) {
1756 OLD                        if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1757 OLD                              || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1758 OLD                            && ( !sk->pubkey_algo
1759 OLD                                 || sk->pubkey_algo
1760 OLD                                    == kk->pkt->pkt.secret_key->pubkey_algo)
1761 OLD                            && ( !sk->pubkey_usage
1762 OLD                                 || !check_pubkey_algo2(
1763 OLD                                       kk->pkt->pkt.secret_key->pubkey_algo,
1764 OLD                                                           sk->pubkey_usage ))
1765 OLD                          )
1766 OLD                            break;
1767 OLD                    }
1768 OLD                    if( kk ) {
1769 OLD                        u32 aki[2];
1770 OLD                        keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1771 OLD                        cache_user_id( k->pkt->pkt.user_id, aki );
1772 OLD                        k = kk;
1773 OLD                        break;
1774 OLD                    }
1775 OLD                    else
1776 OLD                        log_error("No key for userid (in sk)\n");
1777 OLD                }
1778 OLD            }
1779 OLD        }
1780 OLD        else { /* keyid or fingerprint lookup */
1781 OLD            if( DBG_CACHE && (mode== 10 || mode==11) ) {
1782 OLD                log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1783 OLD                                (ulong)keyid[0], (ulong)keyid[1],
1784 OLD                                 sk->pubkey_algo, mode );
1785 OLD            }
1786 OLD            for(k=keyblock; k; k = k->next ) {
1787 OLD                if(    k->pkt->pkttype == PKT_SECRET_KEY
1788 OLD                    || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1789 OLD                    if( mode == 10 || mode == 11 ) {
1790 OLD                        u32 aki[2];
1791 OLD                        keyid_from_sk( k->pkt->pkt.secret_key, aki );
1792 OLD                        if( DBG_CACHE ) {
1793 OLD                            log_debug("             aki=%08lx%08lx algo=%d\n",
1794 OLD                                            (ulong)aki[0], (ulong)aki[1],
1795 OLD                                    k->pkt->pkt.secret_key->pubkey_algo    );
1796 OLD                        }
1797 OLD                        if( aki[1] == keyid[1]
1798 OLD                            && ( mode == 10 || aki[0] == keyid[0] )
1799 OLD                            && ( !sk->pubkey_algo
1800 OLD                                 || sk->pubkey_algo
1801 OLD                                    == k->pkt->pkt.secret_key->pubkey_algo) ){
1802 OLD                            /* cache the userid */
1803 OLD                            for(kk=keyblock; kk; kk = kk->next )
1804 OLD                                if( kk->pkt->pkttype == PKT_USER_ID )
1805 OLD                                    break;
1806 OLD                            if( kk )
1807 OLD                                cache_user_id( kk->pkt->pkt.user_id, aki );
1808 OLD                            else
1809 OLD                                log_error("No userid for key\n");
1810 OLD                            break; /* found */
1811 OLD                        }
1812 OLD                    }
1813 OLD                    else if( mode == 15 ) { /* get the first key */
1814 OLD                        if( !sk->pubkey_algo
1815 OLD                            || sk->pubkey_algo
1816 OLD                                  == k->pkt->pkt.secret_key->pubkey_algo )
1817 OLD                            break;
1818 OLD                    }
1819 OLD                    else if( mode == 16 || mode == 20 ) {
1820 OLD                        size_t an;
1821 OLD                        byte afp[MAX_FINGERPRINT_LEN];
1822 OLD
1823 OLD                        fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1824 OLD                        if( an == mode && !memcmp( afp, name, an)
1825 OLD                            && ( !sk->pubkey_algo
1826 OLD                                 || sk->pubkey_algo
1827 OLD                                    == k->pkt->pkt.secret_key->pubkey_algo) ) {
1828 OLD                            break;
1829 OLD                        }
1830 OLD                    }
1831 OLD                    else
1832 OLD                        BUG();
1833 OLD                } /* end compare secret keys */
1834 OLD            }
1835 OLD        }
1836 OLD        if( k ) { /* found */
1837 OLD            assert(    k->pkt->pkttype == PKT_SECRET_KEY
1838 OLD                    || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1839 OLD            assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1840 OLD            if( primary && !sk->pubkey_usage )
1841 OLD                copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1842 OLD            else
1843 OLD                copy_secret_key( sk, k->pkt->pkt.secret_key );
1844 OLD            break; /* enumeration */
1845 OLD        }
1846 OLD        release_kbnode( keyblock );
1847 OLD        keyblock = NULL;
1848 OLD    }
1849 OLD    if( rc == -1 )
1850 OLD        rc = G10ERR_NO_SECKEY;
1851 OLD    else if( rc )
1852 OLD        log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1853 OLD
1854 OLD  leave:
1855 OLD    enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1856 OLD    release_kbnode( keyblock );
1857 OLD    set_packet_list_mode(oldmode);
1858 OLD    return rc;
1859 OLD}
1860 #endif
1861
1862
1863 /****************
1864  * fixme: replace by the generic function
1865  *
1866  * Enumerate all primary secret keys.  Caller must use these procedure:
1867  *  1) create a void pointer and initialize it to NULL
1868  *  2) pass this void pointer by reference to this function
1869  *     and provide space for the secret key (pass a buffer for sk)
1870  *  3) call this function as long as it does not return -1
1871  *     to indicate EOF.
1872  *  4) Always call this function a last time with SK set to NULL,
1873  *     so that can free it's context.
1874  *
1875  *
1876  */
1877 int
1878 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1879 {
1880     int rc=0;
1881     PACKET pkt;
1882     int save_mode;
1883     struct {
1884         int eof;
1885         int sequence;
1886         const char *name;
1887         IOBUF iobuf;
1888     } *c = *context;
1889
1890
1891     if( !c ) { /* make a new context */
1892         c = m_alloc_clear( sizeof *c );
1893         *context = c;
1894         c->sequence = 0;
1895         c->name = enum_keyblock_resources( &c->sequence, 1 );
1896     }
1897
1898     if( !sk ) { /* free the context */
1899         if( c->iobuf )
1900             iobuf_close(c->iobuf);
1901         m_free( c );
1902         *context = NULL;
1903         return 0;
1904     }
1905
1906     if( c->eof )
1907         return -1;
1908
1909     /* FIXME: This assumes a plain keyring file */
1910     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1911         if( !c->iobuf ) {
1912             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1913                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
1914                 continue; /* try next file */
1915             }
1916         }
1917
1918         save_mode = set_packet_list_mode(0);
1919         init_packet(&pkt);
1920         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1921             if( rc )
1922                 ; /* e.g. unknown packet */
1923             else if( pkt.pkttype == PKT_SECRET_KEY
1924                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1925                 copy_secret_key( sk, pkt.pkt.secret_key );
1926                 set_packet_list_mode(save_mode);
1927                 return 0; /* found */
1928             }
1929             free_packet(&pkt);
1930         }
1931         set_packet_list_mode(save_mode);
1932         iobuf_close(c->iobuf); c->iobuf = NULL;
1933     }
1934     c->eof = 1;
1935     return -1;
1936 }
1937
1938
1939 /****************
1940  * Return a string with a printable representation of the user_id.
1941  * this string must be freed by m_free.
1942  */
1943 char*
1944 get_user_id_string( u32 *keyid )
1945 {
1946     user_id_db_t r;
1947     char *p;
1948     int pass=0;
1949     /* try it two times; second pass reads from key resources */
1950     do {
1951         for(r=user_id_db; r; r = r->next )
1952             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1953                 p = m_alloc( r->len + 10 );
1954                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1955                 return p;
1956             }
1957     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1958     p = m_alloc( 15 );
1959     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1960     return p;
1961 }
1962
1963 char*
1964 get_long_user_id_string( u32 *keyid )
1965 {
1966     user_id_db_t r;
1967     char *p;
1968     int pass=0;
1969     /* try it two times; second pass reads from key resources */
1970     do {
1971         for(r=user_id_db; r; r = r->next )
1972             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1973                 p = m_alloc( r->len + 20 );
1974                 sprintf(p, "%08lX%08lX %.*s",
1975                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
1976                 return p;
1977             }
1978     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1979     p = m_alloc( 25 );
1980     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
1981     return p;
1982 }
1983
1984 char*
1985 get_user_id( u32 *keyid, size_t *rn )
1986 {
1987     user_id_db_t r;
1988     char *p;
1989     int pass=0;
1990     /* try it two times; second pass reads from key resources */
1991     do {
1992         for(r=user_id_db; r; r = r->next )
1993             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1994                 p = m_alloc( r->len );
1995                 memcpy(p, r->name, r->len );
1996                 *rn = r->len;
1997                 return p;
1998             }
1999     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2000     p = m_alloc( 19 );
2001     memcpy(p, "[User id not found]", 19 );
2002     *rn = 19;
2003     return p;
2004 }
2005
2006