Merged most of David Shaw's changes in 1.3 since 2003-06-03.
[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 && spacep (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] && !spacep (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
1597                 if(sig->keyid[0] != kid[0] || sig->keyid[1]!=kid[1])
1598                   {
1599                     PKT_public_key *ultimate_pk;
1600
1601                     ultimate_pk=xcalloc (1,sizeof(*ultimate_pk));
1602
1603                     /* We don't want to use the full get_pubkey to
1604                        avoid infinite recursion in certain cases.
1605                        There is no reason to check that an ultimately
1606                        trusted key is still valid - if it has been
1607                        revoked or the user should also renmove the
1608                        ultimate trust flag.  */
1609                     if(get_pubkey_fast(ultimate_pk,sig->keyid)==0
1610                        && check_key_signature2(keyblock,k,ultimate_pk,
1611                                                NULL, NULL, NULL, NULL)==0
1612                        && get_ownertrust(ultimate_pk)==TRUST_ULTIMATE)
1613                       {
1614                         free_public_key(ultimate_pk);
1615                         pk->is_valid=1;
1616                         break;
1617                       }
1618
1619                     free_public_key(ultimate_pk);
1620                   }
1621               }
1622           }
1623       }
1624
1625     /* Record the highest selfsig version so we know if this is a v3
1626        key through and through, or a v3 key with a v4 selfsig
1627        somewhere.  This is useful in a few places to know if the key
1628        must be treated as PGP2-style or OpenPGP-style.  Note that a
1629        selfsig revocation with a higher version number will also raise
1630        this value.  This is okay since such a revocation must be
1631        issued by the user (i.e. it cannot be issued by someone else to
1632        modify the key behavior.) */
1633
1634     pk->selfsigversion=sigversion;
1635
1636     /* Now that we had a look at all user IDs we can now get some information
1637      * from those user IDs.
1638      */
1639     
1640     if ( !key_usage ) {
1641         /* find the latest user ID with key flags set */
1642         uiddate = 0; /* helper to find the latest user ID */
1643         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1644             k = k->next ) {
1645             if ( k->pkt->pkttype == PKT_USER_ID ) {
1646                 PKT_user_id *uid = k->pkt->pkt.user_id;
1647                 if ( uid->help_key_usage && uid->created > uiddate ) {
1648                     key_usage = uid->help_key_usage;
1649                     uiddate = uid->created;
1650                 }
1651             }
1652         }
1653     }
1654     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1655         key_usage = openpgp_pk_algo_usage ( pk->pubkey_algo );
1656     }
1657     else { /* check that the usage matches the usage as given by the algo */
1658         int x = openpgp_pk_algo_usage ( pk->pubkey_algo );
1659         if ( x ) /* mask it down to the actual allowed usage */
1660             key_usage &= x; 
1661     }
1662     pk->pubkey_usage = key_usage;
1663
1664     if ( !key_expire_seen ) {
1665         /* find the latest valid user ID with a key expiration set 
1666          * Note, that this may be a different one from the above because
1667          * some user IDs may have no expiration date set */
1668         uiddate = 0; 
1669         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1670             k = k->next ) {
1671             if ( k->pkt->pkttype == PKT_USER_ID ) {
1672                 PKT_user_id *uid = k->pkt->pkt.user_id;
1673                 if ( uid->help_key_expire && uid->created > uiddate ) {
1674                     key_expire = uid->help_key_expire;
1675                     uiddate = uid->created;
1676                 }
1677             }
1678         }
1679     }
1680
1681     /* Currently only v3 keys have a maximum expiration date, but I'll
1682        bet v5 keys get this feature again. */
1683     if(key_expire==0 || (pk->max_expiredate && key_expire>pk->max_expiredate))
1684       key_expire=pk->max_expiredate;
1685
1686     pk->has_expired = key_expire >= curtime? 0 : key_expire;
1687     pk->expiredate = key_expire;
1688
1689     /* Fixme: we should see how to get rid of the expiretime fields  but
1690      * this needs changes at other places too. */
1691
1692     /* and now find the real primary user ID and delete all others */
1693     uiddate = uiddate2 = 0;
1694     uidnode = uidnode2 = NULL;
1695     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1696         if ( k->pkt->pkttype == PKT_USER_ID &&
1697              !k->pkt->pkt.user_id->attrib_data) {
1698             PKT_user_id *uid = k->pkt->pkt.user_id;
1699             if (uid->is_primary)
1700               {
1701                 if(uid->created > uiddate)
1702                   {
1703                     uiddate = uid->created;
1704                     uidnode = k;
1705                   }
1706                 else if(uid->created==uiddate && uidnode)
1707                   {
1708                     /* The dates are equal, so we need to do a
1709                        different (and arbitrary) comparison.  This
1710                        should rarely, if ever, happen.  It's good to
1711                        try and guarantee that two different GnuPG
1712                        users with two different keyrings at least pick
1713                        the same primary. */
1714                     if(cmp_user_ids(uid,uidnode->pkt->pkt.user_id)>0)
1715                       uidnode=k;
1716                   }
1717               }
1718             else
1719               {
1720                 if(uid->created > uiddate2)
1721                   {
1722                     uiddate2 = uid->created;
1723                     uidnode2 = k;
1724                   }
1725                 else if(uid->created==uiddate2 && uidnode2)
1726                   {
1727                     if(cmp_user_ids(uid,uidnode2->pkt->pkt.user_id)>0)
1728                       uidnode2=k;
1729                   }
1730               }
1731         }
1732     }
1733     if ( uidnode ) {
1734         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1735             k = k->next ) {
1736             if ( k->pkt->pkttype == PKT_USER_ID &&
1737                  !k->pkt->pkt.user_id->attrib_data) {
1738                 PKT_user_id *uid = k->pkt->pkt.user_id;
1739                 if ( k != uidnode ) 
1740                     uid->is_primary = 0;
1741             }
1742         }
1743     }
1744     else if( uidnode2 ) {
1745         /* none is flagged primary - use the latest user ID we have,
1746            and disambiguate with the arbitrary packet comparison. */
1747         uidnode2->pkt->pkt.user_id->is_primary = 1;
1748     }
1749     else
1750       {
1751         /* None of our uids were self-signed, so pick the one that
1752            sorts first to be the primary.  This is the best we can do
1753            here since there are no self sigs to date the uids. */
1754
1755         uidnode = NULL;
1756
1757         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1758             k = k->next )
1759           {
1760             if(k->pkt->pkttype==PKT_USER_ID
1761                && !k->pkt->pkt.user_id->attrib_data)
1762               {
1763                 if(!uidnode)
1764                   {
1765                     uidnode=k;
1766                     uidnode->pkt->pkt.user_id->is_primary=1;
1767                     continue;
1768                   }
1769                 else
1770                   {
1771                     if(cmp_user_ids(k->pkt->pkt.user_id,
1772                                     uidnode->pkt->pkt.user_id)>0)
1773                       {
1774                         uidnode->pkt->pkt.user_id->is_primary=0;
1775                         uidnode=k;
1776                         uidnode->pkt->pkt.user_id->is_primary=1;
1777                       }
1778                     else
1779                       k->pkt->pkt.user_id->is_primary=0; /* just to be
1780                                                             safe */
1781                   }
1782               }
1783           }
1784       }
1785 }
1786
1787
1788 static void
1789 merge_selfsigs_subkey( KBNODE keyblock, KBNODE subnode )
1790 {
1791     PKT_public_key *mainpk = NULL, *subpk = NULL;
1792     PKT_signature *sig;
1793     KBNODE k;
1794     u32 mainkid[2];
1795     u32 sigdate = 0;
1796     KBNODE signode;
1797     u32 curtime = make_timestamp ();
1798     unsigned int key_usage = 0;
1799     u32 keytimestamp = 0;
1800     u32 key_expire = 0;
1801     const byte *p;
1802     size_t n;
1803
1804     if ( subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1805         BUG ();
1806     mainpk = keyblock->pkt->pkt.public_key;
1807     if ( mainpk->version < 4 )
1808         return; /* (actually this should never happen) */
1809     keyid_from_pk( mainpk, mainkid );
1810     subpk = subnode->pkt->pkt.public_key;
1811     keytimestamp = subpk->timestamp;
1812
1813     subpk->is_valid = 0;
1814     subpk->main_keyid[0] = mainpk->main_keyid[0];
1815     subpk->main_keyid[1] = mainpk->main_keyid[1];
1816
1817     /* find the latest key binding self-signature. */
1818     signode = NULL;
1819     sigdate = 0; /* helper to find the latest signature */
1820     for(k=subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1821                                                         k = k->next ) {
1822         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1823             sig = k->pkt->pkt.signature;
1824             if ( sig->keyid[0] == mainkid[0] && sig->keyid[1]==mainkid[1] ) { 
1825                 if ( check_key_signature( keyblock, k, NULL ) )
1826                     ; /* signature did not verify */
1827                 else if ( IS_SUBKEY_REV (sig) ) {
1828                   /* Note that this means that the date on a
1829                      revocation sig does not matter - even if the
1830                      binding sig is dated after the revocation sig,
1831                      the subkey is still marked as revoked.  This
1832                      seems ok, as it is just as easy to make new
1833                      subkeys rather than re-sign old ones as the
1834                      problem is in the distribution.  Plus, PGP (7)
1835                      does this the same way.  */
1836                     subpk->is_revoked = 1;
1837                     /* although we could stop now, we continue to 
1838                      * figure out other information like the old expiration
1839                      * time */
1840                 }
1841                 else if ( IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate ) {
1842                     if(sig->flags.expired)
1843                         ; /* signature has expired - ignore it */
1844                     else {
1845                         sigdate = sig->timestamp;
1846                         signode = k;
1847                     }
1848                 }
1849             }
1850         }
1851     }
1852
1853     if ( !signode ) {
1854         return;  /* no valid key binding */
1855     }
1856
1857     subpk->is_valid = 1;
1858     sig = signode->pkt->pkt.signature;
1859         
1860     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n );
1861     if ( p && n ) {
1862         /* first octet of the keyflags */   
1863         if ( (*p & 0x03) )
1864             key_usage |= PUBKEY_USAGE_SIG;
1865         if ( (*p & 0x0c) )    
1866             key_usage |= PUBKEY_USAGE_ENC;
1867         if ( (*p & 0x20) )    
1868             key_usage |= PUBKEY_USAGE_AUTH;
1869     }
1870     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1871         key_usage = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1872     }
1873     else { /* check that the usage matches the usage as given by the algo */
1874         int x = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1875         if ( x ) /* mask it down to the actual allowed usage */
1876             key_usage &= x; 
1877     }
1878     subpk->pubkey_usage = key_usage;
1879     
1880     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1881     if ( p ) 
1882         key_expire = keytimestamp + buffer_to_u32(p);
1883     else
1884         key_expire = 0;
1885     subpk->has_expired = key_expire >= curtime? 0 : key_expire;
1886     subpk->expiredate = key_expire;
1887 }
1888
1889
1890
1891 /* 
1892  * Merge information from the self-signatures with the key, so that
1893  * we can later use them more easy.
1894  * The function works by first applying the self signatures to the
1895  * primary key and the to each subkey.
1896  * Here are the rules we use to decide which inormation from which
1897  * self-signature is used:
1898  * We check all self signatures or validity and ignore all invalid signatures.
1899  * All signatures are then ordered by their creation date ....
1900  * For the primary key:
1901  *   FIXME the docs    
1902  */
1903 static void
1904 merge_selfsigs( KBNODE keyblock )
1905 {
1906     KBNODE k;
1907     int revoked;
1908     PKT_public_key *main_pk;
1909     prefitem_t *prefs;
1910     int mdc_feature;
1911
1912     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY ) {
1913         if (keyblock->pkt->pkttype == PKT_SECRET_KEY ) {
1914             log_error ("expected public key but found secret key "
1915                        "- must stop\n");
1916             /* we better exit here becuase a public key is expected at
1917                other places too.  FIXME: Figure this out earlier and
1918                don't get to here at all */
1919             g10_exit (1);
1920         }
1921         BUG ();
1922     }
1923
1924     merge_selfsigs_main ( keyblock, &revoked );
1925
1926     /* now merge in the data from each of the subkeys */
1927     for(k=keyblock; k; k = k->next ) {
1928         if (  k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1929             merge_selfsigs_subkey ( keyblock, k );
1930         }
1931     }
1932
1933     main_pk = keyblock->pkt->pkt.public_key;
1934     if ( revoked || main_pk->has_expired || !main_pk->is_valid ) {
1935         /* if the primary key is revoked, expired, or invalid we
1936          * better set the appropriate flags on that key and all
1937          * subkeys */
1938         for(k=keyblock; k; k = k->next ) {
1939             if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1940                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1941                 PKT_public_key *pk = k->pkt->pkt.public_key;
1942                 if(!main_pk->is_valid)
1943                   pk->is_valid = 0;
1944                 if(revoked)
1945                   pk->is_revoked = 1;
1946                 if(main_pk->has_expired)
1947                   pk->has_expired = main_pk->has_expired;
1948             }
1949         }
1950         return;
1951     }
1952
1953     /* set the preference list of all keys to those of the primary real
1954      * user ID.  Note: we use these preferences when we don't know by
1955      * which user ID the key has been selected.
1956      * fixme: we should keep atoms of commonly used preferences or
1957      * use reference counting to optimize the preference lists storage.
1958      * FIXME: it might be better to use the intersection of 
1959      * all preferences.
1960      * Do a similar thing for the MDC feature flag.
1961      */
1962     prefs = NULL;
1963     mdc_feature = 0;
1964     for (k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next) {
1965         if (k->pkt->pkttype == PKT_USER_ID
1966             && !k->pkt->pkt.user_id->attrib_data
1967             && k->pkt->pkt.user_id->is_primary) {
1968             prefs = k->pkt->pkt.user_id->prefs;
1969             mdc_feature = k->pkt->pkt.user_id->mdc_feature;
1970             break;
1971         }
1972     }    
1973     for(k=keyblock; k; k = k->next ) {
1974         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1975              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1976             PKT_public_key *pk = k->pkt->pkt.public_key;
1977             if (pk->prefs)
1978                 xfree (pk->prefs);
1979             pk->prefs = copy_prefs (prefs);
1980             pk->mdc_feature = mdc_feature;
1981         }
1982     }
1983 }
1984
1985
1986 /*
1987  * Merge the secret keys from secblock into the pubblock thereby
1988  * replacing the public (sub)keys with their secret counterparts Hmmm:
1989  * It might be better to get away from the concept of entire secret
1990  * keys at all and have a way to store just the real secret parts
1991  * from the key.
1992  */
1993 static void
1994 merge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
1995 {
1996     KBNODE pub;
1997
1998     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
1999     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2000     
2001     for (pub=pubblock; pub; pub = pub->next ) {
2002         if ( pub->pkt->pkttype == PKT_PUBLIC_KEY ) {
2003              PKT_public_key *pk = pub->pkt->pkt.public_key;
2004              PKT_secret_key *sk = secblock->pkt->pkt.secret_key;
2005              assert ( pub == pubblock ); /* only in the first node */
2006              /* there is nothing to compare in this case, so just replace
2007               * some information */
2008              copy_public_parts_to_secret_key ( pk, sk );
2009              free_public_key ( pk );
2010              pub->pkt->pkttype = PKT_SECRET_KEY;
2011              pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2012         }
2013         else if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2014             KBNODE sec;
2015             PKT_public_key *pk = pub->pkt->pkt.public_key;
2016
2017             /* this is more complicated: it may happen that the sequence
2018              * of the subkeys dosn't match, so we have to find the
2019              * appropriate secret key */
2020             for (sec=secblock->next; sec; sec = sec->next ) {
2021                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2022                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2023                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2024                         copy_public_parts_to_secret_key ( pk, sk );
2025                         free_public_key ( pk );
2026                         pub->pkt->pkttype = PKT_SECRET_SUBKEY;
2027                         pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2028                         break;
2029                     }
2030                 }
2031             }
2032             if ( !sec ) 
2033                 BUG(); /* already checked in premerge */
2034         }
2035     }
2036 }
2037
2038 /* This function checks that for every public subkey a corresponding
2039  * secret subkey is available and deletes the public subkey otherwise.
2040  * We need this function because we can't delete it later when we
2041  * actually merge the secret parts into the pubring.
2042  * The function also plays some games with the node flags.
2043  */
2044 static void
2045 premerge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
2046 {
2047     KBNODE last, pub;
2048
2049     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
2050     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2051     
2052     for (pub=pubblock,last=NULL; pub; last = pub, pub = pub->next ) {
2053         pub->flag &= ~3; /* reset bits 0 and 1 */
2054         if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2055             KBNODE sec;
2056             PKT_public_key *pk = pub->pkt->pkt.public_key;
2057
2058             for (sec=secblock->next; sec; sec = sec->next ) {
2059                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2060                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2061                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2062                         if ( sk->protect.s2k.mode == 1001 ) {
2063                             /* The secret parts are not available so
2064                                we can't use that key for signing etc.
2065                                Fix the pubkey usage */
2066                             pk->pubkey_usage &= ~(PUBKEY_USAGE_SIG
2067                                                   |PUBKEY_USAGE_AUTH);
2068                         }
2069                         /* transfer flag bits 0 and 1 to the pubblock */
2070                         pub->flag |= (sec->flag &3);
2071                         break;
2072                     }
2073                 }
2074             }
2075             if ( !sec ) {
2076                 KBNODE next, ll;
2077
2078                 if (opt.verbose)
2079                   log_info ( _("no secret subkey "
2080                                "for public subkey %08lX - ignoring\n"),  
2081                            (ulong)keyid_from_pk (pk,NULL) );
2082                 /* we have to remove the subkey in this case */
2083                 assert ( last );
2084                 /* find the next subkey */
2085                 for (next=pub->next,ll=pub;
2086                      next && pub->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2087                      ll = next, next = next->next ) 
2088                     ;
2089                 /* make new link */
2090                 last->next = next;
2091                 /* release this public subkey with all sigs */
2092                 ll->next = NULL;
2093                 release_kbnode( pub );
2094                 /* let the loop continue */
2095                 pub = last;
2096             }
2097         }
2098     }
2099     /* We need to copy the found bits (0 and 1) from the secret key to
2100        the public key.  This has already been done for the subkeys but
2101        got lost on the primary key - fix it here *. */
2102     pubblock->flag |= (secblock->flag & 3);
2103 }
2104
2105
2106
2107 \f
2108 /* See see whether the key fits
2109  * our requirements and in case we do not
2110  * request the primary key, we should select
2111  * a suitable subkey.
2112  * FIXME: Check against PGP 7 whether we still need a kludge
2113  *        to favor type 16 keys over type 20 keys when type 20
2114  *        has not been explitely requested.
2115  * Returns: True when a suitable key has been found.
2116  *
2117  * We have to distinguish four cases:  FIXME!
2118  *  1. No usage and no primary key requested
2119  *     Examples for this case are that we have a keyID to be used
2120  *     for decrytion or verification.
2121  *  2. No usage but primary key requested
2122  *     This is the case for all functions which work on an
2123  *     entire keyblock, e.g. for editing or listing
2124  *  3. Usage and primary key requested
2125  *     FXME
2126  *  4. Usage but no primary key requested
2127  *     FIXME
2128  * FIXME: Tell what is going to happen here and something about the rationale
2129  * Note: We don't use this function if no specific usage is requested;
2130  *       This way the getkey functions can be used for plain key listings.
2131  *
2132  * CTX ist the keyblock we are investigating, if FOUNDK is not NULL this
2133  * is the key we actually found by looking at the keyid or a fingerprint and
2134  * may eitehr point to the primary or one of the subkeys.
2135  */
2136
2137 static int
2138 finish_lookup (GETKEY_CTX ctx)
2139 {
2140     KBNODE keyblock = ctx->keyblock;
2141     KBNODE k;
2142     KBNODE foundk = NULL;
2143     PKT_user_id *foundu = NULL;
2144 #define USAGE_MASK  (PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC)
2145     unsigned int req_usage = ( ctx->req_usage & USAGE_MASK );
2146     /* Request the primary if we're certifying another key, and also
2147        if signing data while --pgp6 or --pgp7 is on since pgp 6 and 7
2148        do not understand signatures made by a signing subkey.  PGP 8
2149        does. */
2150     int req_prim = (ctx->req_usage & PUBKEY_USAGE_CERT) ||
2151       ((PGP6 || PGP7) && (ctx->req_usage & PUBKEY_USAGE_SIG));
2152     u32 latest_date;
2153     KBNODE latest_key;
2154     u32 curtime = make_timestamp ();
2155
2156     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
2157    
2158     ctx->found_key = NULL;
2159
2160     if (ctx->exact) {
2161         for (k=keyblock; k; k = k->next) {
2162             if ( (k->flag & 1) ) {
2163                 assert ( k->pkt->pkttype == PKT_PUBLIC_KEY
2164                          || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
2165                 foundk = k;
2166                 break;
2167             }
2168         }
2169     }
2170
2171     for (k=keyblock; k; k = k->next) {
2172         if ( (k->flag & 2) ) {
2173             assert (k->pkt->pkttype == PKT_USER_ID);
2174             foundu = k->pkt->pkt.user_id;
2175             break;
2176         }
2177     }
2178
2179     if ( DBG_CACHE )
2180         log_debug( "finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
2181                    (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL),
2182                    foundk? "one":"all", req_usage);
2183
2184     if (!req_usage) {
2185         latest_key = foundk? foundk:keyblock;
2186         goto found;
2187     }
2188     
2189     if (!req_usage) {
2190         PKT_public_key *pk = foundk->pkt->pkt.public_key;
2191         if (pk->user_id)
2192             free_user_id (pk->user_id);
2193         pk->user_id = scopy_user_id (foundu);
2194         ctx->found_key = foundk;
2195         cache_user_id( keyblock );
2196         return 1; /* found */
2197     }
2198     
2199     latest_date = 0;
2200     latest_key  = NULL;
2201     /* do not look at subkeys if a certification key is requested */
2202     if ((!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) && !req_prim) {
2203         KBNODE nextk;
2204         /* either start a loop or check just this one subkey */
2205         for (k=foundk?foundk:keyblock; k; k = nextk ) {
2206             PKT_public_key *pk;
2207             nextk = k->next;
2208             if ( k->pkt->pkttype != PKT_PUBLIC_SUBKEY )
2209                 continue;
2210             if ( foundk )
2211                 nextk = NULL;  /* what a hack */
2212             pk = k->pkt->pkt.public_key;
2213             if (DBG_CACHE)
2214                 log_debug( "\tchecking subkey %08lX\n",
2215                            (ulong)keyid_from_pk( pk, NULL));
2216             if ( !pk->is_valid ) {
2217                 if (DBG_CACHE)
2218                     log_debug( "\tsubkey not valid\n");
2219                 continue;
2220             }
2221             if ( pk->is_revoked ) {
2222                 if (DBG_CACHE)
2223                     log_debug( "\tsubkey has been revoked\n");
2224                 continue;
2225             }
2226             if ( pk->has_expired ) {
2227                 if (DBG_CACHE)
2228                     log_debug( "\tsubkey has expired\n");
2229                 continue;
2230             }
2231             if ( pk->timestamp > curtime && !opt.ignore_valid_from ) {
2232                 if (DBG_CACHE)
2233                     log_debug( "\tsubkey not yet valid\n");
2234                 continue;
2235             }
2236             
2237             if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2238                 if (DBG_CACHE)
2239                     log_debug( "\tusage does not match: want=%x have=%x\n",
2240                                req_usage, pk->pubkey_usage );
2241                 continue;
2242             }
2243
2244             if (DBG_CACHE)
2245                 log_debug( "\tsubkey looks fine\n");
2246             if ( pk->timestamp > latest_date ) {
2247                 latest_date = pk->timestamp;
2248                 latest_key  = k;
2249             }
2250         }
2251     }
2252
2253     /* Okay now try the primary key unless we want an exact 
2254      * key ID match on a subkey */
2255     if ((!latest_key && !(ctx->exact && foundk != keyblock)) || req_prim) {
2256         PKT_public_key *pk;
2257         if (DBG_CACHE && !foundk && !req_prim )
2258             log_debug( "\tno suitable subkeys found - trying primary\n");
2259         pk = keyblock->pkt->pkt.public_key;
2260         if ( !pk->is_valid ) {
2261             if (DBG_CACHE)
2262                 log_debug( "\tprimary key not valid\n");
2263         }
2264         else if ( pk->is_revoked ) {
2265             if (DBG_CACHE)
2266                 log_debug( "\tprimary key has been revoked\n");
2267         }
2268         else if ( pk->has_expired ) {
2269             if (DBG_CACHE)
2270                 log_debug( "\tprimary key has expired\n");
2271         }
2272         else  if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2273             if (DBG_CACHE)
2274                 log_debug( "\tprimary key usage does not match: "
2275                            "want=%x have=%x\n",
2276                            req_usage, pk->pubkey_usage );
2277         }
2278         else { /* okay */
2279             if (DBG_CACHE)
2280                 log_debug( "\tprimary key may be used\n");
2281             latest_key = keyblock;
2282             latest_date = pk->timestamp;
2283         }
2284     }
2285     
2286     if ( !latest_key ) {
2287         if (DBG_CACHE)
2288             log_debug("\tno suitable key found -  giving up\n");
2289         return 0;
2290     }
2291
2292  found:
2293     if (DBG_CACHE)
2294         log_debug( "\tusing key %08lX\n",
2295                 (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL) );
2296
2297     if (latest_key) {
2298         PKT_public_key *pk = latest_key->pkt->pkt.public_key;
2299         if (pk->user_id)
2300             free_user_id (pk->user_id);
2301         pk->user_id = scopy_user_id (foundu);
2302     }    
2303         
2304     ctx->found_key = latest_key;
2305
2306     if (latest_key != keyblock && opt.verbose) {
2307         log_info(_("using secondary key %08lX "
2308                    "instead of primary key %08lX\n"),
2309                  (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL),
2310                  (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL) );
2311     }
2312
2313     cache_user_id( keyblock );
2314     
2315     return 1; /* found */
2316 }
2317
2318
2319 static int
2320 lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
2321 {
2322     int rc;
2323     KBNODE secblock = NULL; /* helper */
2324     int no_suitable_key = 0;
2325     
2326     rc = 0;
2327     while (!(rc = keydb_search (ctx->kr_handle, ctx->items, ctx->nitems))) {
2328         /* If we are searching for the first key we have to make sure
2329            that the next interation does not no an implicit reset.
2330            This can be triggered by an empty key ring. */
2331         if (ctx->nitems && ctx->items->mode == KEYDB_SEARCH_MODE_FIRST)
2332             ctx->items->mode = KEYDB_SEARCH_MODE_NEXT;
2333
2334         rc = keydb_get_keyblock (ctx->kr_handle, &ctx->keyblock);
2335         if (rc) {
2336             log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
2337             rc = 0;
2338             goto skip;
2339         }
2340                        
2341         if ( secmode ) {
2342             /* find the correspondig public key and use this 
2343              * this one for the selection process */
2344             u32 aki[2];
2345             KBNODE k = ctx->keyblock;
2346             
2347             if (k->pkt->pkttype != PKT_SECRET_KEY)
2348                 BUG();
2349
2350             keyid_from_sk (k->pkt->pkt.secret_key, aki);
2351             k = get_pubkeyblock (aki);
2352             if( !k ) {
2353                 if (!opt.quiet)
2354                     log_info(_("key %08lX: secret key without public key "
2355                                "- skipped\n"),  (ulong)aki[1] );
2356                 goto skip;
2357             }
2358             secblock = ctx->keyblock;
2359             ctx->keyblock = k;
2360
2361             premerge_public_with_secret ( ctx->keyblock, secblock );
2362         }
2363
2364         /* warning: node flag bits 0 and 1 should be preserved by
2365          * merge_selfsigs.  For secret keys, premerge did tranfer the
2366          * keys to the keyblock */
2367         merge_selfsigs ( ctx->keyblock );
2368         if ( finish_lookup (ctx) ) {
2369             no_suitable_key = 0;
2370             if ( secmode ) {
2371                 merge_public_with_secret ( ctx->keyblock,
2372                                            secblock);
2373                 release_kbnode (secblock);
2374                 secblock = NULL;
2375             }
2376             goto found;
2377         }
2378         else
2379             no_suitable_key = 1;
2380         
2381       skip:
2382         /* release resources and continue search */
2383         if ( secmode ) {
2384             release_kbnode( secblock );
2385             secblock = NULL;
2386         }
2387         release_kbnode( ctx->keyblock );
2388         ctx->keyblock = NULL;
2389     }
2390
2391   found:
2392     if( rc && rc != -1 )
2393         log_error("keydb_search failed: %s\n", gpg_strerror (rc));
2394
2395     if( !rc ) {
2396         *ret_keyblock = ctx->keyblock; /* return the keyblock */
2397         ctx->keyblock = NULL;
2398     }
2399     else if (rc == -1 && no_suitable_key)
2400          rc = secmode ? GPG_ERR_UNUSABLE_SECKEY : GPG_ERR_UNUSABLE_PUBKEY;
2401     else if( rc == -1 )
2402         rc = secmode ? GPG_ERR_NO_SECKEY : GPG_ERR_NO_PUBKEY;
2403
2404     if ( secmode ) {
2405         release_kbnode( secblock );
2406         secblock = NULL;
2407     }
2408     release_kbnode( ctx->keyblock );
2409     ctx->keyblock = NULL;
2410
2411     ctx->last_rc = rc;
2412     return rc;
2413 }
2414
2415
2416
2417
2418 /****************
2419  * FIXME: Replace by the generic function 
2420  *        It does not work as it is right now - it is used at 
2421  *        2 places:  a) to get the key for an anonyous recipient
2422  *                   b) to get the ultimately trusted keys.
2423  *        The a) usage might have some problems.
2424  *
2425  * set with_subkeys true to include subkeys
2426  * set with_spm true to include secret-parts-missing keys
2427  *
2428  * Enumerate all primary secret keys.  Caller must use these procedure:
2429  *  1) create a void pointer and initialize it to NULL
2430  *  2) pass this void pointer by reference to this function
2431  *     and provide space for the secret key (pass a buffer for sk)
2432  *  3) call this function as long as it does not return -1
2433  *     to indicate EOF.
2434  *  4) Always call this function a last time with SK set to NULL,
2435  *     so that can free it's context.
2436  */
2437 int
2438 enum_secret_keys( void **context, PKT_secret_key *sk,
2439                   int with_subkeys, int with_spm )
2440 {
2441     int rc=0;
2442     struct {
2443         int eof;
2444         int first;
2445         KEYDB_HANDLE hd;
2446         KBNODE keyblock;
2447         KBNODE node;
2448     } *c = *context;
2449
2450
2451     if( !c ) { /* make a new context */
2452         c = xcalloc (1, sizeof *c );
2453         *context = c;
2454         c->hd = keydb_new (1);
2455         c->first = 1;
2456         c->keyblock = NULL;
2457         c->node = NULL;
2458     }
2459
2460     if( !sk ) { /* free the context */
2461         keydb_release (c->hd);
2462         release_kbnode (c->keyblock);
2463         xfree ( c );
2464         *context = NULL;
2465         return 0;
2466     }
2467
2468     if( c->eof )
2469         return -1;
2470
2471     do {
2472         /* get the next secret key from the current keyblock */
2473         for (; c->node; c->node = c->node->next) {
2474             if ((c->node->pkt->pkttype == PKT_SECRET_KEY
2475                 || (with_subkeys
2476                     && c->node->pkt->pkttype == PKT_SECRET_SUBKEY) )
2477                 && !(c->node->pkt->pkt.secret_key->protect.s2k.mode==1001
2478                      && !with_spm)) {
2479                 copy_secret_key (sk, c->node->pkt->pkt.secret_key );
2480                 c->node = c->node->next;
2481                 return 0; /* found */
2482             }
2483         }
2484         release_kbnode (c->keyblock);
2485         c->keyblock = c->node = NULL;
2486         
2487         rc = c->first? keydb_search_first (c->hd) : keydb_search_next (c->hd);
2488         c->first = 0;
2489         if (rc) {
2490             keydb_release (c->hd); c->hd = NULL;
2491             c->eof = 1;
2492             return -1; /* eof */
2493         }
2494         
2495         rc = keydb_get_keyblock (c->hd, &c->keyblock);
2496         c->node = c->keyblock;
2497     } while (!rc);
2498
2499     return rc; /* error */
2500 }
2501
2502
2503 \f
2504 /*********************************************
2505  ***********  user ID printing helpers *******
2506  *********************************************/
2507
2508 /****************
2509  * Return a string with a printable representation of the user_id.
2510  * this string must be freed by m_free.
2511  */
2512 char*
2513 get_user_id_string( u32 *keyid )
2514 {
2515     user_id_db_t r;
2516     char *p;
2517     int pass=0;
2518     /* try it two times; second pass reads from key resources */
2519     do {
2520         for(r=user_id_db; r; r = r->next ) {
2521             keyid_list_t a;
2522             for (a=r->keyids; a; a= a->next ) {
2523                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2524                     p = xmalloc ( r->len + 10 );
2525                     sprintf(p, "%08lX %.*s",
2526                             (ulong)keyid[1], r->len, r->name );
2527                     return p;
2528                 }
2529             }
2530         }
2531     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2532     p = xmalloc ( 15 );
2533     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
2534     return p;
2535 }
2536
2537
2538 char*
2539 get_user_id_string_printable ( u32 *keyid )
2540 {
2541     char *p = get_user_id_string( keyid );
2542     char *p2 = utf8_to_native( p, strlen(p), 0 );
2543     xfree (p);
2544     p = make_printable_string (p2, strlen (p2), 0);
2545     xfree (p2);
2546     return p;
2547 }
2548
2549
2550 char*
2551 get_long_user_id_string( u32 *keyid )
2552 {
2553     user_id_db_t r;
2554     char *p;
2555     int pass=0;
2556     /* try it two times; second pass reads from key resources */
2557     do {
2558         for(r=user_id_db; r; r = r->next ) {
2559             keyid_list_t a;
2560             for (a=r->keyids; a; a= a->next ) {
2561                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2562                     p = xmalloc ( r->len + 20 );
2563                     sprintf(p, "%08lX%08lX %.*s",
2564                             (ulong)keyid[0], (ulong)keyid[1],
2565                             r->len, r->name );
2566                     return p;
2567                 }
2568             }
2569         }
2570     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2571     p = xmalloc ( 25 );
2572     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2573     return p;
2574 }
2575
2576 char*
2577 get_user_id( u32 *keyid, size_t *rn )
2578 {
2579     user_id_db_t r;
2580     char *p;
2581     int pass=0;
2582
2583     /* try it two times; second pass reads from key resources */
2584     do {
2585         for(r=user_id_db; r; r = r->next ) {
2586             keyid_list_t a;
2587             for (a=r->keyids; a; a= a->next ) {
2588                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2589                     p = xmalloc ( r->len );
2590                     memcpy(p, r->name, r->len );
2591                     *rn = r->len;
2592                     return p;
2593                 }
2594             }
2595         }
2596     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2597     p = xstrdup ( _("[User id not found]") );
2598     *rn = strlen(p);
2599     return p;
2600 }
2601
2602 char*
2603 get_user_id_printable( u32 *keyid )
2604 {
2605     size_t rn;
2606     char *p = get_user_id( keyid, &rn );
2607     char *p2 = utf8_to_native( p, rn, 0 );
2608     xfree (p);
2609     p = make_printable_string (p2, strlen (p2), 0);
2610     xfree (p2);
2611     return p;
2612 }
2613
2614 KEYDB_HANDLE
2615 get_ctx_handle(GETKEY_CTX ctx)
2616 {
2617   return ctx->kr_handle;
2618 }