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