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