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