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