* trustdb.h, trustdb.c (register_trusted_keyid): New. Adds a keyid to the
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *                                             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
28 #ifndef DISABLE_REGEX
29 #include <sys/types.h>
30 #ifdef USE_GNU_REGEX
31 #include "_regex.h"
32 #else
33 #include <regex.h>
34 #endif
35 #endif /* !DISABLE_REGEX */
36
37 #include "errors.h"
38 #include "iobuf.h"
39 #include "keydb.h"
40 #include "memory.h"
41 #include "util.h"
42 #include "options.h"
43 #include "packet.h"
44 #include "main.h"
45 #include "i18n.h"
46 #include "tdbio.h"
47 #include "trustdb.h"
48
49
50 /*
51  * A structure to store key identification as well as some stuff needed
52  * for validation 
53  */
54 struct key_item {
55   struct key_item *next;
56   unsigned int ownertrust,min_ownertrust;
57   byte trust_depth;
58   byte trust_value;
59   char *trust_regexp;
60   u32 kid[2];
61 };
62
63
64 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
65
66 /*
67  * Structure to keep track of keys, this is used as an array wherre
68  * the item right after the last one has a keyblock set to NULL. 
69  * Maybe we can drop this thing and replace it by key_item
70  */
71 struct key_array {
72   KBNODE keyblock;
73 };
74
75
76 /* control information for the trust DB */
77 static struct {
78     int init;
79     int level;
80     char *dbname;
81 } trustdb_args;
82
83 /* some globals */
84 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
85 static struct key_item *utk_list;      /* all ultimately trusted keys */
86
87 static int pending_check_trustdb;
88
89 static int validate_keys (int interactive);
90
91 \f
92 /**********************************************
93  ************* some helpers *******************
94  **********************************************/
95
96 static struct key_item *
97 new_key_item (void)
98 {
99   struct key_item *k;
100   
101   k = m_alloc_clear (sizeof *k);
102   return k;
103 }
104
105 static void
106 release_key_items (struct key_item *k)
107 {
108   struct key_item *k2;
109
110   for (; k; k = k2)
111     {
112       k2 = k->next;
113       m_free (k->trust_regexp);
114       m_free (k);
115     }
116 }
117
118 /*
119  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
120  * should be distributed equally over the 256 possible values (except
121  * for v3 keyIDs but we consider them as not important here). So we
122  * can just use 10 bits to index a table of 1024 key items. 
123  * Possible optimization: Don not use key_items but other hash_table when the
124  * duplicates lists gets too large. 
125  */
126 static KeyHashTable 
127 new_key_hash_table (void)
128 {
129   struct key_item **tbl;
130
131   tbl = m_alloc_clear (1024 * sizeof *tbl);
132   return tbl;
133 }
134
135 static void
136 release_key_hash_table (KeyHashTable tbl)
137 {
138   int i;
139
140   if (!tbl)
141     return;
142   for (i=0; i < 1024; i++)
143     release_key_items (tbl[i]);
144   m_free (tbl);
145 }
146
147 /* 
148  * Returns: True if the keyID is in the given hash table
149  */
150 static int
151 test_key_hash_table (KeyHashTable tbl, u32 *kid)
152 {
153   struct key_item *k;
154
155   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
156     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
157       return 1;
158   return 0;
159 }
160
161 /*
162  * Add a new key to the hash table.  The key is identified by its key ID.
163  */
164 static void
165 add_key_hash_table (KeyHashTable tbl, u32 *kid)
166 {
167   struct key_item *k, *kk;
168
169   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
170     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
171       return; /* already in table */
172   
173   kk = new_key_item ();
174   kk->kid[0] = kid[0];
175   kk->kid[1] = kid[1];
176   kk->next = tbl[(kid[1] & 0x03ff)];
177   tbl[(kid[1] & 0x03ff)] = kk;
178 }
179
180 /*
181  * Release a key_array
182  */
183 static void
184 release_key_array ( struct key_array *keys )
185 {
186     struct key_array *k;
187
188     if (keys) {
189         for (k=keys; k->keyblock; k++)
190             release_kbnode (k->keyblock);
191         m_free (keys);
192     }
193 }
194
195 \f
196 /*********************************************
197  **********  Initialization  *****************
198  *********************************************/
199
200
201
202 /*
203  * Used to register extra ultimately trusted keys - this has to be done
204  * before initializing the validation module.
205  * FIXME: Should be replaced by a function to add those keys to the trustdb.
206  */
207 void
208 register_trusted_keyid(u32 *keyid)
209 {
210   struct key_item *k;
211
212   k = new_key_item ();
213   k->kid[0] = keyid[0];
214   k->kid[1] = keyid[1];
215   k->next = user_utk_list;
216   user_utk_list = k;
217 }
218
219 void
220 register_trusted_key( const char *string )
221 {
222   KEYDB_SEARCH_DESC desc;
223
224   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID )
225     {
226       log_error(_("`%s' is not a valid long keyID\n"), string );
227       return;
228     }
229
230   register_trusted_keyid(desc.u.kid);
231 }
232
233 /*
234  * Helper to add a key to the global list of ultimately trusted keys.
235  * Retruns: true = inserted, false = already in in list.
236  */
237 static int
238 add_utk (u32 *kid)
239 {
240   struct key_item *k;
241
242   for (k = utk_list; k; k = k->next) 
243     {
244       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
245         {
246           return 0;
247         }
248     }
249
250   k = new_key_item ();
251   k->kid[0] = kid[0];
252   k->kid[1] = kid[1];
253   k->ownertrust = TRUST_ULTIMATE;
254   k->next = utk_list;
255   utk_list = k;
256   if( opt.verbose > 1 )
257     log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
258   return 1;
259 }
260
261
262 /****************
263  * Verify that all our secret keys are usable and put them into the utk_list.
264  */
265 static void
266 verify_own_keys(void)
267 {
268   TRUSTREC rec;
269   ulong recnum;
270   int rc;
271   struct key_item *k;
272
273   if (utk_list)
274     return;
275
276   /* scan the trustdb to find all ultimately trusted keys */
277   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
278     {
279       if ( rec.rectype == RECTYPE_TRUST 
280            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
281         {
282             byte *fpr = rec.r.trust.fingerprint;
283             int fprlen;
284             u32 kid[2];
285             
286             /* Problem: We do only use fingerprints in the trustdb but
287              * we need the keyID here to indetify the key; we can only
288              * use that ugly hack to distinguish between 16 and 20
289              * butes fpr - it does not work always so we better change
290              * the whole validation code to only work with
291              * fingerprints */
292             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
293             keyid_from_fingerprint (fpr, fprlen, kid);
294             if (!add_utk (kid))
295                 log_info(_("key %08lX occurs more than once in the trustdb\n"),
296                             (ulong)kid[1]);
297         }
298     }
299
300   /* Put any --trusted-key keys into the trustdb */
301   for (k = user_utk_list; k; k = k->next) 
302     {
303       if ( add_utk (k->kid) ) 
304         { /* not yet in trustDB as ultimately trusted */
305           PKT_public_key pk;
306
307           memset (&pk, 0, sizeof pk);
308           rc = get_pubkey (&pk, k->kid);
309           if (rc) {
310             log_info(_("key %08lX: no public key for trusted key - skipped\n"),
311                      (ulong)k->kid[1] );
312           }
313           else {
314             update_ownertrust (&pk,
315                                ((get_ownertrust (&pk) & ~TRUST_MASK)
316                                 | TRUST_ULTIMATE ));
317             release_public_key_parts (&pk);
318           }
319           log_info (_("key %08lX marked as ultimately trusted\n"),
320                     (ulong)k->kid[1]);
321         }
322     }
323
324
325   /* release the helper table table */
326   release_key_items (user_utk_list);
327   user_utk_list = NULL;
328   return;
329 }
330
331 \f
332 /*********************************************
333  *********** TrustDB stuff *******************
334  *********************************************/
335
336 /*
337  * Read a record but die if it does not exist
338  */
339 static void
340 read_record (ulong recno, TRUSTREC *rec, int rectype )
341 {
342   int rc = tdbio_read_record (recno, rec, rectype);
343   if (rc)
344     {
345       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
346                 recno, rec->rectype, g10_errstr(rc) );
347       tdbio_invalid();
348     }
349   if (rectype != rec->rectype)
350     {
351       log_error(_("trust record %lu is not of requested type %d\n"),
352                 rec->recnum, rectype);
353       tdbio_invalid();
354     }
355 }
356
357 /*
358  * Write a record and die on error
359  */
360 static void
361 write_record (TRUSTREC *rec)
362 {
363   int rc = tdbio_write_record (rec);
364   if (rc)
365     {
366       log_error(_("trust record %lu, type %d: write failed: %s\n"),
367                             rec->recnum, rec->rectype, g10_errstr(rc) );
368       tdbio_invalid();
369     }
370 }
371
372 /*
373  * sync the TrustDb and die on error
374  */
375 static void
376 do_sync(void)
377 {
378     int rc = tdbio_sync ();
379     if(rc)
380       {
381         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
382         g10_exit(2);
383       }
384 }
385
386 static const char *
387 trust_model_string(void)
388 {
389   switch(opt.trust_model)
390     {
391     case TM_PGP:     return "PGP";
392     case TM_CLASSIC: return "classic";
393     case TM_ALWAYS:  return "always";
394     default:         return "unknown";
395     }
396 }
397
398 /****************
399  * Perform some checks over the trustdb
400  *  level 0: only open the db
401  *        1: used for initial program startup
402  */
403 int
404 setup_trustdb( int level, const char *dbname )
405 {
406     /* just store the args */
407     if( trustdb_args.init )
408         return 0;
409     trustdb_args.level = level;
410     trustdb_args.dbname = dbname? m_strdup(dbname): NULL;
411     return 0;
412 }
413
414 void
415 init_trustdb()
416 {
417   int level = trustdb_args.level;
418   const char* dbname = trustdb_args.dbname;
419
420   if( trustdb_args.init )
421     return;
422
423   trustdb_args.init = 1;
424
425   if(level==0 || level==1)
426     {
427       int rc = tdbio_set_dbname( dbname, !!level );
428       if( rc )
429         log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
430     }
431   else
432     BUG();
433
434   if(opt.trust_model==TM_AUTO)
435     {
436       /* Try and set the trust model off of whatever the trustdb says
437          it is. */
438       opt.trust_model=tdbio_read_model();
439
440       /* Sanity check this ;) */
441       if(opt.trust_model!=TM_CLASSIC && opt.trust_model!=TM_PGP)
442         {
443           log_info(_("unable to use unknown trust model (%d) - "
444                      "assuming %s trust model\n"),opt.trust_model,"PGP");
445           opt.trust_model=TM_PGP;
446         }
447
448       if(opt.verbose)
449         log_info(_("using %s trust model\n"),trust_model_string());
450     }
451
452   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
453     {
454       /* Verify the list of ultimately trusted keys and move the
455          --trusted-keys list there as well. */
456       if(level==1)
457         verify_own_keys();
458
459       if(!tdbio_db_matches_options())
460         pending_check_trustdb=1;
461     }
462 }
463
464
465 /***********************************************
466  *************  Print helpers   ****************
467  ***********************************************/
468
469 /****************
470  * This function returns a letter for a trustvalue  Trust flags
471  * are ignore.
472  */
473 static int
474 trust_letter (unsigned int value)
475 {
476   switch( (value & TRUST_MASK) ) 
477     {
478     case TRUST_UNKNOWN:   return '-';
479     case TRUST_EXPIRED:   return 'e';
480     case TRUST_UNDEFINED: return 'q';
481     case TRUST_NEVER:     return 'n';
482     case TRUST_MARGINAL:  return 'm';
483     case TRUST_FULLY:     return 'f';
484     case TRUST_ULTIMATE:  return 'u';
485     default:              return '?';
486     }
487 }
488
489 /* The strings here are similar to those in
490    pkclist.c:do_edit_ownertrust() */
491 const char *
492 trust_value_to_string (unsigned int value)
493 {
494   switch( (value & TRUST_MASK) ) 
495     {
496     case TRUST_UNKNOWN:   return _("unknown");
497     case TRUST_EXPIRED:   return _("expired");
498     case TRUST_UNDEFINED: return _("undefined");
499     case TRUST_NEVER:     return _("never");
500     case TRUST_MARGINAL:  return _("marginal");
501     case TRUST_FULLY:     return _("full");
502     case TRUST_ULTIMATE:  return _("ultimate");
503     default:              return "err";
504     }
505 }
506
507 int
508 string_to_trust_value (const char *str)
509 {
510   if(ascii_strcasecmp(str,"undefined")==0)
511     return TRUST_UNDEFINED;
512   else if(ascii_strcasecmp(str,"never")==0)
513     return TRUST_NEVER;
514   else if(ascii_strcasecmp(str,"marginal")==0)
515     return TRUST_MARGINAL;
516   else if(ascii_strcasecmp(str,"full")==0)
517     return TRUST_FULLY;
518   else if(ascii_strcasecmp(str,"ultimate")==0)
519     return TRUST_ULTIMATE;
520   else
521     return -1;
522 }
523
524 /****************
525  * Recreate the WoT but do not ask for new ownertrusts.  Special
526  * feature: In batch mode and without a forced yes, this is only done
527  * when a check is due.  This can be used to run the check from a crontab
528  */
529 void
530 check_trustdb ()
531 {
532   init_trustdb();
533   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
534     {
535       if (opt.batch && !opt.answer_yes)
536         {
537           ulong scheduled;
538
539           scheduled = tdbio_read_nextcheck ();
540           if (!scheduled)
541             {
542               log_info (_("no need for a trustdb check\n"));
543               return;
544             }
545
546           if (scheduled > make_timestamp ())
547             {
548               log_info (_("next trustdb check due at %s\n"),
549                         strtimestamp (scheduled));
550               return;
551             }
552         }
553
554       validate_keys (0);
555     }
556   else
557     log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
558               trust_model_string());
559 }
560
561
562 /*
563  * Recreate the WoT. 
564  */
565 void
566 update_trustdb()
567 {
568   init_trustdb();
569   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
570     validate_keys (1);
571   else
572     log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
573               trust_model_string());
574 }
575
576 void
577 revalidation_mark (void)
578 {
579   init_trustdb();
580   /* we simply set the time for the next check to 1 (far back in 1970)
581    * so that a --update-trustdb will be scheduled */
582   if (tdbio_write_nextcheck (1))
583       do_sync ();
584   pending_check_trustdb = 1;
585 }
586
587 int
588 trustdb_pending_check(void)
589 {
590   return pending_check_trustdb;
591 }
592
593 void
594 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
595                    byte *marginals,byte *completes,byte *cert_depth)
596 {
597   TRUSTREC opts;
598
599   init_trustdb();
600
601   read_record(0,&opts,RECTYPE_VER);
602
603   if(trust_model)
604     *trust_model=opts.r.ver.trust_model;
605   if(created)
606     *created=opts.r.ver.created;
607   if(nextcheck)
608     *nextcheck=opts.r.ver.nextcheck;
609   if(marginals)
610     *marginals=opts.r.ver.marginals;
611   if(completes)
612     *completes=opts.r.ver.completes;
613   if(cert_depth)
614     *cert_depth=opts.r.ver.cert_depth;
615 }
616
617 /***********************************************
618  ***********  Ownertrust et al. ****************
619  ***********************************************/
620
621 static int 
622 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
623 {
624   int rc;
625   
626   init_trustdb();
627   rc = tdbio_search_trust_bypk (pk, rec);
628   if (rc == -1)
629     return -1; /* no record yet */
630   if (rc) 
631     {
632       log_error ("trustdb: searching trust record failed: %s\n",
633                  g10_errstr (rc));
634       return rc; 
635     }
636       
637   if (rec->rectype != RECTYPE_TRUST)
638     {
639       log_error ("trustdb: record %lu is not a trust record\n",
640                  rec->recnum);
641       return G10ERR_TRUSTDB; 
642     }      
643   
644   return 0;
645 }
646
647 /****************
648  * Return the assigned ownertrust value for the given public key.
649  * The key should be the primary key.
650  */
651 unsigned int 
652 get_ownertrust ( PKT_public_key *pk)
653 {
654   TRUSTREC rec;
655   int rc;
656   
657   rc = read_trust_record (pk, &rec);
658   if (rc == -1)
659     return TRUST_UNKNOWN; /* no record yet */
660   if (rc) 
661     {
662       tdbio_invalid ();
663       return rc; /* actually never reached */
664     }
665
666   return rec.r.trust.ownertrust;
667 }
668
669 unsigned int 
670 get_min_ownertrust (PKT_public_key *pk)
671 {
672   TRUSTREC rec;
673   int rc;
674   
675   rc = read_trust_record (pk, &rec);
676   if (rc == -1)
677     return TRUST_UNKNOWN; /* no record yet */
678   if (rc) 
679     {
680       tdbio_invalid ();
681       return rc; /* actually never reached */
682     }
683
684   return rec.r.trust.min_ownertrust;
685 }
686
687 /*
688  * Same as get_ownertrust but this takes the minimum ownertrust value
689  * into into account, and will bump up the value as needed.
690  */
691 static int
692 get_ownertrust_with_min (PKT_public_key *pk)
693 {
694   unsigned int otrust,otrust_min;
695
696   otrust = (get_ownertrust (pk) & TRUST_MASK);
697   otrust_min = get_min_ownertrust (pk);
698   if(otrust<otrust_min)
699     {
700       /* If the trust that the user has set is less than the trust
701          that was calculated from a trust signature chain, use the
702          higher of the two.  We do this here and not in
703          get_ownertrust since the underlying ownertrust should not
704          really be set - just the appearance of the ownertrust. */
705
706       otrust=otrust_min;
707     }
708
709   return otrust;
710 }
711
712 /*
713  * Same as get_ownertrust but return a trust letter instead of an
714  * value.  This takes the minimum ownertrust value into account.
715  */
716 int
717 get_ownertrust_info (PKT_public_key *pk)
718 {
719   return trust_letter(get_ownertrust_with_min(pk));
720 }
721
722 /*
723  * Same as get_ownertrust but return a trust string instead of an
724  * value.  This takes the minimum ownertrust value into account.
725  */
726 const char *
727 get_ownertrust_string (PKT_public_key *pk)
728 {
729   return trust_value_to_string(get_ownertrust_with_min(pk));
730 }
731
732 /*
733  * Set the trust value of the given public key to the new value.
734  * The key should be a primary one.
735  */
736 void
737 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
738 {
739   TRUSTREC rec;
740   int rc;
741   
742   rc = read_trust_record (pk, &rec);
743   if (!rc)
744     {
745       if (DBG_TRUST)
746         log_debug ("update ownertrust from %u to %u\n",
747                    (unsigned int)rec.r.trust.ownertrust, new_trust );
748       if (rec.r.trust.ownertrust != new_trust)
749         {
750           rec.r.trust.ownertrust = new_trust;
751           write_record( &rec );
752           revalidation_mark ();
753           do_sync ();
754         }
755     }
756   else if (rc == -1)
757     { /* no record yet - create a new one */
758       size_t dummy;
759
760       if (DBG_TRUST)
761         log_debug ("insert ownertrust %u\n", new_trust );
762
763       memset (&rec, 0, sizeof rec);
764       rec.recnum = tdbio_new_recnum ();
765       rec.rectype = RECTYPE_TRUST;
766       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
767       rec.r.trust.ownertrust = new_trust;
768       write_record (&rec);
769       revalidation_mark ();
770       do_sync ();
771       rc = 0;
772     }
773   else 
774     {
775       tdbio_invalid ();
776     }
777 }
778
779 static void
780 update_min_ownertrust (u32 *kid, unsigned int new_trust )
781 {
782   PKT_public_key *pk;
783   TRUSTREC rec;
784   int rc;
785
786   pk = m_alloc_clear (sizeof *pk);
787   rc = get_pubkey (pk, kid);
788   if (rc)
789     {
790       log_error (_("public key %08lX not found: %s\n"),
791                  (ulong)kid[1], g10_errstr(rc) );
792       return;
793     }
794
795   rc = read_trust_record (pk, &rec);
796   if (!rc)
797     {
798       if (DBG_TRUST)
799         log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
800                    (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
801                    new_trust );
802       if (rec.r.trust.min_ownertrust != new_trust)
803         {
804           rec.r.trust.min_ownertrust = new_trust;
805           write_record( &rec );
806           revalidation_mark ();
807           do_sync ();
808         }
809     }
810   else if (rc == -1)
811     { /* no record yet - create a new one */
812       size_t dummy;
813
814       if (DBG_TRUST)
815         log_debug ("insert min_ownertrust %u\n", new_trust );
816
817       memset (&rec, 0, sizeof rec);
818       rec.recnum = tdbio_new_recnum ();
819       rec.rectype = RECTYPE_TRUST;
820       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
821       rec.r.trust.min_ownertrust = new_trust;
822       write_record (&rec);
823       revalidation_mark ();
824       do_sync ();
825       rc = 0;
826     }
827   else 
828     {
829       tdbio_invalid ();
830     }
831 }
832
833 /* Clear the ownertrust and min_ownertrust values.  Return true if a
834    change actually happened. */
835 int
836 clear_ownertrusts (PKT_public_key *pk)
837 {
838   TRUSTREC rec;
839   int rc;
840   
841   rc = read_trust_record (pk, &rec);
842   if (!rc)
843     {
844       if (DBG_TRUST)
845         {
846           log_debug ("clearing ownertrust (old value %u)\n",
847                      (unsigned int)rec.r.trust.ownertrust);
848           log_debug ("clearing min_ownertrust (old value %u)\n",
849                      (unsigned int)rec.r.trust.min_ownertrust);
850         }
851       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
852         {
853           rec.r.trust.ownertrust = 0;
854           rec.r.trust.min_ownertrust = 0;
855           write_record( &rec );
856           revalidation_mark ();
857           do_sync ();
858           return 1;
859         }
860     }
861   else if (rc != -1)
862     {
863       tdbio_invalid ();
864     }
865   return 0;
866 }
867
868 /* 
869  * Note: Caller has to do a sync 
870  */
871 static void
872 update_validity (PKT_public_key *pk, PKT_user_id *uid,
873                  int depth, int validity)
874 {
875   TRUSTREC trec, vrec;
876   int rc;
877   ulong recno;
878
879   namehash_from_uid(uid);
880
881   rc = read_trust_record (pk, &trec);
882   if (rc && rc != -1)
883     {
884       tdbio_invalid ();
885       return;
886     }
887   if (rc == -1) /* no record yet - create a new one */
888     { 
889       size_t dummy;
890
891       rc = 0;
892       memset (&trec, 0, sizeof trec);
893       trec.recnum = tdbio_new_recnum ();
894       trec.rectype = RECTYPE_TRUST;
895       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
896       trec.r.trust.ownertrust = 0;
897       }
898
899   /* locate an existing one */
900   recno = trec.r.trust.validlist;
901   while (recno)
902     {
903       read_record (recno, &vrec, RECTYPE_VALID);
904       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
905         break;
906       recno = vrec.r.valid.next;
907     }
908
909   if (!recno) /* insert a new validity record */
910     {
911       memset (&vrec, 0, sizeof vrec);
912       vrec.recnum = tdbio_new_recnum ();
913       vrec.rectype = RECTYPE_VALID;
914       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
915       vrec.r.valid.next = trec.r.trust.validlist;
916       trec.r.trust.validlist = vrec.recnum;
917     }
918   vrec.r.valid.validity = validity;
919   vrec.r.valid.full_count = uid->help_full_count;
920   vrec.r.valid.marginal_count = uid->help_marginal_count;
921   write_record (&vrec);
922   trec.r.trust.depth = depth;
923   write_record (&trec);
924 }
925
926
927 /* reset validity for all user IDs.  Caller must sync. */
928 static int
929 clear_validity (PKT_public_key *pk)
930 {
931   TRUSTREC trec, vrec;
932   int rc;
933   ulong recno;
934   int any = 0;
935   
936   rc = read_trust_record (pk, &trec);
937   if (rc && rc != -1)
938     {
939       tdbio_invalid ();
940       return 0;
941     }
942   if (rc == -1) /* no record yet - no need to clear it then ;-) */
943     return 0;
944
945   /* Clear minimum ownertrust, if any */
946   if(trec.r.trust.min_ownertrust)
947     {
948       trec.r.trust.min_ownertrust=0;
949       write_record(&trec);
950     }
951
952   recno = trec.r.trust.validlist;
953   while (recno)
954     {
955       read_record (recno, &vrec, RECTYPE_VALID);
956       if ((vrec.r.valid.validity & TRUST_MASK)
957           || vrec.r.valid.marginal_count || vrec.r.valid.full_count)
958         {
959           vrec.r.valid.validity &= ~TRUST_MASK;
960           vrec.r.valid.marginal_count = vrec.r.valid.full_count = 0;
961           write_record (&vrec);
962           any = 1;
963         }
964       recno = vrec.r.valid.next;
965     }
966
967   return any;
968 }
969
970 /***********************************************
971  *********  Query trustdb values  **************
972  ***********************************************/
973
974 /* Return true if key is disabled */
975 int
976 cache_disabled_value(PKT_public_key *pk)
977 {
978   int rc;
979   TRUSTREC trec;
980   int disabled=0;
981
982   if(pk->is_disabled)
983     return (pk->is_disabled==2);
984
985   init_trustdb();
986
987   rc = read_trust_record (pk, &trec);
988   if (rc && rc != -1)
989     {
990       tdbio_invalid ();
991       goto leave;
992     }
993   if (rc == -1) /* no record found, so assume not disabled */
994     goto leave;
995  
996   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
997     disabled=1;
998  
999   /* Cache it for later so we don't need to look at the trustdb every
1000      time */
1001   if(disabled)
1002     pk->is_disabled=2;
1003   else
1004     pk->is_disabled=1;
1005
1006  leave:
1007    return disabled;
1008 }
1009
1010 void
1011 check_trustdb_stale(void)
1012 {
1013   static int did_nextcheck=0;
1014
1015   init_trustdb ();
1016   if (!did_nextcheck
1017       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
1018     {
1019       ulong scheduled;
1020
1021       did_nextcheck = 1;
1022       scheduled = tdbio_read_nextcheck ();
1023       if (scheduled && scheduled <= make_timestamp ())
1024         {
1025           if (opt.no_auto_check_trustdb) 
1026             {
1027               pending_check_trustdb = 1;
1028               log_info (_("please do a --check-trustdb\n"));
1029             }
1030           else
1031             {
1032               log_info (_("checking the trustdb\n"));
1033               validate_keys (0);
1034             }
1035         }
1036     }
1037 }
1038
1039 /*
1040  * Return the validity information for PK.  If the namehash is not
1041  * NULL, the validity of the corresponsing user ID is returned,
1042  * otherwise, a reasonable value for the entire key is returned. 
1043  */
1044 unsigned int
1045 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1046 {
1047   TRUSTREC trec, vrec;
1048   int rc;
1049   ulong recno;
1050   unsigned int validity;
1051   u32 kid[2];
1052   PKT_public_key *main_pk;
1053
1054   if(uid)
1055     namehash_from_uid(uid);
1056
1057   init_trustdb ();
1058   check_trustdb_stale();
1059
1060   keyid_from_pk (pk, kid);
1061   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1062     { /* this is a subkey - get the mainkey */
1063       main_pk = m_alloc_clear (sizeof *main_pk);
1064       rc = get_pubkey (main_pk, pk->main_keyid);
1065       if (rc)
1066         {
1067           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
1068                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
1069           validity = TRUST_UNKNOWN; 
1070           goto leave;
1071         }
1072     }
1073   else
1074     main_pk = pk;
1075
1076   rc = read_trust_record (main_pk, &trec);
1077   if (rc && rc != -1)
1078     {
1079       tdbio_invalid ();
1080       return 0;
1081     }
1082   if (rc == -1) /* no record found */
1083     {
1084       validity = TRUST_UNKNOWN; 
1085       goto leave;
1086     }
1087
1088   /* loop over all user IDs */
1089   recno = trec.r.trust.validlist;
1090   validity = 0;
1091   while (recno)
1092     {
1093       read_record (recno, &vrec, RECTYPE_VALID);
1094
1095       if(uid)
1096         {
1097           /* If a user ID is given we return the validity for that
1098              user ID ONLY.  If the namehash is not found, then there
1099              is no validity at all (i.e. the user ID wasn't
1100              signed). */
1101           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1102             {
1103               validity=(vrec.r.valid.validity & TRUST_MASK);
1104               break;
1105             }
1106         }
1107       else
1108         {
1109           /* If no namehash is given, we take the maximum validity
1110              over all user IDs */
1111           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1112             validity = (vrec.r.valid.validity & TRUST_MASK);
1113         }
1114
1115       recno = vrec.r.valid.next;
1116     }
1117   
1118   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1119     {
1120       validity |= TRUST_FLAG_DISABLED;
1121       pk->is_disabled=2;
1122     }
1123   else
1124     pk->is_disabled=1;
1125
1126  leave:
1127   /* set some flags direct from the key */
1128   if (main_pk->is_revoked)
1129     validity |= TRUST_FLAG_REVOKED;
1130   if (main_pk != pk && pk->is_revoked)
1131     validity |= TRUST_FLAG_SUB_REVOKED;
1132   /* Note: expiration is a trust value and not a flag - don't know why
1133    * I initially designed it that way */
1134   if (main_pk->has_expired || pk->has_expired)
1135     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1136   
1137   if (pending_check_trustdb)
1138     validity |= TRUST_FLAG_PENDING_CHECK;
1139
1140   if (main_pk != pk)
1141     free_public_key (main_pk);
1142   return validity;
1143 }
1144
1145 int
1146 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1147 {
1148     int trustlevel;
1149
1150     trustlevel = get_validity (pk, uid);
1151     if( trustlevel & TRUST_FLAG_REVOKED )
1152         return 'r';
1153     return trust_letter ( trustlevel );
1154 }
1155
1156 const char *
1157 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1158 {
1159   int trustlevel;
1160
1161   trustlevel = get_validity (pk, uid);
1162   if( trustlevel & TRUST_FLAG_REVOKED )
1163     return _("revoked");
1164   return trust_value_to_string(trustlevel);
1165 }
1166
1167 static void
1168 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1169 {
1170   TRUSTREC trec, vrec;
1171   ulong recno;
1172
1173   if(pk==NULL || uid==NULL)
1174     BUG();
1175
1176   namehash_from_uid(uid);
1177
1178   uid->help_marginal_count=uid->help_full_count=0;
1179
1180   init_trustdb ();
1181
1182   if(read_trust_record (pk, &trec)!=0)
1183     return;
1184
1185   /* loop over all user IDs */
1186   recno = trec.r.trust.validlist;
1187   while (recno)
1188     {
1189       read_record (recno, &vrec, RECTYPE_VALID);
1190
1191       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1192         {
1193           uid->help_marginal_count=vrec.r.valid.marginal_count;
1194           uid->help_full_count=vrec.r.valid.full_count;
1195           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1196           break;
1197         }
1198
1199       recno = vrec.r.valid.next;
1200     }
1201 }
1202
1203 void
1204 list_trust_path( const char *username )
1205 {
1206 }
1207
1208 /****************
1209  * Enumerate all keys, which are needed to build all trust paths for
1210  * the given key.  This function does not return the key itself or
1211  * the ultimate key (the last point in cerificate chain).  Only
1212  * certificate chains which ends up at an ultimately trusted key
1213  * are listed.  If ownertrust or validity is not NULL, the corresponding
1214  * value for the returned LID is also returned in these variable(s).
1215  *
1216  *  1) create a void pointer and initialize it to NULL
1217  *  2) pass this void pointer by reference to this function.
1218  *     Set lid to the key you want to enumerate and pass it by reference.
1219  *  3) call this function as long as it does not return -1
1220  *     to indicate EOF. LID does contain the next key used to build the web
1221  *  4) Always call this function a last time with LID set to NULL,
1222  *     so that it can free its context.
1223  *
1224  * Returns: -1 on EOF or the level of the returned LID
1225  */
1226 int
1227 enum_cert_paths( void **context, ulong *lid,
1228                  unsigned *ownertrust, unsigned *validity )
1229 {
1230     return -1;
1231 }
1232
1233
1234 /****************
1235  * Print the current path
1236  */
1237 void
1238 enum_cert_paths_print( void **context, FILE *fp,
1239                                        int refresh, ulong selected_lid )
1240 {
1241     return;
1242 }
1243
1244
1245 \f
1246 /****************************************
1247  *********** NEW NEW NEW ****************
1248  ****************************************/
1249
1250 static int
1251 ask_ownertrust (u32 *kid,int minimum)
1252 {
1253   PKT_public_key *pk;
1254   int rc;
1255   int ot;
1256
1257   pk = m_alloc_clear (sizeof *pk);
1258   rc = get_pubkey (pk, kid);
1259   if (rc)
1260     {
1261       log_error (_("public key %08lX not found: %s\n"),
1262                  (ulong)kid[1], g10_errstr(rc) );
1263       return TRUST_UNKNOWN;
1264     }
1265  
1266   if(opt.force_ownertrust)
1267     {
1268       log_info("force trust for key %08lX%08lX to %s\n",
1269                (ulong)kid[0],(ulong)kid[1],
1270                trust_value_to_string(opt.force_ownertrust));
1271       update_ownertrust(pk,opt.force_ownertrust);
1272       ot=opt.force_ownertrust;
1273     }
1274   else
1275     {
1276       ot=edit_ownertrust(pk,0);
1277       if(ot>0)
1278         ot = get_ownertrust (pk);
1279       else if(ot==0)
1280         ot = minimum?minimum:TRUST_UNDEFINED;
1281       else
1282         ot = -1; /* quit */
1283     }
1284
1285   free_public_key( pk );
1286
1287   return ot;
1288 }
1289
1290
1291 static void
1292 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1293 {
1294   for ( ;node; node = node->next )
1295     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1296         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1297       {
1298         u32 aki[2];
1299
1300         keyid_from_pk (node->pkt->pkt.public_key, aki);
1301         add_key_hash_table (tbl, aki);
1302       }
1303 }
1304
1305
1306 static void
1307 dump_key_array (int depth, struct key_array *keys)
1308 {
1309   struct key_array *kar;
1310
1311   for (kar=keys; kar->keyblock; kar++)
1312     {
1313       KBNODE node = kar->keyblock;
1314       u32 kid[2];
1315
1316       keyid_from_pk(node->pkt->pkt.public_key, kid);
1317       printf ("%d:%08lX%08lX:K::%c::::\n",
1318               depth, (ulong)kid[0], (ulong)kid[1], '?');
1319
1320       for (; node; node = node->next)
1321         {
1322           if (node->pkt->pkttype == PKT_USER_ID)
1323             {
1324               int len = node->pkt->pkt.user_id->len;
1325
1326               if (len > 30)
1327                 len = 30;
1328               printf ("%d:%08lX%08lX:U:::%c:::",
1329                       depth, (ulong)kid[0], (ulong)kid[1],
1330                       (node->flag & 4)? 'f':
1331                       (node->flag & 2)? 'm':
1332                       (node->flag & 1)? 'q':'-');
1333               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1334               putchar (':');
1335               putchar ('\n');
1336             }
1337         }
1338     }
1339 }  
1340
1341
1342 static void
1343 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1344 {
1345   KBNODE node;
1346   int status;
1347   int any = 0;
1348
1349   for (node=keyblock; node; node = node->next)
1350     {
1351       if (node->pkt->pkttype == PKT_USER_ID)
1352         {
1353           PKT_user_id *uid = node->pkt->pkt.user_id;
1354           if (node->flag & 4)
1355             status = TRUST_FULLY;
1356           else if (node->flag & 2)
1357             status = TRUST_MARGINAL;
1358           else if (node->flag & 1)
1359             status = TRUST_UNDEFINED;
1360           else
1361             status = 0;
1362           
1363           if (status)
1364             {
1365               update_validity (keyblock->pkt->pkt.public_key,
1366                                uid, depth, status);
1367
1368               mark_keyblock_seen(stored,keyblock);
1369
1370               any = 1;
1371             }
1372         }
1373     }
1374
1375   if (any)
1376     do_sync ();
1377 }  
1378
1379 /*
1380  * check whether the signature sig is in the klist k
1381  */
1382 static struct key_item *
1383 is_in_klist (struct key_item *k, PKT_signature *sig)
1384 {
1385   for (; k; k = k->next)
1386     {
1387       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1388         return k;
1389     }
1390   return NULL;
1391 }
1392
1393 /*
1394  * Mark the signature of the given UID which are used to certify it.
1395  * To do this, we first revmove all signatures which are not valid and
1396  * from the remain ones we look for the latest one.  If this is not a
1397  * certification revocation signature we mark the signature by setting
1398  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1399  * purposes.  
1400  */
1401 static void
1402 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1403                        u32 *main_kid, struct key_item *klist,
1404                        u32 curtime, u32 *next_expire)
1405 {
1406   KBNODE node;
1407   PKT_signature *sig;
1408   
1409   /* first check all signatures */
1410   for (node=uidnode->next; node; node = node->next)
1411     {
1412       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1413       if (node->pkt->pkttype == PKT_USER_ID
1414           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1415         break; /* ready */
1416       if (node->pkt->pkttype != PKT_SIGNATURE)
1417         continue;
1418       
1419       sig = node->pkt->pkt.signature;
1420       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1421         continue; /* ignore self-signatures */
1422       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1423         continue; /* we only look at these signature classes */
1424       if (!is_in_klist (klist, sig))
1425         continue;  /* no need to check it then */
1426       if (check_key_signature (keyblock, node, NULL))
1427         continue; /* ignore invalid signatures */
1428       node->flag |= 1<<9;
1429     }      
1430   /* reset the remaining flags */
1431   for (; node; node = node->next)
1432       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1433
1434   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1435    * bit 10 will be set by the loop to keep track of keyIDs already
1436    * processed, bit 8 will be set for the usable signatures */
1437
1438   /* for each cert figure out the latest valid one */
1439   for (node=uidnode->next; node; node = node->next)
1440     {
1441       KBNODE n, signode;
1442       u32 kid[2];
1443       u32 sigdate;
1444       
1445       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1446         break;
1447       if ( !(node->flag & (1<<9)) )
1448         continue; /* not a node to look at */
1449       if ( (node->flag & (1<<10)) )
1450         continue; /* signature with a keyID already processed */
1451       node->flag |= (1<<10); /* mark this node as processed */
1452       sig = node->pkt->pkt.signature;
1453       signode = node;
1454       sigdate = sig->timestamp;
1455       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1456       for (n=uidnode->next; n; n = n->next)
1457         {
1458           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1459             break;
1460           if ( !(n->flag & (1<<9)) )
1461             continue;
1462           if ( (n->flag & (1<<10)) )
1463             continue; /* shortcut already processed signatures */
1464           sig = n->pkt->pkt.signature;
1465           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1466             continue;
1467           n->flag |= (1<<10); /* mark this node as processed */
1468
1469           /* If signode is nonrevocable and unexpired and n isn't,
1470              then take signode (skip).  It doesn't matter which is
1471              older: if signode was older then we don't want to take n
1472              as signode is nonrevocable.  If n was older then we're
1473              automatically fine. */
1474           
1475           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1476                !signode->pkt->pkt.signature->flags.revocable &&
1477                (signode->pkt->pkt.signature->expiredate==0 ||
1478                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1479              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1480                 !n->pkt->pkt.signature->flags.revocable &&
1481                 (n->pkt->pkt.signature->expiredate==0 ||
1482                  n->pkt->pkt.signature->expiredate>curtime))))
1483             continue;
1484
1485           /* If n is nonrevocable and unexpired and signode isn't,
1486              then take n.  Again, it doesn't matter which is older: if
1487              n was older then we don't want to take signode as n is
1488              nonrevocable.  If signode was older then we're
1489              automatically fine. */
1490           
1491           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1492                 !signode->pkt->pkt.signature->flags.revocable &&
1493                 (signode->pkt->pkt.signature->expiredate==0 ||
1494                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1495              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1496                !n->pkt->pkt.signature->flags.revocable &&
1497                (n->pkt->pkt.signature->expiredate==0 ||
1498                 n->pkt->pkt.signature->expiredate>curtime))))
1499             {
1500               signode = n;
1501               sigdate = sig->timestamp;
1502               continue;
1503             }
1504
1505           /* At this point, if it's newer, it goes in as the only
1506              remaining possibilities are signode and n are both either
1507              revocable or expired or both nonrevocable and unexpired.
1508              If the timestamps are equal take the later ordered
1509              packet, presuming that the key packets are hopefully in
1510              their original order. */
1511
1512           if (sig->timestamp >= sigdate)
1513             {
1514               signode = n;
1515               sigdate = sig->timestamp;
1516             }
1517         }
1518       sig = signode->pkt->pkt.signature;
1519       if (IS_UID_SIG (sig))
1520         { /* this seems to be a usable one which is not revoked. 
1521            * Just need to check whether there is an expiration time,
1522            * We do the expired certification after finding a suitable
1523            * certification, the assumption is that a signator does not
1524            * want that after the expiration of his certificate the
1525            * system falls back to an older certification which has a
1526            * different expiration time */
1527           const byte *p;
1528           u32 expire;
1529                     
1530           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1531           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1532
1533           if (expire==0 || expire > curtime )
1534             {
1535               signode->flag |= (1<<8); /* yeah, found a good cert */
1536               if (expire && expire < *next_expire)
1537                 *next_expire = expire;
1538             }
1539         }
1540     }
1541 }
1542
1543 /* Used by validate_one_keyblock to confirm a regexp within a trust
1544    signature.  Returns 1 for match, and 0 for no match or regex
1545    error. */
1546 static int
1547 check_regexp(const char *exp,const char *string)
1548 {
1549 #ifdef DISABLE_REGEX
1550   /* When DISABLE_REGEX is defined, assume all regexps do not
1551      match. */
1552   return 0;
1553 #elif defined(__riscos__)
1554   return riscos_check_regexp(exp, string, DBG_TRUST);
1555 #else
1556   int ret;
1557   regex_t pat;
1558
1559   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1560     return 0;
1561
1562   ret=regexec(&pat,string,0,NULL,0);
1563
1564   regfree(&pat);
1565
1566   if(DBG_TRUST)
1567     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1568
1569   return (ret==0);
1570 #endif
1571 }
1572
1573 /*
1574  * Return true if the key is signed by one of the keys in the given
1575  * key ID list.  User IDs with a valid signature are marked by node
1576  * flags as follows:
1577  *  flag bit 0: There is at least one signature
1578  *           1: There is marginal confidence that this is a legitimate uid
1579  *           2: There is full confidence that this is a legitimate uid.
1580  *           8: Used for internal purposes.
1581  *           9: Ditto (in mark_usable_uid_certs())
1582  *          10: Ditto (ditto)
1583  * This function assumes that all kbnode flags are cleared on entry.
1584  */
1585 static int
1586 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1587                        u32 curtime, u32 *next_expire)
1588 {
1589   struct key_item *kr;
1590   KBNODE node, uidnode=NULL;
1591   PKT_user_id *uid=NULL;
1592   PKT_public_key *pk = kb->pkt->pkt.public_key;
1593   u32 main_kid[2];
1594   int issigned=0, any_signed = 0;
1595
1596   keyid_from_pk(pk, main_kid);
1597   for (node=kb; node; node = node->next)
1598     {
1599       /* A bit of discussion here: is it better for the web of trust
1600          to be built among only self-signed uids?  On the one hand, a
1601          self-signed uid is a statement that the key owner definitely
1602          intended that uid to be there, but on the other hand, a
1603          signed (but not self-signed) uid does carry trust, of a sort,
1604          even if it is a statement being made by people other than the
1605          key owner "through" the uids on the key owner's key.  I'm
1606          going with the latter.  However, if the user ID was
1607          explicitly revoked, or passively allowed to expire, that
1608          should stop validity through the user ID until it is
1609          resigned.  -dshaw */
1610
1611       if (node->pkt->pkttype == PKT_USER_ID
1612           && !node->pkt->pkt.user_id->is_revoked
1613           && !node->pkt->pkt.user_id->is_expired)
1614         {
1615           if (uidnode && issigned)
1616             {
1617               if (uid->help_full_count >= opt.completes_needed
1618                   || uid->help_marginal_count >= opt.marginals_needed )
1619                 uidnode->flag |= 4; 
1620               else if (uid->help_full_count || uid->help_marginal_count)
1621                 uidnode->flag |= 2;
1622               uidnode->flag |= 1;
1623               any_signed = 1;
1624             }
1625           uidnode = node;
1626           uid=uidnode->pkt->pkt.user_id;
1627
1628           /* If the selfsig is going to expire... */
1629           if(uid->expiredate && uid->expiredate<*next_expire)
1630             *next_expire = uid->expiredate;
1631
1632           issigned = 0;
1633           get_validity_counts(pk,uid);
1634           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1635                                  curtime, next_expire);
1636         }
1637       else if (node->pkt->pkttype == PKT_SIGNATURE
1638                && (node->flag & (1<<8)) && uid)
1639         {
1640           /* Note that we are only seeing unrevoked sigs here */
1641           PKT_signature *sig = node->pkt->pkt.signature;
1642           
1643           kr = is_in_klist (klist, sig);
1644           /* If the trust_regexp does not match, it's as if the sig
1645              did not exist.  This is safe for non-trust sigs as well
1646              since we don't accept a regexp on the sig unless it's a
1647              trust sig. */
1648           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1649                      (uidnode && check_regexp(kr->trust_regexp,
1650                                             uidnode->pkt->pkt.user_id->name))))
1651             {
1652               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1653                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1654                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1655                           kr->trust_depth);
1656
1657               /* Are we part of a trust sig chain?  We always favor
1658                  the latest trust sig, rather than the greater or
1659                  lesser trust sig or value.  I could make a decent
1660                  argument for any of these cases, but this seems to be
1661                  what PGP does, and I'd like to be compatible. -dms */
1662               if(opt.trust_model==TM_PGP && sig->trust_depth
1663                  && pk->trust_timestamp<=sig->timestamp
1664                  && (sig->trust_depth<=kr->trust_depth
1665                      || kr->ownertrust==TRUST_ULTIMATE))
1666                 {
1667                   /* If we got here, we know that:
1668
1669                      this is a trust sig.
1670
1671                      it's a newer trust sig than any previous trust
1672                      sig on this key (not uid).
1673
1674                      it is legal in that it was either generated by an
1675                      ultimate key, or a key that was part of a trust
1676                      chain, and the depth does not violate the
1677                      original trust sig.
1678
1679                      if there is a regexp attached, it matched
1680                      successfully.
1681                   */
1682
1683                   if(DBG_TRUST)
1684                     log_debug("replacing trust value %d with %d and "
1685                               "depth %d with %d\n",
1686                               pk->trust_value,sig->trust_value,
1687                               pk->trust_depth,sig->trust_depth);
1688
1689                   pk->trust_value=sig->trust_value;
1690                   pk->trust_depth=sig->trust_depth-1;
1691
1692                   /* If the trust sig contains a regexp, record it
1693                      on the pk for the next round. */
1694                   if(sig->trust_regexp)
1695                     pk->trust_regexp=sig->trust_regexp;
1696                 }
1697
1698               if (kr->ownertrust == TRUST_ULTIMATE)
1699                 uid->help_full_count = opt.completes_needed;
1700               else if (kr->ownertrust == TRUST_FULLY)
1701                 uid->help_full_count++;
1702               else if (kr->ownertrust == TRUST_MARGINAL)
1703                 uid->help_marginal_count++;
1704               issigned = 1;
1705             }
1706         }
1707     }
1708
1709   if (uidnode && issigned)
1710     {
1711       if (uid->help_full_count >= opt.completes_needed
1712           || uid->help_marginal_count >= opt.marginals_needed )
1713         uidnode->flag |= 4; 
1714       else if (uid->help_full_count || uid->help_marginal_count)
1715         uidnode->flag |= 2;
1716       uidnode->flag |= 1;
1717       any_signed = 1;
1718     }
1719
1720   return any_signed;
1721 }
1722
1723
1724 static int
1725 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1726 {
1727   return test_key_hash_table ((KeyHashTable)opaque, kid);
1728 }
1729
1730
1731 /*
1732  * Scan all keys and return a key_array of all suitable keys from
1733  * kllist.  The caller has to pass keydb handle so that we don't use
1734  * to create our own.  Returns either a key_array or NULL in case of
1735  * an error.  No results found are indicated by an empty array.
1736  * Caller hast to release the returned array.  
1737  */
1738 static struct key_array *
1739 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1740                    struct key_item *klist, u32 curtime, u32 *next_expire)
1741 {
1742   KBNODE keyblock = NULL;
1743   struct key_array *keys = NULL;
1744   size_t nkeys, maxkeys;
1745   int rc;
1746   KEYDB_SEARCH_DESC desc;
1747   
1748   maxkeys = 1000;
1749   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1750   nkeys = 0;
1751   
1752   rc = keydb_search_reset (hd);
1753   if (rc)
1754     {
1755       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1756       m_free (keys);
1757       return NULL;
1758     }
1759
1760   memset (&desc, 0, sizeof desc);
1761   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1762   desc.skipfnc = search_skipfnc;
1763   desc.skipfncvalue = full_trust;
1764   rc = keydb_search (hd, &desc, 1);
1765   if (rc == -1)
1766     {
1767       keys[nkeys].keyblock = NULL;
1768       return keys;
1769     }
1770   if (rc)
1771     {
1772       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1773       m_free (keys);
1774       return NULL;
1775     }
1776   
1777   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1778   do
1779     {
1780       PKT_public_key *pk;
1781         
1782       rc = keydb_get_keyblock (hd, &keyblock);
1783       if (rc) 
1784         {
1785           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1786           m_free (keys);
1787           return NULL;
1788         }
1789       
1790       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1791         {
1792           log_debug ("ooops: invalid pkttype %d encountered\n",
1793                      keyblock->pkt->pkttype);
1794           dump_kbnode (keyblock);
1795           release_kbnode(keyblock);
1796           continue;
1797         }
1798
1799       /* prepare the keyblock for further processing */
1800       merge_keys_and_selfsig (keyblock); 
1801       clear_kbnode_flags (keyblock);
1802       pk = keyblock->pkt->pkt.public_key;
1803       if (pk->has_expired || pk->is_revoked)
1804         {
1805           /* it does not make sense to look further at those keys */
1806           mark_keyblock_seen (full_trust, keyblock);
1807         }
1808       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1809         {
1810           KBNODE node;
1811
1812           if (pk->expiredate && pk->expiredate >= curtime
1813               && pk->expiredate < *next_expire)
1814             *next_expire = pk->expiredate;
1815
1816           if (nkeys == maxkeys) {
1817             maxkeys += 1000;
1818             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1819           }
1820           keys[nkeys++].keyblock = keyblock;
1821
1822           /* Optimization - if all uids are fully trusted, then we
1823              never need to consider this key as a candidate again. */
1824
1825           for (node=keyblock; node; node = node->next)
1826             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1827               break;
1828
1829           if(node==NULL)
1830             mark_keyblock_seen (full_trust, keyblock);
1831
1832           keyblock = NULL;
1833         }
1834
1835       release_kbnode (keyblock);
1836       keyblock = NULL;
1837     } 
1838   while ( !(rc = keydb_search (hd, &desc, 1)) );
1839   if (rc && rc != -1) 
1840     {
1841       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1842       m_free (keys);
1843       return NULL;
1844     }
1845
1846   keys[nkeys].keyblock = NULL;
1847   return keys;
1848
1849
1850 /* Caller must sync */
1851 static void
1852 reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
1853 {
1854   int rc;
1855   KBNODE keyblock = NULL;
1856   KEYDB_SEARCH_DESC desc;
1857   int count = 0, nreset = 0;
1858   
1859   rc = keydb_search_reset (hd);
1860   if (rc)
1861     {
1862       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1863       return;
1864     }
1865
1866   memset (&desc, 0, sizeof desc);
1867   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1868   if(exclude)
1869     {
1870       desc.skipfnc = search_skipfnc;
1871       desc.skipfncvalue = exclude;
1872     }
1873   rc = keydb_search (hd, &desc, 1);
1874   if (rc && rc != -1 )
1875     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1876   else if (!rc)
1877     {
1878       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1879       do
1880         {
1881           rc = keydb_get_keyblock (hd, &keyblock);
1882           if (rc) 
1883             {
1884               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1885               break;
1886             }
1887           count++;
1888
1889           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1890             {
1891               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1892               release_kbnode (keyblock);
1893             } 
1894         }
1895       while ( !(rc = keydb_search (hd, &desc, 1)) );
1896       if (rc && rc != -1) 
1897         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1898     }
1899   if (opt.verbose)
1900     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1901               count, nreset);
1902 }
1903
1904 /*
1905  * Run the key validation procedure.
1906  *
1907  * This works this way:
1908  * Step 1: Find all ultimately trusted keys (UTK).
1909  *         mark them all as seen and put them into klist.
1910  * Step 2: loop max_cert_times
1911  * Step 3:   if OWNERTRUST of any key in klist is undefined
1912  *             ask user to assign ownertrust
1913  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1914  * Step 5:     if key is revoked or expired
1915  *                mark key as seen
1916  *                continue loop at Step 4
1917  * Step 6:     For each user ID of that key signed by a key in klist
1918  *                Calculate validity by counting trusted signatures.
1919  *                Set validity of user ID
1920  * Step 7:     If any signed user ID was found
1921  *                mark key as seen
1922  *             End Loop
1923  * Step 8:   Build a new klist from all fully trusted keys from step 6
1924  *           End Loop
1925  *         Ready  
1926  *
1927  */
1928 static int
1929 validate_keys (int interactive)
1930 {
1931   int rc = 0;
1932   int quit=0;
1933   struct key_item *klist = NULL;
1934   struct key_item *k;
1935   struct key_array *keys = NULL;
1936   struct key_array *kar;
1937   KEYDB_HANDLE kdb = NULL;
1938   KBNODE node;
1939   int depth;
1940   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1941   KeyHashTable stored,used,full_trust;
1942   u32 start_time, next_expire;
1943
1944   start_time = make_timestamp ();
1945   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1946   stored = new_key_hash_table ();
1947   used = new_key_hash_table ();
1948   full_trust = new_key_hash_table ();
1949   /* Fixme: Instead of always building a UTK list, we could just build it
1950    * here when needed */
1951   if (!utk_list)
1952     {
1953       log_info (_("no ultimately trusted keys found\n"));
1954       goto leave;
1955     }
1956
1957   kdb = keydb_new (0);
1958
1959   reset_trust_records (kdb,NULL);
1960
1961   /* mark all UTKs as used and fully_trusted and set validity to
1962      ultimate */
1963   for (k=utk_list; k; k = k->next)
1964     {
1965       KBNODE keyblock;
1966       PKT_public_key *pk;
1967
1968       keyblock = get_pubkeyblock (k->kid);
1969       if (!keyblock)
1970         {
1971           log_error (_("public key of ultimately"
1972                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1973           continue;
1974         }
1975       mark_keyblock_seen (used, keyblock);
1976       mark_keyblock_seen (stored, keyblock);
1977       mark_keyblock_seen (full_trust, keyblock);
1978       pk = keyblock->pkt->pkt.public_key;
1979       for (node=keyblock; node; node = node->next)
1980         {
1981           if (node->pkt->pkttype == PKT_USER_ID)
1982             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1983         }
1984       if ( pk->expiredate && pk->expiredate >= start_time
1985            && pk->expiredate < next_expire)
1986         next_expire = pk->expiredate;
1987       
1988       release_kbnode (keyblock);
1989       do_sync ();
1990     }
1991
1992   klist = utk_list;
1993
1994   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1995            opt.marginals_needed,opt.completes_needed,trust_model_string());
1996
1997   for (depth=0; depth < opt.max_cert_depth; depth++)
1998     {
1999       int valids=0,key_count;
2000       /* See whether we should assign ownertrust values to the keys in
2001          klist.  */
2002       ot_unknown = ot_undefined = ot_never = 0;
2003       ot_marginal = ot_full = ot_ultimate = 0;
2004       for (k=klist; k; k = k->next)
2005         {
2006           int min=0;
2007
2008           /* 120 and 60 are as per RFC2440 */
2009           if(k->trust_value>=120)
2010             min=TRUST_FULLY;
2011           else if(k->trust_value>=60)
2012             min=TRUST_MARGINAL;
2013
2014           if(min!=k->min_ownertrust)
2015             update_min_ownertrust(k->kid,min);
2016
2017           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2018             {
2019               k->ownertrust = ask_ownertrust (k->kid,min);
2020
2021               if (k->ownertrust == -1)
2022                 {
2023                   quit=1;
2024                   goto leave;
2025                 }
2026             }
2027
2028           /* This can happen during transition from an old trustdb
2029              before trust sigs.  It can also happen if a user uses two
2030              different versions of GnuPG or changes the --trust-model
2031              setting. */
2032           if(k->ownertrust<min)
2033             {
2034               if(DBG_TRUST)
2035                 log_debug("key %08lX: "
2036                           "overriding ownertrust \"%s\" with \"%s\"\n",
2037                           (ulong)k->kid[1],
2038                           trust_value_to_string(k->ownertrust),
2039                           trust_value_to_string(min));
2040
2041               k->ownertrust=min;
2042             }
2043
2044           if (k->ownertrust == TRUST_UNKNOWN)
2045             ot_unknown++;
2046           else if (k->ownertrust == TRUST_UNDEFINED)
2047             ot_undefined++;
2048           else if (k->ownertrust == TRUST_NEVER)
2049             ot_never++;
2050           else if (k->ownertrust == TRUST_MARGINAL)
2051             ot_marginal++;
2052           else if (k->ownertrust == TRUST_FULLY)
2053             ot_full++;
2054           else if (k->ownertrust == TRUST_ULTIMATE)
2055             ot_ultimate++;
2056
2057           valids++;
2058         }
2059
2060       /* Find all keys which are signed by a key in kdlist */
2061       keys = validate_key_list (kdb, full_trust, klist,
2062                                 start_time, &next_expire);
2063       if (!keys) 
2064         {
2065           log_error ("validate_key_list failed\n");
2066           rc = G10ERR_GENERAL;
2067           goto leave;
2068         }
2069
2070       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2071         ;
2072
2073       /* Store the calculated valididation status somewhere */
2074       if (opt.verbose > 1)
2075         dump_key_array (depth, keys);
2076
2077       for (kar=keys; kar->keyblock; kar++)
2078           store_validation_status (depth, kar->keyblock, stored);
2079
2080       log_info (_("depth: %d  valid: %3d  signed: %3d"
2081                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2082                 depth, valids, key_count, ot_unknown, ot_undefined,
2083                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2084
2085       /* Build a new kdlist from all fully valid keys in KEYS */
2086       if (klist != utk_list)
2087         release_key_items (klist);
2088       klist = NULL;
2089       for (kar=keys; kar->keyblock; kar++)
2090         {
2091           for (node=kar->keyblock; node; node = node->next)
2092             {
2093               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2094                 {
2095                   u32 kid[2];
2096
2097                   /* have we used this key already? */
2098                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2099                   if(test_key_hash_table(used,kid)==0)
2100                     {
2101                       /* Normally we add both the primary and subkey
2102                          ids to the hash via mark_keyblock_seen, but
2103                          since we aren't using this hash as a skipfnc,
2104                          that doesn't matter here. */
2105                       add_key_hash_table (used,kid);
2106                       k = new_key_item ();
2107                       k->kid[0]=kid[0];
2108                       k->kid[1]=kid[1];
2109                       k->ownertrust =
2110                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2111                          & TRUST_MASK);
2112                       k->min_ownertrust =
2113                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2114                       k->trust_depth=
2115                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2116                       k->trust_value=
2117                         kar->keyblock->pkt->pkt.public_key->trust_value;
2118                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2119                         k->trust_regexp=
2120                           m_strdup(kar->keyblock->pkt->
2121                                    pkt.public_key->trust_regexp);
2122                       k->next = klist;
2123                       klist = k;
2124                       break;
2125                     }
2126                 }
2127             }
2128         }
2129       release_key_array (keys);
2130       keys = NULL;
2131       if (!klist)
2132         break; /* no need to dive in deeper */
2133     }
2134
2135  leave:
2136   keydb_release (kdb);
2137   release_key_array (keys);
2138   release_key_items (klist);
2139   release_key_hash_table (full_trust);
2140   release_key_hash_table (used);
2141   release_key_hash_table (stored);
2142   if (!rc && !quit) /* mark trustDB as checked */
2143     {
2144       if (next_expire == 0xffffffff || next_expire < start_time )
2145         tdbio_write_nextcheck (0); 
2146       else
2147         {
2148           tdbio_write_nextcheck (next_expire); 
2149           log_info (_("next trustdb check due at %s\n"),
2150                     strtimestamp (next_expire));
2151         }
2152
2153       if(tdbio_update_version_record()!=0)
2154         {
2155           log_error(_("unable to update trustdb version record: "
2156                       "write failed: %s\n"), g10_errstr(rc));
2157           tdbio_invalid();
2158         }
2159
2160       do_sync ();
2161       pending_check_trustdb = 0;
2162     }
2163
2164   return rc;
2165 }