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