* keygen.c (do_add_key_flags, parse_parameter_usage)
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <ctype.h>
28
29 #include "gpg.h"
30 #include "util.h"
31 #include "packet.h"
32 #include "memory.h"
33 #include "iobuf.h"
34 #include "keydb.h"
35 #include "options.h"
36 #include "main.h"
37 #include "trustdb.h"
38 #include "i18n.h"
39
40 #define MAX_PK_CACHE_ENTRIES   200
41 #define MAX_UID_CACHE_ENTRIES  200
42
43 #if MAX_PK_CACHE_ENTRIES < 2
44 #error We need the cache for key creation
45 #endif
46
47
48 struct getkey_ctx_s {
49     int exact;
50     KBNODE keyblock;
51     KBPOS  kbpos;
52     KBNODE found_key; /* pointer into some keyblock */
53     int last_rc;
54     int req_usage;
55     int req_algo;
56     KEYDB_HANDLE kr_handle;
57     int not_allocated;
58     int nitems;
59     KEYDB_SEARCH_DESC items[1];
60 };
61
62 #if 0
63 static struct {
64     int any;
65     int okay_count;
66     int nokey_count;
67     int error_count;
68 } lkup_stats[21];
69 #endif
70
71 typedef struct keyid_list {
72     struct keyid_list *next;
73     u32 keyid[2];
74 } *keyid_list_t;
75
76
77 #if MAX_PK_CACHE_ENTRIES
78   typedef struct pk_cache_entry {
79       struct pk_cache_entry *next;
80       u32 keyid[2];
81       PKT_public_key *pk;
82   } *pk_cache_entry_t;
83   static pk_cache_entry_t pk_cache;
84   static int pk_cache_entries;   /* number of entries in pk cache */
85   static int pk_cache_disabled;
86 #endif
87
88 #if MAX_UID_CACHE_ENTRIES < 5
89 #error we really need the userid cache
90 #endif
91 typedef struct user_id_db {
92     struct user_id_db *next;
93     keyid_list_t keyids;
94     int len;
95     char name[1];
96 } *user_id_db_t;
97 static user_id_db_t user_id_db;
98 static int uid_cache_entries;   /* number of entries in uid cache */
99
100 static void merge_selfsigs( KBNODE keyblock );
101 static int lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode );
102
103 #if 0
104 static void
105 print_stats()
106 {
107     int i;
108     for(i=0; i < DIM(lkup_stats); i++ ) {
109         if( lkup_stats[i].any )
110             fprintf(stderr,
111                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
112                     i,
113                     lkup_stats[i].okay_count,
114                     lkup_stats[i].nokey_count,
115                     lkup_stats[i].error_count );
116     }
117 }
118 #endif
119
120
121 void
122 cache_public_key( PKT_public_key *pk )
123 {
124 #if MAX_PK_CACHE_ENTRIES
125     pk_cache_entry_t ce;
126     u32 keyid[2];
127
128     if( pk_cache_disabled )
129         return;
130
131     if( pk->dont_cache )
132         return;
133
134     if( is_ELGAMAL(pk->pubkey_algo)
135         || pk->pubkey_algo == PUBKEY_ALGO_DSA
136         || is_RSA(pk->pubkey_algo) ) {
137         keyid_from_pk( pk, keyid );
138     }
139     else
140         return; /* don't know how to get the keyid */
141
142     for( ce = pk_cache; ce; ce = ce->next )
143         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
144             if( DBG_CACHE )
145                 log_debug("cache_public_key: already in cache\n");
146             return;
147         }
148
149     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
150         /* fixme: use another algorithm to free some cache slots */
151         pk_cache_disabled=1;
152         if( opt.verbose > 1 )
153             log_info(_("too many entries in pk cache - disabled\n"));
154         return;
155     }
156     pk_cache_entries++;
157     ce = xmalloc ( sizeof *ce );
158     ce->next = pk_cache;
159     pk_cache = ce;
160     ce->pk = copy_public_key( NULL, pk );
161     ce->keyid[0] = keyid[0];
162     ce->keyid[1] = keyid[1];
163 #endif
164 }
165
166
167 /*
168  * Return the user ID from the given keyblock.
169  * We use the primary uid flag which has been set by the merge_selfsigs
170  * function.  The returned value is only valid as long as then given
171  * keyblock is not changed
172  */
173 static const char *
174 get_primary_uid ( KBNODE keyblock, size_t *uidlen )
175 {
176     KBNODE k;
177     const char *s;
178
179     for (k=keyblock; k; k=k->next ) {
180         if ( k->pkt->pkttype == PKT_USER_ID
181              && !k->pkt->pkt.user_id->attrib_data
182              && k->pkt->pkt.user_id->is_primary ) {
183             *uidlen = k->pkt->pkt.user_id->len;
184             return k->pkt->pkt.user_id->name;
185         }
186     } 
187     /* fixme: returning translatable constants instead of a user ID is 
188      * not good because they are probably not utf-8 encoded. */
189     s = _("[User id not found]");
190     *uidlen = strlen (s);
191     return s;
192 }
193
194
195 static void
196 release_keyid_list ( keyid_list_t k )
197 {
198     while (  k ) {
199         keyid_list_t k2 = k->next;
200         xfree (k);
201         k = k2;
202     }
203 }
204
205 /****************
206  * Store the association of keyid and userid
207  * Feed only public keys to this function.
208  */
209 static void
210 cache_user_id( KBNODE keyblock )
211 {
212     user_id_db_t r;
213     const char *uid;
214     size_t uidlen;
215     keyid_list_t keyids = NULL;
216     KBNODE k;
217
218     for (k=keyblock; k; k = k->next ) {
219         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
220              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
221             keyid_list_t a = xcalloc (1, sizeof *a );
222             /* Hmmm: For a long list of keyids it might be an advantage
223              * to append the keys */
224             keyid_from_pk( k->pkt->pkt.public_key, a->keyid );
225             /* first check for duplicates */
226             for(r=user_id_db; r; r = r->next ) {
227                 keyid_list_t b = r->keyids;
228                 for ( b = r->keyids; b; b = b->next ) {
229                     if( b->keyid[0] == a->keyid[0]
230                         && b->keyid[1] == a->keyid[1] ) {
231                         if( DBG_CACHE )
232                             log_debug("cache_user_id: already in cache\n");
233                         release_keyid_list ( keyids );
234                         xfree ( a );
235                         return;
236                     }
237                 }
238             }
239             /* now put it into the cache */
240             a->next = keyids;
241             keyids = a;
242         }
243     }
244     if ( !keyids )
245         BUG (); /* No key no fun */
246
247
248     uid = get_primary_uid ( keyblock, &uidlen );
249
250     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
251         /* fixme: use another algorithm to free some cache slots */
252         r = user_id_db;
253         user_id_db = r->next;
254         release_keyid_list ( r->keyids );
255         xfree (r);
256         uid_cache_entries--;
257     }
258     r = xmalloc ( sizeof *r + uidlen-1 );
259     r->keyids = keyids;
260     r->len = uidlen;
261     memcpy(r->name, uid, r->len);
262     r->next = user_id_db;
263     user_id_db = r;
264     uid_cache_entries++;
265 }
266
267
268 void
269 getkey_disable_caches()
270 {
271 #if MAX_PK_CACHE_ENTRIES
272     {
273         pk_cache_entry_t ce, ce2;
274
275         for( ce = pk_cache; ce; ce = ce2 ) {
276             ce2 = ce->next;
277             free_public_key( ce->pk );
278             xfree ( ce );
279         }
280         pk_cache_disabled=1;
281         pk_cache_entries = 0;
282         pk_cache = NULL;
283     }
284 #endif
285     /* fixme: disable user id cache ? */
286 }
287
288
289 static void
290 pk_from_block ( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE keyblock )
291 {
292     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
293
294     assert ( a->pkt->pkttype == PKT_PUBLIC_KEY
295              ||  a->pkt->pkttype == PKT_PUBLIC_SUBKEY );
296      
297     copy_public_key ( pk, a->pkt->pkt.public_key );
298 }
299
300 static void
301 sk_from_block ( GETKEY_CTX ctx,
302                 PKT_secret_key *sk, KBNODE keyblock )
303 {
304     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
305
306     assert ( a->pkt->pkttype == PKT_SECRET_KEY
307              ||  a->pkt->pkttype == PKT_SECRET_SUBKEY );
308      
309     copy_secret_key( sk, a->pkt->pkt.secret_key);
310 }
311
312
313 /****************
314  * Get a public key and store it into the allocated pk
315  * can be called with PK set to NULL to just read it into some
316  * internal structures.
317  */
318 int
319 get_pubkey( PKT_public_key *pk, u32 *keyid )
320 {
321     int internal = 0;
322     int rc = 0;
323
324 #if MAX_PK_CACHE_ENTRIES
325     {   /* Try to get it from the cache */
326         pk_cache_entry_t ce;
327         for( ce = pk_cache; ce; ce = ce->next ) {
328             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
329                 if( pk )
330                     copy_public_key( pk, ce->pk );
331                 return 0;
332             }
333         }
334     }
335 #endif
336     /* more init stuff */
337     if( !pk ) {
338         pk = xcalloc (1, sizeof *pk );
339         internal++;
340     }
341
342
343     /* do a lookup */
344     {   struct getkey_ctx_s ctx;
345         KBNODE kb = NULL;
346         memset( &ctx, 0, sizeof ctx );
347         ctx.exact = 1; /* use the key ID exactly as given */
348         ctx.not_allocated = 1;
349         ctx.kr_handle = keydb_new (0);
350         ctx.nitems = 1;
351         ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
352         ctx.items[0].u.kid[0] = keyid[0];
353         ctx.items[0].u.kid[1] = keyid[1];
354         ctx.req_algo  = pk->req_algo;
355         ctx.req_usage = pk->req_usage;
356         rc = lookup( &ctx, &kb, 0 );
357         if ( !rc ) {
358             pk_from_block ( &ctx, pk, kb );
359         }
360         get_pubkey_end( &ctx );
361         release_kbnode ( kb );
362     }
363     if( !rc )
364         goto leave;
365
366     rc = GPG_ERR_NO_PUBKEY;
367
368   leave:
369     if( !rc )
370         cache_public_key( pk );
371     if( internal )
372         free_public_key(pk);
373     return rc;
374 }
375
376
377 /* Get a public key and store it into the allocated pk.  This function
378    differs from get_pubkey() in that it does not do a check of the key
379    to avoid recursion.  It should be used only in very certain cases.  */
380 int
381 get_pubkey_fast (PKT_public_key *pk, u32 *keyid)
382 {
383   int rc = 0;
384   KEYDB_HANDLE hd;
385   KBNODE keyblock;
386   
387   assert (pk);
388 #if MAX_PK_CACHE_ENTRIES
389   { /* Try to get it from the cache */
390     pk_cache_entry_t ce;
391
392     for (ce = pk_cache; ce; ce = ce->next)
393       {
394         if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
395           {
396             if (pk)
397               copy_public_key (pk, ce->pk);
398             return 0;
399           }
400       }
401   }
402 #endif
403
404   hd = keydb_new (0);
405   rc = keydb_search_kid (hd, keyid);
406   if (rc == -1)
407     {
408       keydb_release (hd);
409       return GPG_ERR_NO_PUBKEY;
410     }
411   rc = keydb_get_keyblock (hd, &keyblock);
412   keydb_release (hd);
413   if (rc) 
414     {
415       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
416       return GPG_ERR_NO_PUBKEY;
417     }
418   
419   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
420            ||  keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY );
421   copy_public_key (pk, keyblock->pkt->pkt.public_key );
422   release_kbnode (keyblock);
423
424   /* Not caching key here since it won't have all of the fields
425      properly set. */
426
427   return 0;
428 }
429
430
431
432 KBNODE
433 get_pubkeyblock( u32 *keyid )
434 {
435     struct getkey_ctx_s ctx;
436     int rc = 0;
437     KBNODE keyblock = NULL;
438
439     memset( &ctx, 0, sizeof ctx );
440     /* no need to set exact here because we want the entire block */
441     ctx.not_allocated = 1;
442     ctx.kr_handle = keydb_new (0);
443     ctx.nitems = 1;
444     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
445     ctx.items[0].u.kid[0] = keyid[0];
446     ctx.items[0].u.kid[1] = keyid[1];
447     rc = lookup( &ctx, &keyblock, 0 );
448     get_pubkey_end( &ctx );
449
450     return rc ? NULL : keyblock;
451 }
452
453
454
455
456 /****************
457  * Get a secret key and store it into sk
458  */
459 int
460 get_seckey( PKT_secret_key *sk, u32 *keyid )
461 {
462     int rc;
463     struct getkey_ctx_s ctx;
464     KBNODE kb = NULL;
465
466     memset( &ctx, 0, sizeof ctx );
467     ctx.exact = 1; /* use the key ID exactly as given */
468     ctx.not_allocated = 1;
469     ctx.kr_handle = keydb_new (1);
470     ctx.nitems = 1;
471     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
472     ctx.items[0].u.kid[0] = keyid[0];
473     ctx.items[0].u.kid[1] = keyid[1];
474     ctx.req_algo  = sk->req_algo;
475     ctx.req_usage = sk->req_usage;
476     rc = lookup( &ctx, &kb, 1 );
477     if ( !rc ) {
478         sk_from_block ( &ctx, sk, kb );
479     }
480     get_seckey_end( &ctx );
481     release_kbnode ( kb );
482
483     if( !rc ) {
484         /* check the secret key (this may prompt for a passprase to
485          * unlock the secret key
486          */
487         rc = check_secret_key( sk, 0 );
488     }
489
490     return rc;
491 }
492
493
494 /****************
495  * Check whether the secret key is available.  This is just a fast
496  * check and does not tell us whether the secret key is valid.  It
497  * merely tells other whether there is some secret key.
498  * Returns: 0 := key is available
499  * GPG_ERR_NO_SECKEY := not availabe
500  */
501 int
502 seckey_available( u32 *keyid )
503 {
504     int rc;
505     KEYDB_HANDLE hd = keydb_new (1);
506
507     rc = keydb_search_kid (hd, keyid);
508     if ( rc == -1 )
509         rc = GPG_ERR_NO_SECKEY;
510     keydb_release (hd);
511     return rc;
512 }
513
514
515 /****************
516  * Return the type of the user id:
517  *
518  * Please use the constants KEYDB_SERCH_MODE_xxx
519  *  0 = Invalid user ID
520  *  1 = exact match
521  *  2 = match a substring
522  *  3 = match an email address
523  *  4 = match a substring of an email address
524  *  5 = match an email address, but compare from end
525  *  6 = word match mode
526  * 10 = it is a short KEYID (don't care about keyid[0])
527  * 11 = it is a long  KEYID
528  * 12 = it is a trustdb index (keyid is looked up)
529  * 16 = it is a 16 byte fingerprint
530  * 20 = it is a 20 byte fingerprint
531  * 21 = Unified fingerprint :fpr:pk_algo:
532  *      (We don't use pk_algo yet)
533  *
534  * Rules used:
535  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
536  *   must be in the range 0..9), this is considered a keyid; depending
537  *   on the length a short or complete one.
538  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
539  *   must be in the range 0..9), this is considered a fingerprint.
540  * - If the username starts with a left angle, we assume it is a complete
541  *   email address and look only at this part.
542  * - If the username starts with a colon we assume it is a unified 
543  *   key specfification. 
544  * - If the username starts with a '.', we assume it is the ending
545  *   part of an email address
546  * - If the username starts with an '@', we assume it is a part of an
547  *   email address
548  * - If the userid start with an '=' an exact compare is done.
549  * - If the userid starts with a '*' a case insensitive substring search is
550  *   done (This is the default).
551  * - If the userid starts with a '+' we will compare individual words
552  *   and a match requires that all the words are in the userid.
553  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
554  *   (note that you can't search for these characters). Compare
555  *   is not case sensitive.
556  */
557
558 int
559 classify_user_id( const char *name, KEYDB_SEARCH_DESC *desc )
560 {
561     const char *s;
562     int hexprefix = 0;
563     int hexlength;
564     int mode = 0;   
565     KEYDB_SEARCH_DESC dummy_desc;
566
567     if (!desc)
568         desc = &dummy_desc;
569
570     /* clear the structure so that the mode field is set to zero unless
571      * we set it to the correct value right at the end of this function */
572     memset (desc, 0, sizeof *desc);
573
574     /* skip leading spaces.  Fixme: what is with trailing spaces? */
575     for(s = name; *s && isspace(*s); s++ )
576         ;
577
578     switch (*s) {
579         case 0:    /* empty string is an error */
580             return 0;
581
582         case '.':  /* an email address, compare from end */
583             mode = KEYDB_SEARCH_MODE_MAILEND;
584             s++;
585             desc->u.name = s;
586             break;
587
588         case '<':  /* an email address */
589             mode = KEYDB_SEARCH_MODE_MAIL;
590             desc->u.name = s;
591             break;
592
593         case '@':  /* part of an email address */
594             mode = KEYDB_SEARCH_MODE_MAILSUB;
595             s++;
596             desc->u.name = s;
597             break;
598
599         case '=':  /* exact compare */
600             mode = KEYDB_SEARCH_MODE_EXACT;
601             s++;
602             desc->u.name = s;
603             break;
604
605         case '*':  /* case insensitive substring search */
606             mode = KEYDB_SEARCH_MODE_SUBSTR;
607             s++;
608             desc->u.name = s;
609             break;
610
611         case '+':  /* compare individual words */
612             mode = KEYDB_SEARCH_MODE_WORDS;
613             s++;
614             desc->u.name = s;
615             break;
616
617         case '#':  /* local user id */
618             return 0; /* This is now obsolete and van't not be used anymore*/
619         
620         case ':': /*Unified fingerprint */
621             {  
622                 const char *se, *si;
623                 int i;
624                 
625                 se = strchr( ++s,':');
626                 if ( !se )
627                     return 0;
628                 for (i=0,si=s; si < se; si++, i++ ) {
629                     if ( !strchr("01234567890abcdefABCDEF", *si ) )
630                         return 0; /* invalid digit */
631                 }
632                 if (i != 32 && i != 40)
633                     return 0; /* invalid length of fpr*/
634                 for (i=0,si=s; si < se; i++, si +=2) 
635                     desc->u.fpr[i] = hextobyte(si);
636                 for ( ; i < 20; i++)
637                     desc->u.fpr[i]= 0;
638                 s = se + 1;
639                 mode = KEYDB_SEARCH_MODE_FPR;
640             } 
641             break;
642            
643         default:
644             if (s[0] == '0' && s[1] == 'x') {
645                 hexprefix = 1;
646                 s += 2;
647             }
648
649             hexlength = strspn(s, "0123456789abcdefABCDEF");
650             if (hexlength >= 8 && s[hexlength] =='!') {
651                 desc->exact = 1;
652                 hexlength++; /* just for the following check */
653             }
654
655             /* check if a hexadecimal number is terminated by EOS or blank */
656             if (hexlength && s[hexlength] && !isspace(s[hexlength])) {
657                 if (hexprefix)      /* a "0x" prefix without correct */
658                     return 0;       /* termination is an error */
659                 else                /* The first chars looked like */
660                     hexlength = 0;  /* a hex number, but really were not. */
661             }
662
663             if (desc->exact)
664                 hexlength--;
665
666             if (hexlength == 8
667                 || (!hexprefix && hexlength == 9 && *s == '0')){
668                 /* short keyid */
669                 if (hexlength == 9)
670                     s++;
671                 desc->u.kid[0] = 0;
672                 desc->u.kid[1] = strtoul( s, NULL, 16 );
673                 mode = KEYDB_SEARCH_MODE_SHORT_KID;
674             }
675             else if (hexlength == 16
676                      || (!hexprefix && hexlength == 17 && *s == '0')) {
677                 /* complete keyid */
678                 char buf[9];
679                 if (hexlength == 17)
680                     s++;
681                 mem2str(buf, s, 9 );
682                 desc->u.kid[0] = strtoul( buf, NULL, 16 );
683                 desc->u.kid[1] = strtoul( s+8, NULL, 16 );
684                 mode = KEYDB_SEARCH_MODE_LONG_KID;
685             }
686             else if (hexlength == 32 || (!hexprefix && hexlength == 33
687                                                             && *s == '0')) {
688                 /* md5 fingerprint */
689                 int i;
690                 if (hexlength == 33)
691                     s++;
692                 memset(desc->u.fpr+16, 0, 4); 
693                 for (i=0; i < 16; i++, s+=2) {
694                     int c = hextobyte(s);
695                     if (c == -1)
696                         return 0;
697                     desc->u.fpr[i] = c;
698                 }
699                 mode = KEYDB_SEARCH_MODE_FPR16;
700             }
701             else if (hexlength == 40 || (!hexprefix && hexlength == 41
702                                                               && *s == '0')) {
703                 /* sha1/rmd160 fingerprint */
704                 int i;
705                 if (hexlength == 41)
706                     s++;
707                 for (i=0; i < 20; i++, s+=2) {
708                     int c = hextobyte(s);
709                     if (c == -1)
710                         return 0;
711                     desc->u.fpr[i] = c;
712                 }
713                 mode = KEYDB_SEARCH_MODE_FPR20;
714             }
715             else {
716                 if (hexprefix)  /* This was a hex number with a prefix */
717                     return 0;   /* and a wrong length */
718
719                 desc->exact = 0;
720                 desc->u.name = s;
721                 mode = KEYDB_SEARCH_MODE_SUBSTR;   /* default mode */
722             }
723     }
724
725     desc->mode = mode;
726     return mode;
727 }
728
729
730 static int
731 skip_disabled(void *dummy,u32 *keyid)
732 {
733   int rc,disabled=0;
734   PKT_public_key *pk=xcalloc (1,sizeof(PKT_public_key));
735
736   rc = get_pubkey(pk, keyid);
737   if(rc)
738     {
739       log_error("error checking disabled status of %08lX: %s\n",
740                 (ulong)keyid[1],gpg_strerror (rc));
741       goto leave;
742     }
743  
744   disabled=pk_is_disabled(pk);
745
746  leave:
747   free_public_key(pk);
748   return disabled;
749 }
750
751 /****************
752  * Try to get the pubkey by the userid. This function looks for the
753  * first pubkey certificate which has the given name in a user_id.
754  * if pk/sk has the pubkey algo set, the function will only return
755  * a pubkey with that algo.
756  * The caller should provide storage for either the pk or the sk.
757  * If ret_kb is not NULL the function will return the keyblock there.
758  */
759
760 static int
761 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
762             PKT_public_key *pk, PKT_secret_key *sk,
763             int secmode, int include_disabled,
764             KBNODE *ret_kb, KEYDB_HANDLE *ret_kdbhd )
765 {
766     int rc = 0;
767     int n;
768     STRLIST r;
769     GETKEY_CTX ctx;
770     KBNODE help_kb = NULL;
771     
772     if( retctx ) {/* reset the returned context in case of error */
773         assert (!ret_kdbhd);  /* not allowed because the handle is
774                                  stored in the context */
775         *retctx = NULL;
776     }
777     if (ret_kdbhd)
778         *ret_kdbhd = NULL;
779
780     /* build the search context */
781     for(n=0, r=namelist; r; r = r->next )
782         n++;
783     ctx = xcalloc (1,sizeof *ctx + (n-1)*sizeof ctx->items );
784     ctx->nitems = n;
785
786     for(n=0, r=namelist; r; r = r->next, n++ ) {
787         classify_user_id (r->d, &ctx->items[n]);
788         
789         if (ctx->items[n].exact)
790             ctx->exact = 1;
791         if (!ctx->items[n].mode) {
792             xfree (ctx);
793             return GPG_ERR_INV_USER_ID;
794         }
795         if(!include_disabled
796            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_SHORT_KID
797            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_LONG_KID
798            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR16
799            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR20
800            && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR)
801           ctx->items[n].skipfnc=skip_disabled;
802     }
803
804     ctx->kr_handle = keydb_new (secmode);
805     if ( !ret_kb ) 
806         ret_kb = &help_kb;
807
808     if( secmode ) {
809         if (sk) {
810             ctx->req_algo  = sk->req_algo;
811             ctx->req_usage = sk->req_usage;
812         }
813         rc = lookup( ctx, ret_kb, 1 );
814         if ( !rc && sk ) {
815             sk_from_block ( ctx, sk, *ret_kb );
816         }
817     }
818     else {
819         if (pk) {
820             ctx->req_algo  = pk->req_algo;
821             ctx->req_usage = pk->req_usage;
822         }
823         rc = lookup( ctx, ret_kb, 0 );
824         if ( !rc && pk ) {
825             pk_from_block ( ctx, pk, *ret_kb );
826         }
827     }
828
829     release_kbnode ( help_kb );
830
831     if (retctx) /* caller wants the context */
832         *retctx = ctx;
833     else {
834         if (ret_kdbhd) {
835             *ret_kdbhd = ctx->kr_handle;
836             ctx->kr_handle = NULL;
837         }
838         get_pubkey_end (ctx);
839     }
840
841     return rc;
842 }
843
844 /*
845  * Find a public key from NAME and returh the keyblock or the key.
846  * If ret_kdb is not NULL, the KEYDB handle used to locate this keyblock is
847  * returned and the caller is responsible for closing it.
848  */
849 int
850 get_pubkey_byname (PKT_public_key *pk,
851                    const char *name, KBNODE *ret_keyblock,
852                    KEYDB_HANDLE *ret_kdbhd, int include_disabled ) 
853 {
854     int rc;
855     STRLIST namelist = NULL;
856
857     add_to_strlist( &namelist, name );
858     rc = key_byname( NULL, namelist, pk, NULL, 0,
859                      include_disabled, ret_keyblock, ret_kdbhd);
860     free_strlist( namelist );
861     return rc;
862 }
863
864 int
865 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
866                     STRLIST names, KBNODE *ret_keyblock )
867 {
868     return key_byname( retctx, names, pk, NULL, 0, 1, ret_keyblock, NULL);
869 }
870
871 int
872 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
873 {
874     int rc;
875
876     rc = lookup( ctx, ret_keyblock, 0 );
877     if ( !rc && pk && ret_keyblock )
878         pk_from_block ( ctx, pk, *ret_keyblock );
879     
880     return rc;
881 }
882
883
884 void
885 get_pubkey_end( GETKEY_CTX ctx )
886 {
887     if( ctx ) {
888         memset (&ctx->kbpos, 0, sizeof ctx->kbpos);
889         keydb_release (ctx->kr_handle);
890         if( !ctx->not_allocated )
891             xfree ( ctx );
892     }
893 }
894
895
896
897
898 /****************
899  * Search for a key with the given fingerprint.
900  * FIXME:
901  * We should replace this with the _byname function.  This can be done
902  * by creating a userID conforming to the unified fingerprint style. 
903  */
904 int
905 get_pubkey_byfprint( PKT_public_key *pk,
906                      const byte *fprint, size_t fprint_len)
907 {
908     int rc;
909
910     if( fprint_len == 20 || fprint_len == 16 ) {
911         struct getkey_ctx_s ctx;
912         KBNODE kb = NULL;
913
914         memset( &ctx, 0, sizeof ctx );
915         ctx.exact = 1 ;
916         ctx.not_allocated = 1;
917         ctx.kr_handle = keydb_new (0);
918         ctx.nitems = 1;
919         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
920                                           : KEYDB_SEARCH_MODE_FPR20;
921         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
922         rc = lookup( &ctx, &kb, 0 );
923         if (!rc && pk )
924             pk_from_block ( &ctx, pk, kb );
925         release_kbnode ( kb );
926         get_pubkey_end( &ctx );
927     }
928     else
929         rc = GPG_ERR_GENERAL; /* Oops */
930     return rc;
931 }
932
933
934 /* Get a public key and store it into the allocated pk.  This function
935    differs from get_pubkey_byfprint() in that it does not do a check
936    of the key to avoid recursion.  It should be used only in very
937    certain cases.  PK may be NULL to check just for the existance of
938    the key. */
939 int
940 get_pubkey_byfprint_fast (PKT_public_key *pk,
941                           const byte *fprint, size_t fprint_len)
942 {
943   int rc = 0;
944   KEYDB_HANDLE hd;
945   KBNODE keyblock;
946   byte fprbuf[MAX_FINGERPRINT_LEN];
947   int i;
948   
949   for (i=0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
950     fprbuf[i] = fprint[i];
951   while (i < MAX_FINGERPRINT_LEN) 
952     fprbuf[i++] = 0;
953
954   hd = keydb_new (0);
955   rc = keydb_search_fpr (hd, fprbuf);
956   if (rc == -1)
957     {
958       keydb_release (hd);
959       return GPG_ERR_NO_PUBKEY;
960     }
961   rc = keydb_get_keyblock (hd, &keyblock);
962   keydb_release (hd);
963   if (rc) 
964     {
965       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
966       return GPG_ERR_NO_PUBKEY;
967     }
968   
969   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
970            ||  keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY );
971   if (pk)
972     copy_public_key (pk, keyblock->pkt->pkt.public_key );
973   release_kbnode (keyblock);
974
975   /* Not caching key here since it won't have all of the fields
976      properly set. */
977
978   return 0;
979 }
980
981 /****************
982  * Search for a key with the given fingerprint and return the
983  * complete keyblock which may have more than only this key.
984  */
985 int
986 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
987                                                 size_t fprint_len )
988 {
989     int rc;
990
991     if( fprint_len == 20 || fprint_len == 16 ) {
992         struct getkey_ctx_s ctx;
993
994         memset( &ctx, 0, sizeof ctx );
995         ctx.not_allocated = 1;
996         ctx.kr_handle = keydb_new (0);
997         ctx.nitems = 1;
998         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
999                                           : KEYDB_SEARCH_MODE_FPR20;
1000         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1001         rc = lookup( &ctx, ret_keyblock, 0 );
1002         get_pubkey_end( &ctx );
1003     }
1004     else
1005         rc = GPG_ERR_GENERAL; /* Oops */
1006
1007     return rc;
1008 }
1009
1010
1011 /****************
1012  * Get a secret key by name and store it into sk
1013  * If NAME is NULL use the default key
1014  */
1015 static int
1016 get_seckey_byname2( GETKEY_CTX *retctx,
1017                    PKT_secret_key *sk, const char *name, int unprotect,
1018                    KBNODE *retblock )
1019 {
1020     STRLIST namelist = NULL;
1021     int rc;
1022
1023     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
1024         add_to_strlist( &namelist, opt.def_secret_key );
1025         rc = key_byname( retctx, namelist, NULL, sk, 1, 1, retblock, NULL );
1026     }
1027     else if( !name ) { /* use the first one as default key */
1028         struct getkey_ctx_s ctx;
1029         KBNODE kb = NULL;
1030
1031         assert (!retctx ); /* do we need this at all */
1032         assert (!retblock);
1033         memset( &ctx, 0, sizeof ctx );
1034         ctx.not_allocated = 1;
1035         ctx.kr_handle = keydb_new (1);
1036         ctx.nitems = 1;
1037         ctx.items[0].mode = KEYDB_SEARCH_MODE_FIRST;
1038         rc = lookup( &ctx, &kb, 1 );
1039         if (!rc && sk )
1040             sk_from_block ( &ctx, sk, kb );
1041         release_kbnode ( kb );
1042         get_seckey_end( &ctx );
1043     }
1044     else {
1045         add_to_strlist( &namelist, name );
1046         rc = key_byname( retctx, namelist, NULL, sk, 1, 1, retblock, NULL );
1047     }
1048
1049     free_strlist( namelist );
1050
1051     if( !rc && unprotect )
1052         rc = check_secret_key( sk, 0 );
1053
1054     return rc;
1055 }
1056
1057 int 
1058 get_seckey_byname( PKT_secret_key *sk, const char *name, int unlock )
1059 {
1060     return get_seckey_byname2 ( NULL, sk, name, unlock, NULL );
1061 }
1062
1063
1064 int
1065 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
1066                     STRLIST names, KBNODE *ret_keyblock )
1067 {
1068     return key_byname( retctx, names, NULL, sk, 1, 1, ret_keyblock, NULL );
1069 }
1070
1071
1072 int
1073 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1074 {
1075     int rc;
1076
1077     rc = lookup( ctx, ret_keyblock, 1 );
1078     if ( !rc && sk && ret_keyblock )
1079         sk_from_block ( ctx, sk, *ret_keyblock );
1080
1081     return rc;
1082 }
1083
1084
1085 void
1086 get_seckey_end( GETKEY_CTX ctx )
1087 {
1088     get_pubkey_end( ctx );
1089 }
1090
1091
1092 /****************
1093  * Search for a key with the given fingerprint.
1094  * FIXME:
1095  * We should replace this with the _byname function.  Thiscsan be done
1096  * by creating a userID conforming to the unified fingerprint style. 
1097  */
1098 int
1099 get_seckey_byfprint( PKT_secret_key *sk,
1100                      const byte *fprint, size_t fprint_len)
1101 {
1102     int rc;
1103
1104     if( fprint_len == 20 || fprint_len == 16 ) {
1105         struct getkey_ctx_s ctx;
1106         KBNODE kb = NULL;
1107
1108         memset( &ctx, 0, sizeof ctx );
1109         ctx.exact = 1 ;
1110         ctx.not_allocated = 1;
1111         ctx.kr_handle = keydb_new (1);
1112         ctx.nitems = 1;
1113         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
1114                                           : KEYDB_SEARCH_MODE_FPR20;
1115         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1116         rc = lookup( &ctx, &kb, 1 );
1117         if (!rc && sk )
1118             sk_from_block ( &ctx, sk, kb );
1119         release_kbnode ( kb );
1120         get_pubkey_end( &ctx );
1121     }
1122     else
1123         rc = GPG_ERR_GENERAL; /* Oops */
1124     return rc;
1125 }
1126
1127 \f
1128 /************************************************
1129  ************* Merging stuff ********************
1130  ************************************************/
1131
1132 /****************
1133  * merge all selfsignatures with the keys.
1134  * FIXME: replace this at least for the public key parts
1135  *        by merge_selfsigs.
1136  *        It is still used in keyedit.c and
1137  *        at 2 or 3 other places - check whether it is really needed.
1138  *        It might be needed by the key edit and import stuff because
1139  *        the keylock is changed.
1140  */
1141 void
1142 merge_keys_and_selfsig( KBNODE keyblock )
1143 {
1144     PKT_public_key *pk = NULL;
1145     PKT_secret_key *sk = NULL;
1146     PKT_signature *sig;
1147     KBNODE k;
1148     u32 kid[2] = { 0, 0 };
1149     u32 sigdate = 0;
1150
1151     if (keyblock && keyblock->pkt->pkttype == PKT_PUBLIC_KEY ) {
1152         /* divert to our new function */
1153         merge_selfsigs (keyblock);
1154         return;
1155     }
1156     /* still need the old one because the new one can't handle secret keys */
1157
1158     for(k=keyblock; k; k = k->next ) {
1159         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1160             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1161             pk = k->pkt->pkt.public_key; sk = NULL;
1162             if( pk->version < 4 )
1163                 pk = NULL; /* not needed for old keys */
1164             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1165                 keyid_from_pk( pk, kid );
1166             else if( !pk->expiredate ) { /* and subkey */
1167                 /* insert the expiration date here */
1168                 /*FIXME!!! pk->expiredate = subkeys_expiretime( k, kid );*/
1169             }
1170             sigdate = 0;
1171         }
1172         else if( k->pkt->pkttype == PKT_SECRET_KEY
1173             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1174             pk = NULL; sk = k->pkt->pkt.secret_key;
1175             if( sk->version < 4 )
1176                 sk = NULL;
1177             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1178                 keyid_from_sk( sk, kid );
1179             sigdate = 0;
1180         }
1181         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1182                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1183                  && sig->sig_class <= 0x30 && sig->version > 3
1184                  && !(sig->sig_class == 0x18 || sig->sig_class == 0x28)
1185                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1186             /* okay this is a self-signature which can be used.
1187              * This is not used for subkey binding signature, becuase this
1188              * is done above.
1189              * FIXME: We should only use this if the signature is valid
1190              *        but this is time consuming - we must provide another
1191              *        way to handle this
1192              */
1193             const byte *p;
1194             u32 ed;
1195
1196             p = parse_sig_subpkt( sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL );
1197             if( pk ) {
1198                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1199                 if( sig->timestamp > sigdate ) {
1200                     pk->expiredate = ed;
1201                     sigdate = sig->timestamp;
1202                 }
1203             }
1204             else {
1205                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1206                 if( sig->timestamp > sigdate ) {
1207                     sk->expiredate = ed;
1208                     sigdate = sig->timestamp;
1209                 }
1210             }
1211         }
1212
1213         if(pk && (pk->expiredate==0 ||
1214                   (pk->max_expiredate && pk->expiredate>pk->max_expiredate)))
1215           pk->expiredate=pk->max_expiredate;
1216
1217         if(sk && (sk->expiredate==0 ||
1218                   (sk->max_expiredate && sk->expiredate>sk->max_expiredate)))
1219           sk->expiredate=sk->max_expiredate;
1220     }
1221 }
1222
1223 /*
1224  * Apply information from SIGNODE (which is the valid self-signature
1225  * associated with that UID) to the UIDNODE:
1226  * - wether the UID has been revoked
1227  * - assumed creation date of the UID
1228  * - temporary store the keyflags here
1229  * - temporary store the key expiration time here
1230  * - mark whether the primary user ID flag hat been set.
1231  * - store the preferences
1232  */
1233 static void
1234 fixup_uidnode ( KBNODE uidnode, KBNODE signode, u32 keycreated )
1235 {
1236     PKT_user_id   *uid = uidnode->pkt->pkt.user_id;
1237     PKT_signature *sig = signode->pkt->pkt.signature;
1238     const byte *p, *sym, *hash, *zip;
1239     size_t n, nsym, nhash, nzip;
1240
1241     uid->created = 0; /* not created == invalid */
1242     if ( IS_UID_REV ( sig ) ) {
1243         uid->is_revoked = 1;
1244         return; /* has been revoked */
1245     }
1246
1247     uid->created = sig->timestamp; /* this one is okay */
1248     uid->selfsigversion = sig->version;
1249     /* If we got this far, it's not expired :) */
1250     uid->is_expired = 0;
1251     uid->expiredate = sig->expiredate;
1252
1253     /* store the key flags in the helper variable for later processing */
1254     uid->help_key_usage = 0;
1255     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1256     if ( p && n ) {
1257         /* first octet of the keyflags */   
1258         if ( (*p & 0x03) )
1259             uid->help_key_usage |= PUBKEY_USAGE_SIG;
1260         if ( (*p & 0x0c) )    
1261             uid->help_key_usage |= PUBKEY_USAGE_ENC;
1262         /* Note: we do not set the CERT flag here because it can be assumed
1263          * that thre is no real policy to set it. */
1264         if ( (*p & 0x20) )    
1265             uid->help_key_usage |= PUBKEY_USAGE_AUTH;
1266     }
1267
1268     /* ditto or the key expiration */
1269     uid->help_key_expire = 0;
1270     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1271     if ( p ) { 
1272         uid->help_key_expire = keycreated + buffer_to_u32(p);
1273     }
1274
1275     /* Set the primary user ID flag - we will later wipe out some
1276      * of them to only have one in our keyblock */
1277     uid->is_primary = 0;
1278     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL );
1279     if ( p && *p )
1280         uid->is_primary = 2;
1281     /* We could also query this from the unhashed area if it is not in
1282      * the hased area and then later try to decide which is the better
1283      * there should be no security problem with this.
1284      * For now we only look at the hashed one. 
1285      */
1286
1287     /* Now build the preferences list.  These must come from the
1288        hashed section so nobody can modify the ciphers a key is
1289        willing to accept. */
1290     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_SYM, &n );
1291     sym = p; nsym = p?n:0;
1292     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_HASH, &n );
1293     hash = p; nhash = p?n:0;
1294     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_COMPR, &n );
1295     zip = p; nzip = p?n:0;
1296     if (uid->prefs) 
1297         xfree (uid->prefs);
1298     n = nsym + nhash + nzip;
1299     if (!n)
1300         uid->prefs = NULL;
1301     else {
1302         uid->prefs = xmalloc (sizeof (*uid->prefs) * (n+1));
1303         n = 0;
1304         for (; nsym; nsym--, n++) {
1305             uid->prefs[n].type = PREFTYPE_SYM;
1306             uid->prefs[n].value = *sym++;
1307         }
1308         for (; nhash; nhash--, n++) {
1309             uid->prefs[n].type = PREFTYPE_HASH;
1310             uid->prefs[n].value = *hash++;
1311         }
1312         for (; nzip; nzip--, n++) {
1313             uid->prefs[n].type = PREFTYPE_ZIP;
1314             uid->prefs[n].value = *zip++;
1315         }
1316         uid->prefs[n].type = PREFTYPE_NONE; /* end of list marker */
1317         uid->prefs[n].value = 0;
1318     }
1319
1320     /* see whether we have the MDC feature */
1321     uid->mdc_feature = 0;
1322     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
1323     if (p && n && (p[0] & 0x01))
1324         uid->mdc_feature = 1;
1325
1326     /* and the keyserver modify flag */
1327     uid->ks_modify = 1;
1328     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n);
1329     if (p && n && (p[0] & 0x80))
1330         uid->ks_modify = 0;
1331 }
1332
1333 static void
1334 merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
1335 {
1336     PKT_public_key *pk = NULL;
1337     KBNODE k;
1338     u32 kid[2];
1339     u32 sigdate, uiddate, uiddate2;
1340     KBNODE signode, uidnode, uidnode2;
1341     u32 curtime = make_timestamp ();
1342     unsigned int key_usage = 0;
1343     u32 keytimestamp = 0;
1344     u32 key_expire = 0;
1345     int key_expire_seen = 0;
1346     byte sigversion = 0;
1347
1348     *r_revoked = 0;
1349     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1350         BUG ();
1351     pk = keyblock->pkt->pkt.public_key;
1352     keytimestamp = pk->timestamp;
1353
1354     keyid_from_pk( pk, kid );
1355     pk->main_keyid[0] = kid[0];
1356     pk->main_keyid[1] = kid[1];
1357
1358     if ( pk->version < 4 ) {
1359         /* before v4 the key packet itself contains the expiration
1360          * date and there was no way to change it, so we start with
1361          * the one from the key packet */
1362         key_expire = pk->max_expiredate;
1363         key_expire_seen = 1;
1364     }
1365
1366     /* first pass: find the latest direct key self-signature.
1367      * We assume that the newest one overrides all others
1368      */
1369
1370     /* In case this key was already merged */
1371     xfree (pk->revkey);
1372     pk->revkey=NULL;
1373     pk->numrevkeys=0;
1374
1375     signode = NULL;
1376     sigdate = 0; /* helper to find the latest signature */
1377     for(k=keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next ) {
1378         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1379             PKT_signature *sig = k->pkt->pkt.signature;
1380             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1381                 if ( check_key_signature( keyblock, k, NULL ) )
1382                     ; /* signature did not verify */
1383                 else if ( IS_KEY_REV (sig) ){
1384                     /* key has been revoked - there is no way to override
1385                      * such a revocation, so we theoretically can stop now.
1386                      * We should not cope with expiration times for revocations
1387                      * here because we have to assume that an attacker can
1388                      * generate all kinds of signatures.  However due to the
1389                      * fact that the key has been revoked it does not harm
1390                      * either and by continuing we gather some more info on 
1391                      * that key.
1392                      */ 
1393                     *r_revoked = 1;
1394                 }
1395                 else if ( IS_KEY_SIG (sig) ) {
1396                   /* Add any revocation keys onto the pk.  This is
1397                      particularly interesting since we normally only
1398                      get data from the most recent 1F signature, but
1399                      you need multiple 1F sigs to properly handle
1400                      revocation keys (PGP does it this way, and a
1401                      revocation key could be sensitive and hence in a
1402                      different signature). */
1403                   if(sig->revkey) {
1404                     int i;
1405
1406                     pk->revkey=
1407                       xrealloc(pk->revkey,sizeof(struct revocation_key)*
1408                                 (pk->numrevkeys+sig->numrevkeys));
1409
1410                     for(i=0;i<sig->numrevkeys;i++)
1411                       memcpy(&pk->revkey[pk->numrevkeys++],
1412                              sig->revkey[i],
1413                              sizeof(struct revocation_key));
1414                   }
1415
1416                   if( sig->timestamp >= sigdate ) {
1417                     if(sig->flags.expired)
1418                         ; /* signature has expired - ignore it */
1419                     else {
1420                         sigdate = sig->timestamp;
1421                         signode = k;
1422                         if( sig->version > sigversion )
1423                           sigversion = sig->version;
1424
1425                     }
1426                   }
1427                 }
1428             }
1429         }
1430     }
1431
1432     /* Remove dupes from the revocation keys */
1433
1434     if(pk->revkey)
1435       {
1436         int i,j,x,changed=0;
1437
1438         for(i=0;i<pk->numrevkeys;i++)
1439           {
1440             for(j=i+1;j<pk->numrevkeys;j++)
1441               {
1442                 if(memcmp(&pk->revkey[i],&pk->revkey[j],
1443                           sizeof(struct revocation_key))==0)
1444                   {
1445                     /* remove j */
1446
1447                     for(x=j;x<pk->numrevkeys-1;x++)
1448                       pk->revkey[x]=pk->revkey[x+1];
1449
1450                     pk->numrevkeys--;
1451                     j--;
1452                     changed=1;
1453                   }
1454               }
1455           }
1456
1457         if(changed)
1458           pk->revkey=xrealloc(pk->revkey,
1459                                pk->numrevkeys*sizeof(struct revocation_key));
1460       }
1461
1462     if ( signode ) {
1463         /* some information from a direct key signature take precedence
1464          * over the same information given in UID sigs.
1465          */
1466         PKT_signature *sig = signode->pkt->pkt.signature;
1467         const byte *p;
1468         size_t n;
1469         
1470         p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1471         if ( p && n ) {
1472             /* first octet of the keyflags */   
1473             if ( (*p & 0x03) )
1474                 key_usage |= PUBKEY_USAGE_SIG;
1475             if ( (*p & 0x0c) )    
1476                 key_usage |= PUBKEY_USAGE_ENC;
1477             if ( (*p & 0x20) )    
1478                 key_usage |= PUBKEY_USAGE_AUTH;
1479         }
1480
1481         p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1482         if ( p ) {
1483           key_expire = keytimestamp + buffer_to_u32(p);
1484           key_expire_seen = 1;
1485         }
1486
1487         /* mark that key as valid: one direct key signature should 
1488          * render a key as valid */
1489         pk->is_valid = 1;
1490     }
1491
1492     /* pass 1.5: look for key revocation signatures that were not made
1493        by the key (i.e. did a revocation key issue a revocation for
1494        us?).  Only bother to do this if there is a revocation key in
1495        the first place. */
1496
1497     if(pk->revkey)
1498       for(k=keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next )
1499         {
1500           if ( k->pkt->pkttype == PKT_SIGNATURE )
1501             {
1502               PKT_signature *sig = k->pkt->pkt.signature;
1503
1504               if(IS_KEY_REV(sig) &&
1505                  (sig->keyid[0]!=kid[0] || sig->keyid[1]!=kid[1]))
1506                 { 
1507                   /* Failure here means the sig did not verify, is was
1508                      not issued by a revocation key, or a revocation
1509                      key loop was broken. */
1510
1511                   if(check_revocation_keys(pk,sig)==0)
1512                     *r_revoked=1;
1513
1514                   /* In the future handle subkey and cert revocations?
1515                      PGP doesn't, but it's in 2440. */
1516                 }
1517             }
1518         }
1519
1520     /* second pass: look at the self-signature of all user IDs */
1521     signode = uidnode = NULL;
1522     sigdate = 0; /* helper to find the latest signature in one user ID */
1523     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1524         if ( k->pkt->pkttype == PKT_USER_ID ) {
1525             if ( uidnode && signode ) 
1526               {
1527                 fixup_uidnode ( uidnode, signode, keytimestamp );
1528                 pk->is_valid=1;
1529               }
1530             uidnode = k;
1531             signode = NULL;
1532             sigdate = 0;
1533         }
1534         else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode ) {
1535             PKT_signature *sig = k->pkt->pkt.signature;
1536             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1537                 if ( check_key_signature( keyblock, k, NULL ) )
1538                     ; /* signature did not verify */
1539                 else if ( (IS_UID_SIG (sig) || IS_UID_REV (sig))
1540                           && sig->timestamp >= sigdate ) {
1541                     /* Note: we allow to invalidate cert revocations
1542                      * by a newer signature.  An attacker can't use this
1543                      * because a key should be revoced with a key revocation.
1544                      * The reason why we have to allow for that is that at
1545                      * one time an email address may become invalid but later
1546                      * the same email address may become valid again (hired,
1547                      * fired, hired again).
1548                      */
1549                     if(sig->flags.expired) {
1550                       /* Expired uids don't get to be primary unless
1551                          they are the only uid there is. */
1552                       uidnode->pkt->pkt.user_id->is_primary=0;
1553                       uidnode->pkt->pkt.user_id->is_expired=1;
1554                       uidnode->pkt->pkt.user_id->expiredate=sig->expiredate;
1555                     }
1556                     else {
1557                         sigdate = sig->timestamp;
1558                         signode = k;
1559                         if( sig->version > sigversion )
1560                           sigversion = sig->version;
1561                     }
1562                 }
1563             }
1564         }
1565     }
1566     if ( uidnode && signode ) {
1567         fixup_uidnode ( uidnode, signode, keytimestamp );
1568         pk->is_valid = 1;
1569     }
1570
1571     /* If the key isn't valid yet, and we have
1572        --allow-non-selfsigned-uid set, then force it valid. */
1573     if(!pk->is_valid && opt.allow_non_selfsigned_uid)
1574       {
1575         if(opt.verbose)
1576           log_info(_("Invalid key %08lX made valid by "
1577                      "--allow-non-selfsigned-uid\n"),
1578                    (ulong)keyid_from_pk(pk,NULL));
1579
1580         pk->is_valid = 1;
1581       }
1582
1583     /* The key STILL isn't valid, so try and find an ultimately
1584        trusted signature. */
1585     if(!pk->is_valid)
1586       {
1587         uidnode=NULL;
1588
1589         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k=k->next)
1590           {
1591             if ( k->pkt->pkttype == PKT_USER_ID )
1592               uidnode = k;
1593             else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode )
1594               {
1595                 PKT_signature *sig = k->pkt->pkt.signature;
1596                 u32 dummy;
1597                 int dum2;
1598
1599                 if(sig->keyid[0] != kid[0] || sig->keyid[1]!=kid[1])
1600                   {
1601                     PKT_public_key *ultimate_pk;
1602
1603                     ultimate_pk=xcalloc (1,sizeof(*ultimate_pk));
1604
1605                     /* We don't want to use the full get_pubkey to
1606                        avoid infinite recursion in certain cases.
1607                        There is no reason to check that an ultimately
1608                        trusted key is still valid - if it has been
1609                        revoked or the user should also renmove the
1610                        ultimate trust flag.  */
1611                     if(get_pubkey_fast(ultimate_pk,sig->keyid)==0
1612                        && check_key_signature2(keyblock,k,ultimate_pk,
1613                                                NULL,&dummy,&dum2)==0
1614                        && get_ownertrust(ultimate_pk)==TRUST_ULTIMATE)
1615                       {
1616                         free_public_key(ultimate_pk);
1617                         pk->is_valid=1;
1618                         break;
1619                       }
1620
1621                     free_public_key(ultimate_pk);
1622                   }
1623               }
1624           }
1625       }
1626
1627     /* Record the highest selfsig version so we know if this is a v3
1628        key through and through, or a v3 key with a v4 selfsig
1629        somewhere.  This is useful in a few places to know if the key
1630        must be treated as PGP2-style or OpenPGP-style.  Note that a
1631        selfsig revocation with a higher version number will also raise
1632        this value.  This is okay since such a revocation must be
1633        issued by the user (i.e. it cannot be issued by someone else to
1634        modify the key behavior.) */
1635
1636     pk->selfsigversion=sigversion;
1637
1638     /* Now that we had a look at all user IDs we can now get some information
1639      * from those user IDs.
1640      */
1641     
1642     if ( !key_usage ) {
1643         /* find the latest user ID with key flags set */
1644         uiddate = 0; /* helper to find the latest user ID */
1645         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1646             k = k->next ) {
1647             if ( k->pkt->pkttype == PKT_USER_ID ) {
1648                 PKT_user_id *uid = k->pkt->pkt.user_id;
1649                 if ( uid->help_key_usage && uid->created > uiddate ) {
1650                     key_usage = uid->help_key_usage;
1651                     uiddate = uid->created;
1652                 }
1653             }
1654         }
1655     }
1656     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1657         key_usage = openpgp_pk_algo_usage ( pk->pubkey_algo );
1658     }
1659     else { /* check that the usage matches the usage as given by the algo */
1660         int x = openpgp_pk_algo_usage ( pk->pubkey_algo );
1661         if ( x ) /* mask it down to the actual allowed usage */
1662             key_usage &= x; 
1663     }
1664     pk->pubkey_usage = key_usage;
1665
1666     if ( !key_expire_seen ) {
1667         /* find the latest valid user ID with a key expiration set 
1668          * Note, that this may be a different one from the above because
1669          * some user IDs may have no expiration date set */
1670         uiddate = 0; 
1671         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1672             k = k->next ) {
1673             if ( k->pkt->pkttype == PKT_USER_ID ) {
1674                 PKT_user_id *uid = k->pkt->pkt.user_id;
1675                 if ( uid->help_key_expire && uid->created > uiddate ) {
1676                     key_expire = uid->help_key_expire;
1677                     uiddate = uid->created;
1678                 }
1679             }
1680         }
1681     }
1682
1683     /* Currently only v3 keys have a maximum expiration date, but I'll
1684        bet v5 keys get this feature again. */
1685     if(key_expire==0 || (pk->max_expiredate && key_expire>pk->max_expiredate))
1686       key_expire=pk->max_expiredate;
1687
1688     pk->has_expired = key_expire >= curtime? 0 : key_expire;
1689     pk->expiredate = key_expire;
1690
1691     /* Fixme: we should see how to get rid of the expiretime fields  but
1692      * this needs changes at other places too. */
1693
1694     /* and now find the real primary user ID and delete all others */
1695     uiddate = uiddate2 = 0;
1696     uidnode = uidnode2 = NULL;
1697     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1698         if ( k->pkt->pkttype == PKT_USER_ID &&
1699              !k->pkt->pkt.user_id->attrib_data) {
1700             PKT_user_id *uid = k->pkt->pkt.user_id;
1701             if (uid->is_primary)
1702               {
1703                 if(uid->created > uiddate)
1704                   {
1705                     uiddate = uid->created;
1706                     uidnode = k;
1707                   }
1708                 else if(uid->created==uiddate && uidnode)
1709                   {
1710                     /* The dates are equal, so we need to do a
1711                        different (and arbitrary) comparison.  This
1712                        should rarely, if ever, happen.  It's good to
1713                        try and guarantee that two different GnuPG
1714                        users with two different keyrings at least pick
1715                        the same primary. */
1716                     if(cmp_user_ids(uid,uidnode->pkt->pkt.user_id)>0)
1717                       uidnode=k;
1718                   }
1719               }
1720             else
1721               {
1722                 if(uid->created > uiddate2)
1723                   {
1724                     uiddate2 = uid->created;
1725                     uidnode2 = k;
1726                   }
1727                 else if(uid->created==uiddate2 && uidnode2)
1728                   {
1729                     if(cmp_user_ids(uid,uidnode2->pkt->pkt.user_id)>0)
1730                       uidnode2=k;
1731                   }
1732               }
1733         }
1734     }
1735     if ( uidnode ) {
1736         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1737             k = k->next ) {
1738             if ( k->pkt->pkttype == PKT_USER_ID &&
1739                  !k->pkt->pkt.user_id->attrib_data) {
1740                 PKT_user_id *uid = k->pkt->pkt.user_id;
1741                 if ( k != uidnode ) 
1742                     uid->is_primary = 0;
1743             }
1744         }
1745     }
1746     else if( uidnode2 ) {
1747         /* none is flagged primary - use the latest user ID we have,
1748            and disambiguate with the arbitrary packet comparison. */
1749         uidnode2->pkt->pkt.user_id->is_primary = 1;
1750     }
1751     else
1752       {
1753         /* None of our uids were self-signed, so pick the one that
1754            sorts first to be the primary.  This is the best we can do
1755            here since there are no self sigs to date the uids. */
1756
1757         uidnode = NULL;
1758
1759         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1760             k = k->next )
1761           {
1762             if(k->pkt->pkttype==PKT_USER_ID
1763                && !k->pkt->pkt.user_id->attrib_data)
1764               {
1765                 if(!uidnode)
1766                   {
1767                     uidnode=k;
1768                     uidnode->pkt->pkt.user_id->is_primary=1;
1769                     continue;
1770                   }
1771                 else
1772                   {
1773                     if(cmp_user_ids(k->pkt->pkt.user_id,
1774                                     uidnode->pkt->pkt.user_id)>0)
1775                       {
1776                         uidnode->pkt->pkt.user_id->is_primary=0;
1777                         uidnode=k;
1778                         uidnode->pkt->pkt.user_id->is_primary=1;
1779                       }
1780                     else
1781                       k->pkt->pkt.user_id->is_primary=0; /* just to be
1782                                                             safe */
1783                   }
1784               }
1785           }
1786       }
1787 }
1788
1789
1790 static void
1791 merge_selfsigs_subkey( KBNODE keyblock, KBNODE subnode )
1792 {
1793     PKT_public_key *mainpk = NULL, *subpk = NULL;
1794     PKT_signature *sig;
1795     KBNODE k;
1796     u32 mainkid[2];
1797     u32 sigdate = 0;
1798     KBNODE signode;
1799     u32 curtime = make_timestamp ();
1800     unsigned int key_usage = 0;
1801     u32 keytimestamp = 0;
1802     u32 key_expire = 0;
1803     const byte *p;
1804     size_t n;
1805
1806     if ( subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1807         BUG ();
1808     mainpk = keyblock->pkt->pkt.public_key;
1809     if ( mainpk->version < 4 )
1810         return; /* (actually this should never happen) */
1811     keyid_from_pk( mainpk, mainkid );
1812     subpk = subnode->pkt->pkt.public_key;
1813     keytimestamp = subpk->timestamp;
1814
1815     subpk->is_valid = 0;
1816     subpk->main_keyid[0] = mainpk->main_keyid[0];
1817     subpk->main_keyid[1] = mainpk->main_keyid[1];
1818
1819     /* find the latest key binding self-signature. */
1820     signode = NULL;
1821     sigdate = 0; /* helper to find the latest signature */
1822     for(k=subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1823                                                         k = k->next ) {
1824         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1825             sig = k->pkt->pkt.signature;
1826             if ( sig->keyid[0] == mainkid[0] && sig->keyid[1]==mainkid[1] ) { 
1827                 if ( check_key_signature( keyblock, k, NULL ) )
1828                     ; /* signature did not verify */
1829                 else if ( IS_SUBKEY_REV (sig) ) {
1830                   /* Note that this means that the date on a
1831                      revocation sig does not matter - even if the
1832                      binding sig is dated after the revocation sig,
1833                      the subkey is still marked as revoked.  This
1834                      seems ok, as it is just as easy to make new
1835                      subkeys rather than re-sign old ones as the
1836                      problem is in the distribution.  Plus, PGP (7)
1837                      does this the same way.  */
1838                     subpk->is_revoked = 1;
1839                     /* although we could stop now, we continue to 
1840                      * figure out other information like the old expiration
1841                      * time */
1842                 }
1843                 else if ( IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate ) {
1844                     if(sig->flags.expired)
1845                         ; /* signature has expired - ignore it */
1846                     else {
1847                         sigdate = sig->timestamp;
1848                         signode = k;
1849                     }
1850                 }
1851             }
1852         }
1853     }
1854
1855     if ( !signode ) {
1856         return;  /* no valid key binding */
1857     }
1858
1859     subpk->is_valid = 1;
1860     sig = signode->pkt->pkt.signature;
1861         
1862     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1863     if ( p && n ) {
1864         /* first octet of the keyflags */   
1865         if ( (*p & 0x03) )
1866             key_usage |= PUBKEY_USAGE_SIG;
1867         if ( (*p & 0x0c) )    
1868             key_usage |= PUBKEY_USAGE_ENC;
1869         if ( (*p & 0x20) )    
1870             key_usage |= PUBKEY_USAGE_AUTH;
1871     }
1872     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1873         key_usage = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1874     }
1875     else { /* check that the usage matches the usage as given by the algo */
1876         int x = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1877         if ( x ) /* mask it down to the actual allowed usage */
1878             key_usage &= x; 
1879     }
1880     subpk->pubkey_usage = key_usage;
1881     
1882     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1883     if ( p ) 
1884         key_expire = keytimestamp + buffer_to_u32(p);
1885     else
1886         key_expire = 0;
1887     subpk->has_expired = key_expire >= curtime? 0 : key_expire;
1888     subpk->expiredate = key_expire;
1889 }
1890
1891
1892
1893 /* 
1894  * Merge information from the self-signatures with the key, so that
1895  * we can later use them more easy.
1896  * The function works by first applying the self signatures to the
1897  * primary key and the to each subkey.
1898  * Here are the rules we use to decide which inormation from which
1899  * self-signature is used:
1900  * We check all self signatures or validity and ignore all invalid signatures.
1901  * All signatures are then ordered by their creation date ....
1902  * For the primary key:
1903  *   FIXME the docs    
1904  */
1905 static void
1906 merge_selfsigs( KBNODE keyblock )
1907 {
1908     KBNODE k;
1909     int revoked;
1910     PKT_public_key *main_pk;
1911     prefitem_t *prefs;
1912     int mdc_feature;
1913
1914     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY ) {
1915         if (keyblock->pkt->pkttype == PKT_SECRET_KEY ) {
1916             log_error ("expected public key but found secret key "
1917                        "- must stop\n");
1918             /* we better exit here becuase a public key is expected at
1919                other places too.  FIXME: Figure this out earlier and
1920                don't get to here at all */
1921             g10_exit (1);
1922         }
1923         BUG ();
1924     }
1925
1926     merge_selfsigs_main ( keyblock, &revoked );
1927
1928     /* now merge in the data from each of the subkeys */
1929     for(k=keyblock; k; k = k->next ) {
1930         if (  k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1931             merge_selfsigs_subkey ( keyblock, k );
1932         }
1933     }
1934
1935     main_pk = keyblock->pkt->pkt.public_key;
1936     if ( revoked || main_pk->has_expired || !main_pk->is_valid ) {
1937         /* if the primary key is revoked, expired, or invalid we
1938          * better set the appropriate flags on that key and all
1939          * subkeys */
1940         for(k=keyblock; k; k = k->next ) {
1941             if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1942                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1943                 PKT_public_key *pk = k->pkt->pkt.public_key;
1944                 if(!main_pk->is_valid)
1945                   pk->is_valid = 0;
1946                 if(revoked)
1947                   pk->is_revoked = 1;
1948                 if(main_pk->has_expired)
1949                   pk->has_expired = main_pk->has_expired;
1950             }
1951         }
1952         return;
1953     }
1954
1955     /* set the preference list of all keys to those of the primary real
1956      * user ID.  Note: we use these preferences when we don't know by
1957      * which user ID the key has been selected.
1958      * fixme: we should keep atoms of commonly used preferences or
1959      * use reference counting to optimize the preference lists storage.
1960      * FIXME: it might be better to use the intersection of 
1961      * all preferences.
1962      * Do a similar thing for the MDC feature flag.
1963      */
1964     prefs = NULL;
1965     mdc_feature = 0;
1966     for (k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next) {
1967         if (k->pkt->pkttype == PKT_USER_ID
1968             && !k->pkt->pkt.user_id->attrib_data
1969             && k->pkt->pkt.user_id->is_primary) {
1970             prefs = k->pkt->pkt.user_id->prefs;
1971             mdc_feature = k->pkt->pkt.user_id->mdc_feature;
1972             break;
1973         }
1974     }    
1975     for(k=keyblock; k; k = k->next ) {
1976         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1977              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1978             PKT_public_key *pk = k->pkt->pkt.public_key;
1979             if (pk->prefs)
1980                 xfree (pk->prefs);
1981             pk->prefs = copy_prefs (prefs);
1982             pk->mdc_feature = mdc_feature;
1983         }
1984     }
1985 }
1986
1987
1988 /*
1989  * Merge the secret keys from secblock into the pubblock thereby
1990  * replacing the public (sub)keys with their secret counterparts Hmmm:
1991  * It might be better to get away from the concept of entire secret
1992  * keys at all and have a way to store just the real secret parts
1993  * from the key.
1994  */
1995 static void
1996 merge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
1997 {
1998     KBNODE pub;
1999
2000     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
2001     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2002     
2003     for (pub=pubblock; pub; pub = pub->next ) {
2004         if ( pub->pkt->pkttype == PKT_PUBLIC_KEY ) {
2005              PKT_public_key *pk = pub->pkt->pkt.public_key;
2006              PKT_secret_key *sk = secblock->pkt->pkt.secret_key;
2007              assert ( pub == pubblock ); /* only in the first node */
2008              /* there is nothing to compare in this case, so just replace
2009               * some information */
2010              copy_public_parts_to_secret_key ( pk, sk );
2011              free_public_key ( pk );
2012              pub->pkt->pkttype = PKT_SECRET_KEY;
2013              pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2014         }
2015         else if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2016             KBNODE sec;
2017             PKT_public_key *pk = pub->pkt->pkt.public_key;
2018
2019             /* this is more complicated: it may happen that the sequence
2020              * of the subkeys dosn't match, so we have to find the
2021              * appropriate secret key */
2022             for (sec=secblock->next; sec; sec = sec->next ) {
2023                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2024                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2025                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2026                         copy_public_parts_to_secret_key ( pk, sk );
2027                         free_public_key ( pk );
2028                         pub->pkt->pkttype = PKT_SECRET_SUBKEY;
2029                         pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2030                         break;
2031                     }
2032                 }
2033             }
2034             if ( !sec ) 
2035                 BUG(); /* already checked in premerge */
2036         }
2037     }
2038 }
2039
2040 /* This function checks that for every public subkey a corresponding
2041  * secret subkey is available and deletes the public subkey otherwise.
2042  * We need this function because we can't delete it later when we
2043  * actually merge the secret parts into the pubring.
2044  * The function also plays some games with the node flags.
2045  */
2046 static void
2047 premerge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
2048 {
2049     KBNODE last, pub;
2050
2051     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
2052     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2053     
2054     for (pub=pubblock,last=NULL; pub; last = pub, pub = pub->next ) {
2055         pub->flag &= ~3; /* reset bits 0 and 1 */
2056         if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2057             KBNODE sec;
2058             PKT_public_key *pk = pub->pkt->pkt.public_key;
2059
2060             for (sec=secblock->next; sec; sec = sec->next ) {
2061                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2062                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2063                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2064                         if ( sk->protect.s2k.mode == 1001 ) {
2065                             /* The secret parts are not available so
2066                                we can't use that key for signing etc.
2067                                Fix the pubkey usage */
2068                             pk->pubkey_usage &= ~(PUBKEY_USAGE_SIG
2069                                                   |PUBKEY_USAGE_AUTH);
2070                         }
2071                         /* transfer flag bits 0 and 1 to the pubblock */
2072                         pub->flag |= (sec->flag &3);
2073                         break;
2074                     }
2075                 }
2076             }
2077             if ( !sec ) {
2078                 KBNODE next, ll;
2079
2080                 if (opt.verbose)
2081                   log_info ( _("no secret subkey "
2082                                "for public subkey %08lX - ignoring\n"),  
2083                            (ulong)keyid_from_pk (pk,NULL) );
2084                 /* we have to remove the subkey in this case */
2085                 assert ( last );
2086                 /* find the next subkey */
2087                 for (next=pub->next,ll=pub;
2088                      next && pub->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2089                      ll = next, next = next->next ) 
2090                     ;
2091                 /* make new link */
2092                 last->next = next;
2093                 /* release this public subkey with all sigs */
2094                 ll->next = NULL;
2095                 release_kbnode( pub );
2096                 /* let the loop continue */
2097                 pub = last;
2098             }
2099         }
2100     }
2101     /* We need to copy the found bits (0 and 1) from the secret key to
2102        the public key.  This has already been done for the subkeys but
2103        got lost on the primary key - fix it here *. */
2104     pubblock->flag |= (secblock->flag & 3);
2105 }
2106
2107
2108
2109 \f
2110 /* See see whether the key fits
2111  * our requirements and in case we do not
2112  * request the primary key, we should select
2113  * a suitable subkey.
2114  * FIXME: Check against PGP 7 whether we still need a kludge
2115  *        to favor type 16 keys over type 20 keys when type 20
2116  *        has not been explitely requested.
2117  * Returns: True when a suitable key has been found.
2118  *
2119  * We have to distinguish four cases:  FIXME!
2120  *  1. No usage and no primary key requested
2121  *     Examples for this case are that we have a keyID to be used
2122  *     for decrytion or verification.
2123  *  2. No usage but primary key requested
2124  *     This is the case for all functions which work on an
2125  *     entire keyblock, e.g. for editing or listing
2126  *  3. Usage and primary key requested
2127  *     FXME
2128  *  4. Usage but no primary key requested
2129  *     FIXME
2130  * FIXME: Tell what is going to happen here and something about the rationale
2131  * Note: We don't use this function if no specific usage is requested;
2132  *       This way the getkey functions can be used for plain key listings.
2133  *
2134  * CTX ist the keyblock we are investigating, if FOUNDK is not NULL this
2135  * is the key we actually found by looking at the keyid or a fingerprint and
2136  * may eitehr point to the primary or one of the subkeys.
2137  */
2138
2139 static int
2140 finish_lookup (GETKEY_CTX ctx)
2141 {
2142     KBNODE keyblock = ctx->keyblock;
2143     KBNODE k;
2144     KBNODE foundk = NULL;
2145     PKT_user_id *foundu = NULL;
2146 #define USAGE_MASK  (PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC)
2147     unsigned int req_usage = ( ctx->req_usage & USAGE_MASK );
2148     /* Request the primary if we're certifying another key, and also
2149        if signing data while --pgp6 or --pgp7 is on since pgp 6 and 7
2150        do not understand signatures made by a signing subkey.  PGP 8
2151        does. */
2152     int req_prim = (ctx->req_usage & PUBKEY_USAGE_CERT) ||
2153       ((PGP6 || PGP7) && (ctx->req_usage & PUBKEY_USAGE_SIG));
2154     u32 latest_date;
2155     KBNODE latest_key;
2156     u32 curtime = make_timestamp ();
2157
2158     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
2159    
2160     ctx->found_key = NULL;
2161
2162     if (ctx->exact) {
2163         for (k=keyblock; k; k = k->next) {
2164             if ( (k->flag & 1) ) {
2165                 assert ( k->pkt->pkttype == PKT_PUBLIC_KEY
2166                          || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
2167                 foundk = k;
2168                 break;
2169             }
2170         }
2171     }
2172
2173     for (k=keyblock; k; k = k->next) {
2174         if ( (k->flag & 2) ) {
2175             assert (k->pkt->pkttype == PKT_USER_ID);
2176             foundu = k->pkt->pkt.user_id;
2177             break;
2178         }
2179     }
2180
2181     if ( DBG_CACHE )
2182         log_debug( "finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
2183                    (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL),
2184                    foundk? "one":"all", req_usage);
2185
2186     if (!req_usage) {
2187         latest_key = foundk? foundk:keyblock;
2188         goto found;
2189     }
2190     
2191     if (!req_usage) {
2192         PKT_public_key *pk = foundk->pkt->pkt.public_key;
2193         if (pk->user_id)
2194             free_user_id (pk->user_id);
2195         pk->user_id = scopy_user_id (foundu);
2196         ctx->found_key = foundk;
2197         cache_user_id( keyblock );
2198         return 1; /* found */
2199     }
2200     
2201     latest_date = 0;
2202     latest_key  = NULL;
2203     /* do not look at subkeys if a certification key is requested */
2204     if ((!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) && !req_prim) {
2205         KBNODE nextk;
2206         /* either start a loop or check just this one subkey */
2207         for (k=foundk?foundk:keyblock; k; k = nextk ) {
2208             PKT_public_key *pk;
2209             nextk = k->next;
2210             if ( k->pkt->pkttype != PKT_PUBLIC_SUBKEY )
2211                 continue;
2212             if ( foundk )
2213                 nextk = NULL;  /* what a hack */
2214             pk = k->pkt->pkt.public_key;
2215             if (DBG_CACHE)
2216                 log_debug( "\tchecking subkey %08lX\n",
2217                            (ulong)keyid_from_pk( pk, NULL));
2218             if ( !pk->is_valid ) {
2219                 if (DBG_CACHE)
2220                     log_debug( "\tsubkey not valid\n");
2221                 continue;
2222             }
2223             if ( pk->is_revoked ) {
2224                 if (DBG_CACHE)
2225                     log_debug( "\tsubkey has been revoked\n");
2226                 continue;
2227             }
2228             if ( pk->has_expired ) {
2229                 if (DBG_CACHE)
2230                     log_debug( "\tsubkey has expired\n");
2231                 continue;
2232             }
2233             if ( pk->timestamp > curtime && !opt.ignore_valid_from ) {
2234                 if (DBG_CACHE)
2235                     log_debug( "\tsubkey not yet valid\n");
2236                 continue;
2237             }
2238             
2239             if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2240                 if (DBG_CACHE)
2241                     log_debug( "\tusage does not match: want=%x have=%x\n",
2242                                req_usage, pk->pubkey_usage );
2243                 continue;
2244             }
2245
2246             if (DBG_CACHE)
2247                 log_debug( "\tsubkey looks fine\n");
2248             if ( pk->timestamp > latest_date ) {
2249                 latest_date = pk->timestamp;
2250                 latest_key  = k;
2251             }
2252         }
2253     }
2254
2255     /* Okay now try the primary key unless we want an exact 
2256      * key ID match on a subkey */
2257     if ((!latest_key && !(ctx->exact && foundk != keyblock)) || req_prim) {
2258         PKT_public_key *pk;
2259         if (DBG_CACHE && !foundk && !req_prim )
2260             log_debug( "\tno suitable subkeys found - trying primary\n");
2261         pk = keyblock->pkt->pkt.public_key;
2262         if ( !pk->is_valid ) {
2263             if (DBG_CACHE)
2264                 log_debug( "\tprimary key not valid\n");
2265         }
2266         else if ( pk->is_revoked ) {
2267             if (DBG_CACHE)
2268                 log_debug( "\tprimary key has been revoked\n");
2269         }
2270         else if ( pk->has_expired ) {
2271             if (DBG_CACHE)
2272                 log_debug( "\tprimary key has expired\n");
2273         }
2274         else  if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2275             if (DBG_CACHE)
2276                 log_debug( "\tprimary key usage does not match: "
2277                            "want=%x have=%x\n",
2278                            req_usage, pk->pubkey_usage );
2279         }
2280         else { /* okay */
2281             if (DBG_CACHE)
2282                 log_debug( "\tprimary key may be used\n");
2283             latest_key = keyblock;
2284             latest_date = pk->timestamp;
2285         }
2286     }
2287     
2288     if ( !latest_key ) {
2289         if (DBG_CACHE)
2290             log_debug("\tno suitable key found -  giving up\n");
2291         return 0;
2292     }
2293
2294  found:
2295     if (DBG_CACHE)
2296         log_debug( "\tusing key %08lX\n",
2297                 (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL) );
2298
2299     if (latest_key) {
2300         PKT_public_key *pk = latest_key->pkt->pkt.public_key;
2301         if (pk->user_id)
2302             free_user_id (pk->user_id);
2303         pk->user_id = scopy_user_id (foundu);
2304     }    
2305         
2306     ctx->found_key = latest_key;
2307
2308     if (latest_key != keyblock && opt.verbose) {
2309         log_info(_("using secondary key %08lX "
2310                    "instead of primary key %08lX\n"),
2311                  (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL),
2312                  (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL) );
2313     }
2314
2315     cache_user_id( keyblock );
2316     
2317     return 1; /* found */
2318 }
2319
2320
2321 static int
2322 lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
2323 {
2324     int rc;
2325     KBNODE secblock = NULL; /* helper */
2326     int no_suitable_key = 0;
2327     
2328     rc = 0;
2329     while (!(rc = keydb_search (ctx->kr_handle, ctx->items, ctx->nitems))) {
2330         /* If we are searching for the first key we have to make sure
2331            that the next interation does not no an implicit reset.
2332            This can be triggered by an empty key ring. */
2333         if (ctx->nitems && ctx->items->mode == KEYDB_SEARCH_MODE_FIRST)
2334             ctx->items->mode = KEYDB_SEARCH_MODE_NEXT;
2335
2336         rc = keydb_get_keyblock (ctx->kr_handle, &ctx->keyblock);
2337         if (rc) {
2338             log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
2339             rc = 0;
2340             goto skip;
2341         }
2342                        
2343         if ( secmode ) {
2344             /* find the correspondig public key and use this 
2345              * this one for the selection process */
2346             u32 aki[2];
2347             KBNODE k = ctx->keyblock;
2348             
2349             if (k->pkt->pkttype != PKT_SECRET_KEY)
2350                 BUG();
2351
2352             keyid_from_sk (k->pkt->pkt.secret_key, aki);
2353             k = get_pubkeyblock (aki);
2354             if( !k ) {
2355                 if (!opt.quiet)
2356                     log_info(_("key %08lX: secret key without public key "
2357                                "- skipped\n"),  (ulong)aki[1] );
2358                 goto skip;
2359             }
2360             secblock = ctx->keyblock;
2361             ctx->keyblock = k;
2362
2363             premerge_public_with_secret ( ctx->keyblock, secblock );
2364         }
2365
2366         /* warning: node flag bits 0 and 1 should be preserved by
2367          * merge_selfsigs.  For secret keys, premerge did tranfer the
2368          * keys to the keyblock */
2369         merge_selfsigs ( ctx->keyblock );
2370         if ( finish_lookup (ctx) ) {
2371             no_suitable_key = 0;
2372             if ( secmode ) {
2373                 merge_public_with_secret ( ctx->keyblock,
2374                                            secblock);
2375                 release_kbnode (secblock);
2376                 secblock = NULL;
2377             }
2378             goto found;
2379         }
2380         else
2381             no_suitable_key = 1;
2382         
2383       skip:
2384         /* release resources and continue search */
2385         if ( secmode ) {
2386             release_kbnode( secblock );
2387             secblock = NULL;
2388         }
2389         release_kbnode( ctx->keyblock );
2390         ctx->keyblock = NULL;
2391     }
2392
2393   found:
2394     if( rc && rc != -1 )
2395         log_error("keydb_search failed: %s\n", gpg_strerror (rc));
2396
2397     if( !rc ) {
2398         *ret_keyblock = ctx->keyblock; /* return the keyblock */
2399         ctx->keyblock = NULL;
2400     }
2401     else if (rc == -1 && no_suitable_key)
2402          rc = secmode ? GPG_ERR_UNUSABLE_SECKEY : GPG_ERR_UNUSABLE_PUBKEY;
2403     else if( rc == -1 )
2404         rc = secmode ? GPG_ERR_NO_SECKEY : GPG_ERR_NO_PUBKEY;
2405
2406     if ( secmode ) {
2407         release_kbnode( secblock );
2408         secblock = NULL;
2409     }
2410     release_kbnode( ctx->keyblock );
2411     ctx->keyblock = NULL;
2412
2413     ctx->last_rc = rc;
2414     return rc;
2415 }
2416
2417
2418
2419
2420 /****************
2421  * FIXME: Replace by the generic function 
2422  *        It does not work as it is right now - it is used at 
2423  *        2 places:  a) to get the key for an anonyous recipient
2424  *                   b) to get the ultimately trusted keys.
2425  *        The a) usage might have some problems.
2426  *
2427  * set with_subkeys true to include subkeys
2428  * set with_spm true to include secret-parts-missing keys
2429  *
2430  * Enumerate all primary secret keys.  Caller must use these procedure:
2431  *  1) create a void pointer and initialize it to NULL
2432  *  2) pass this void pointer by reference to this function
2433  *     and provide space for the secret key (pass a buffer for sk)
2434  *  3) call this function as long as it does not return -1
2435  *     to indicate EOF.
2436  *  4) Always call this function a last time with SK set to NULL,
2437  *     so that can free it's context.
2438  */
2439 int
2440 enum_secret_keys( void **context, PKT_secret_key *sk,
2441                   int with_subkeys, int with_spm )
2442 {
2443     int rc=0;
2444     struct {
2445         int eof;
2446         int first;
2447         KEYDB_HANDLE hd;
2448         KBNODE keyblock;
2449         KBNODE node;
2450     } *c = *context;
2451
2452
2453     if( !c ) { /* make a new context */
2454         c = xcalloc (1, sizeof *c );
2455         *context = c;
2456         c->hd = keydb_new (1);
2457         c->first = 1;
2458         c->keyblock = NULL;
2459         c->node = NULL;
2460     }
2461
2462     if( !sk ) { /* free the context */
2463         keydb_release (c->hd);
2464         release_kbnode (c->keyblock);
2465         xfree ( c );
2466         *context = NULL;
2467         return 0;
2468     }
2469
2470     if( c->eof )
2471         return -1;
2472
2473     do {
2474         /* get the next secret key from the current keyblock */
2475         for (; c->node; c->node = c->node->next) {
2476             if ((c->node->pkt->pkttype == PKT_SECRET_KEY
2477                 || (with_subkeys
2478                     && c->node->pkt->pkttype == PKT_SECRET_SUBKEY) )
2479                 && !(c->node->pkt->pkt.secret_key->protect.s2k.mode==1001
2480                      && !with_spm)) {
2481                 copy_secret_key (sk, c->node->pkt->pkt.secret_key );
2482                 c->node = c->node->next;
2483                 return 0; /* found */
2484             }
2485         }
2486         release_kbnode (c->keyblock);
2487         c->keyblock = c->node = NULL;
2488         
2489         rc = c->first? keydb_search_first (c->hd) : keydb_search_next (c->hd);
2490         c->first = 0;
2491         if (rc) {
2492             keydb_release (c->hd); c->hd = NULL;
2493             c->eof = 1;
2494             return -1; /* eof */
2495         }
2496         
2497         rc = keydb_get_keyblock (c->hd, &c->keyblock);
2498         c->node = c->keyblock;
2499     } while (!rc);
2500
2501     return rc; /* error */
2502 }
2503
2504
2505 \f
2506 /*********************************************
2507  ***********  user ID printing helpers *******
2508  *********************************************/
2509
2510 /****************
2511  * Return a string with a printable representation of the user_id.
2512  * this string must be freed by m_free.
2513  */
2514 char*
2515 get_user_id_string( u32 *keyid )
2516 {
2517     user_id_db_t r;
2518     char *p;
2519     int pass=0;
2520     /* try it two times; second pass reads from key resources */
2521     do {
2522         for(r=user_id_db; r; r = r->next ) {
2523             keyid_list_t a;
2524             for (a=r->keyids; a; a= a->next ) {
2525                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2526                     p = xmalloc ( r->len + 10 );
2527                     sprintf(p, "%08lX %.*s",
2528                             (ulong)keyid[1], r->len, r->name );
2529                     return p;
2530                 }
2531             }
2532         }
2533     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2534     p = xmalloc ( 15 );
2535     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
2536     return p;
2537 }
2538
2539
2540 char*
2541 get_user_id_string_printable ( u32 *keyid )
2542 {
2543     char *p = get_user_id_string( keyid );
2544     char *p2 = utf8_to_native( p, strlen(p), 0 );
2545     xfree (p);
2546     p = make_printable_string (p2, strlen (p2), 0);
2547     xfree (p2);
2548     return p;
2549 }
2550
2551
2552 char*
2553 get_long_user_id_string( u32 *keyid )
2554 {
2555     user_id_db_t r;
2556     char *p;
2557     int pass=0;
2558     /* try it two times; second pass reads from key resources */
2559     do {
2560         for(r=user_id_db; r; r = r->next ) {
2561             keyid_list_t a;
2562             for (a=r->keyids; a; a= a->next ) {
2563                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2564                     p = xmalloc ( r->len + 20 );
2565                     sprintf(p, "%08lX%08lX %.*s",
2566                             (ulong)keyid[0], (ulong)keyid[1],
2567                             r->len, r->name );
2568                     return p;
2569                 }
2570             }
2571         }
2572     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2573     p = xmalloc ( 25 );
2574     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2575     return p;
2576 }
2577
2578 char*
2579 get_user_id( u32 *keyid, size_t *rn )
2580 {
2581     user_id_db_t r;
2582     char *p;
2583     int pass=0;
2584
2585     /* try it two times; second pass reads from key resources */
2586     do {
2587         for(r=user_id_db; r; r = r->next ) {
2588             keyid_list_t a;
2589             for (a=r->keyids; a; a= a->next ) {
2590                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2591                     p = xmalloc ( r->len );
2592                     memcpy(p, r->name, r->len );
2593                     *rn = r->len;
2594                     return p;
2595                 }
2596             }
2597         }
2598     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2599     p = xstrdup ( _("[User id not found]") );
2600     *rn = strlen(p);
2601     return p;
2602 }
2603
2604 char*
2605 get_user_id_printable( u32 *keyid )
2606 {
2607     size_t rn;
2608     char *p = get_user_id( keyid, &rn );
2609     char *p2 = utf8_to_native( p, rn, 0 );
2610     xfree (p);
2611     p = make_printable_string (p2, strlen (p2), 0);
2612     xfree (p2);
2613     return p;
2614 }
2615
2616 KEYDB_HANDLE
2617 get_ctx_handle(GETKEY_CTX ctx)
2618 {
2619   return ctx->kr_handle;
2620 }