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