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