gpg: Silence two more warnings.
[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   if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
1005     {
1006       kbnode_t user_id_node = NULL; /* Silence -Wmaybe-uninitialized.  */
1007       int user_ids = 0;
1008       int user_ids_expired = 0;
1009
1010       char fingerprint[MAX_FINGERPRINT_LEN];
1011       size_t fingerprint_len = sizeof (fingerprint);
1012
1013       fingerprint_from_pk (main_pk, fingerprint, &fingerprint_len);
1014       assert (fingerprint_len == sizeof (fingerprint));
1015
1016       /* If the caller didn't supply a user id then iterate over all
1017          uids.  */
1018       if (! uid)
1019         user_id_node = get_pubkeyblock (main_pk->keyid);
1020
1021       while (uid
1022              || (user_id_node = find_next_kbnode (user_id_node, PKT_USER_ID)))
1023         {
1024           unsigned int tl;
1025           PKT_user_id *user_id;
1026
1027           if (uid)
1028             user_id = uid;
1029           else
1030             user_id = user_id_node->pkt->pkt.user_id;
1031
1032           if (user_id->is_revoked || user_id->is_expired)
1033             /* If the user id is revoked or expired, then skip it.  */
1034             {
1035               char *s;
1036               if (user_id->is_revoked && user_id->is_expired)
1037                 s = "revoked and expired";
1038               else if (user_id->is_revoked)
1039                 s = "revoked";
1040               else
1041                 s = "expire";
1042
1043               log_info ("TOFU: Ignoring %s user id (%s)\n", s, user_id->name);
1044
1045               continue;
1046             }
1047
1048           user_ids ++;
1049
1050           if (sig)
1051             tl = tofu_register (fingerprint, user_id->name,
1052                                 sig->digest, sig->digest_len,
1053                                 sig->timestamp, "unknown",
1054                                 may_ask);
1055           else
1056             tl = tofu_get_validity (fingerprint, user_id->name, may_ask);
1057
1058           if (tl == TRUST_EXPIRED)
1059             user_ids_expired ++;
1060           else if (tl == TRUST_UNDEFINED || tl == TRUST_UNKNOWN)
1061             ;
1062           else if (tl == TRUST_NEVER)
1063             tofu_validity = TRUST_NEVER;
1064           else
1065             {
1066               assert (tl == TRUST_MARGINAL
1067                       || tl == TRUST_FULLY
1068                       || tl == TRUST_ULTIMATE);
1069
1070               if (tl > tofu_validity)
1071                 /* XXX: We we really want the max?  */
1072                 tofu_validity = tl;
1073             }
1074
1075           if (uid)
1076             /* If the caller specified a user id, then we stop
1077                now.  */
1078             break;
1079         }
1080     }
1081
1082   if (opt.trust_model == TM_TOFU_PGP
1083       || opt.trust_model == TM_CLASSIC
1084       || opt.trust_model == TM_PGP)
1085     {
1086       err = read_trust_record (main_pk, &trec);
1087       if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1088         {
1089           tdbio_invalid ();
1090           return 0;
1091         }
1092       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1093         {
1094           /* No record found.  */
1095           validity = TRUST_UNKNOWN;
1096           goto leave;
1097         }
1098
1099       /* Loop over all user IDs */
1100       recno = trec.r.trust.validlist;
1101       validity = 0;
1102       while (recno)
1103         {
1104           read_record (recno, &vrec, RECTYPE_VALID);
1105
1106           if(uid)
1107             {
1108               /* If a user ID is given we return the validity for that
1109                  user ID ONLY.  If the namehash is not found, then
1110                  there is no validity at all (i.e. the user ID wasn't
1111                  signed). */
1112               if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1113                 {
1114                   validity=(vrec.r.valid.validity & TRUST_MASK);
1115                   break;
1116                 }
1117             }
1118           else
1119             {
1120               /* If no user ID is given, we take the maximum validity
1121                  over all user IDs */
1122               if (validity < (vrec.r.valid.validity & TRUST_MASK))
1123                 validity = (vrec.r.valid.validity & TRUST_MASK);
1124             }
1125
1126           recno = vrec.r.valid.next;
1127         }
1128
1129       if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
1130         {
1131           validity |= TRUST_FLAG_DISABLED;
1132           pk->flags.disabled = 1;
1133         }
1134       else
1135         pk->flags.disabled = 0;
1136       pk->flags.disabled_valid = 1;
1137     }
1138
1139  leave:
1140   validity = tofu_wot_trust_combine (tofu_validity, validity);
1141
1142   if (opt.trust_model != TM_TOFU
1143       && pending_check_trustdb)
1144     validity |= TRUST_FLAG_PENDING_CHECK;
1145
1146   return validity;
1147 }
1148
1149
1150 static void
1151 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1152 {
1153   TRUSTREC trec, vrec;
1154   ulong recno;
1155
1156   if(pk==NULL || uid==NULL)
1157     BUG();
1158
1159   namehash_from_uid(uid);
1160
1161   uid->help_marginal_count=uid->help_full_count=0;
1162
1163   init_trustdb ();
1164
1165   if(read_trust_record (pk, &trec))
1166     return;
1167
1168   /* loop over all user IDs */
1169   recno = trec.r.trust.validlist;
1170   while (recno)
1171     {
1172       read_record (recno, &vrec, RECTYPE_VALID);
1173
1174       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1175         {
1176           uid->help_marginal_count=vrec.r.valid.marginal_count;
1177           uid->help_full_count=vrec.r.valid.full_count;
1178           /*  es_printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1179           break;
1180         }
1181
1182       recno = vrec.r.valid.next;
1183     }
1184 }
1185
1186 void
1187 list_trust_path( const char *username )
1188 {
1189   (void)username;
1190 }
1191
1192 /****************
1193  * Enumerate all keys, which are needed to build all trust paths for
1194  * the given key.  This function does not return the key itself or
1195  * the ultimate key (the last point in cerificate chain).  Only
1196  * certificate chains which ends up at an ultimately trusted key
1197  * are listed.  If ownertrust or validity is not NULL, the corresponding
1198  * value for the returned LID is also returned in these variable(s).
1199  *
1200  *  1) create a void pointer and initialize it to NULL
1201  *  2) pass this void pointer by reference to this function.
1202  *     Set lid to the key you want to enumerate and pass it by reference.
1203  *  3) call this function as long as it does not return -1
1204  *     to indicate EOF. LID does contain the next key used to build the web
1205  *  4) Always call this function a last time with LID set to NULL,
1206  *     so that it can free its context.
1207  *
1208  * Returns: -1 on EOF or the level of the returned LID
1209  */
1210 int
1211 enum_cert_paths( void **context, ulong *lid,
1212                  unsigned *ownertrust, unsigned *validity )
1213 {
1214   (void)context;
1215   (void)lid;
1216   (void)ownertrust;
1217   (void)validity;
1218   return -1;
1219 }
1220
1221
1222 /****************
1223  * Print the current path
1224  */
1225 void
1226 enum_cert_paths_print (void **context, FILE *fp,
1227                        int refresh, ulong selected_lid)
1228 {
1229   (void)context;
1230   (void)fp;
1231   (void)refresh;
1232   (void)selected_lid;
1233 }
1234
1235
1236 \f
1237 /****************************************
1238  *********** NEW NEW NEW ****************
1239  ****************************************/
1240
1241 static int
1242 ask_ownertrust (u32 *kid,int minimum)
1243 {
1244   PKT_public_key *pk;
1245   int rc;
1246   int ot;
1247
1248   pk = xmalloc_clear (sizeof *pk);
1249   rc = get_pubkey (pk, kid);
1250   if (rc)
1251     {
1252       log_error (_("public key %s not found: %s\n"),
1253                  keystr(kid), gpg_strerror (rc) );
1254       return TRUST_UNKNOWN;
1255     }
1256
1257   if(opt.force_ownertrust)
1258     {
1259       log_info("force trust for key %s to %s\n",
1260                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1261       tdb_update_ownertrust (pk, opt.force_ownertrust);
1262       ot=opt.force_ownertrust;
1263     }
1264   else
1265     {
1266       ot=edit_ownertrust(pk,0);
1267       if(ot>0)
1268         ot = tdb_get_ownertrust (pk);
1269       else if(ot==0)
1270         ot = minimum?minimum:TRUST_UNDEFINED;
1271       else
1272         ot = -1; /* quit */
1273     }
1274
1275   free_public_key( pk );
1276
1277   return ot;
1278 }
1279
1280
1281 static void
1282 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1283 {
1284   for ( ;node; node = node->next )
1285     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1286         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1287       {
1288         u32 aki[2];
1289
1290         keyid_from_pk (node->pkt->pkt.public_key, aki);
1291         add_key_hash_table (tbl, aki);
1292       }
1293 }
1294
1295
1296 static void
1297 dump_key_array (int depth, struct key_array *keys)
1298 {
1299   struct key_array *kar;
1300
1301   for (kar=keys; kar->keyblock; kar++)
1302     {
1303       KBNODE node = kar->keyblock;
1304       u32 kid[2];
1305
1306       keyid_from_pk(node->pkt->pkt.public_key, kid);
1307       es_printf ("%d:%08lX%08lX:K::%c::::\n",
1308                  depth, (ulong)kid[0], (ulong)kid[1], '?');
1309
1310       for (; node; node = node->next)
1311         {
1312           if (node->pkt->pkttype == PKT_USER_ID)
1313             {
1314               int len = node->pkt->pkt.user_id->len;
1315
1316               if (len > 30)
1317                 len = 30;
1318               es_printf ("%d:%08lX%08lX:U:::%c:::",
1319                          depth, (ulong)kid[0], (ulong)kid[1],
1320                          (node->flag & 4)? 'f':
1321                          (node->flag & 2)? 'm':
1322                          (node->flag & 1)? 'q':'-');
1323               es_write_sanitized (es_stdout, node->pkt->pkt.user_id->name,
1324                                   len, ":", NULL);
1325               es_putc (':', es_stdout);
1326               es_putc ('\n', es_stdout);
1327             }
1328         }
1329     }
1330 }
1331
1332
1333 static void
1334 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1335 {
1336   KBNODE node;
1337   int status;
1338   int any = 0;
1339
1340   for (node=keyblock; node; node = node->next)
1341     {
1342       if (node->pkt->pkttype == PKT_USER_ID)
1343         {
1344           PKT_user_id *uid = node->pkt->pkt.user_id;
1345           if (node->flag & 4)
1346             status = TRUST_FULLY;
1347           else if (node->flag & 2)
1348             status = TRUST_MARGINAL;
1349           else if (node->flag & 1)
1350             status = TRUST_UNDEFINED;
1351           else
1352             status = 0;
1353
1354           if (status)
1355             {
1356               update_validity (keyblock->pkt->pkt.public_key,
1357                                uid, depth, status);
1358
1359               mark_keyblock_seen(stored,keyblock);
1360
1361               any = 1;
1362             }
1363         }
1364     }
1365
1366   if (any)
1367     do_sync ();
1368 }
1369
1370
1371 /* Returns a sanitized copy of the regexp (which might be "", but not
1372    NULL). */
1373 #ifndef DISABLE_REGEX
1374 static char *
1375 sanitize_regexp(const char *old)
1376 {
1377   size_t start=0,len=strlen(old),idx=0;
1378   int escaped=0,standard_bracket=0;
1379   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
1380                                    have to */
1381
1382   /* There are basically two commonly-used regexps here.  GPG and most
1383      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
1384      command line uses "example.com" (i.e. whatever the user specfies,
1385      and we can't expect users know to use "\." instead of ".").  So
1386      here are the rules: we're allowed to start with "<[^>]+[@.]" and
1387      end with ">$" or start and end with nothing.  In between, the
1388      only legal regex character is ".", and everything else gets
1389      escaped.  Part of the gotcha here is that some regex packages
1390      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
1391      operator, but GNU regex does.  Commenting removes these operators
1392      from consideration.  A possible future enhancement is to use
1393      commenting to effectively back off a given regex to the Henry
1394      Spencer syntax in 4880. -dshaw */
1395
1396   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
1397   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
1398      && old[len-2]=='>' && old[len-1]=='$')
1399     {
1400       strcpy(new,"<[^>]+[@.]");
1401       idx=strlen(new);
1402       standard_bracket=1;
1403       start+=10;
1404       len-=2;
1405     }
1406
1407   /* Walk the remaining characters and ensure that everything that is
1408      left is not an operational regex character. */
1409   for(;start<len;start++)
1410     {
1411       if(!escaped && old[start]=='\\')
1412         escaped=1;
1413       else if(!escaped && old[start]!='.')
1414         new[idx++]='\\';
1415       else
1416         escaped=0;
1417
1418       new[idx++]=old[start];
1419     }
1420
1421   new[idx]='\0';
1422
1423   /* Note that the (sub)string we look at might end with a bare "\".
1424      If it does, leave it that way.  If the regexp actually ended with
1425      ">$", then it was escaping the ">" and is fine.  If the regexp
1426      actually ended with the bare "\", then it's an illegal regexp and
1427      regcomp should kick it out. */
1428
1429   if(standard_bracket)
1430     strcat(new,">$");
1431
1432   return new;
1433 }
1434 #endif /*!DISABLE_REGEX*/
1435
1436 /* Used by validate_one_keyblock to confirm a regexp within a trust
1437    signature.  Returns 1 for match, and 0 for no match or regex
1438    error. */
1439 static int
1440 check_regexp(const char *expr,const char *string)
1441 {
1442 #ifdef DISABLE_REGEX
1443   (void)expr;
1444   (void)string;
1445   /* When DISABLE_REGEX is defined, assume all regexps do not
1446      match. */
1447   return 0;
1448 #else
1449   int ret;
1450   char *regexp;
1451
1452   regexp=sanitize_regexp(expr);
1453
1454 #ifdef __riscos__
1455   ret=riscos_check_regexp(expr, string, DBG_TRUST);
1456 #else
1457   {
1458     regex_t pat;
1459
1460     ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
1461     if(ret==0)
1462       {
1463         ret=regexec(&pat,string,0,NULL,0);
1464         regfree(&pat);
1465         ret=(ret==0);
1466       }
1467   }
1468 #endif
1469
1470   if(DBG_TRUST)
1471     log_debug("regexp '%s' ('%s') on '%s': %s\n",
1472               regexp,expr,string,ret==0?"YES":"NO");
1473
1474   xfree(regexp);
1475
1476   return ret;
1477 #endif
1478 }
1479
1480 /*
1481  * Return true if the key is signed by one of the keys in the given
1482  * key ID list.  User IDs with a valid signature are marked by node
1483  * flags as follows:
1484  *  flag bit 0: There is at least one signature
1485  *           1: There is marginal confidence that this is a legitimate uid
1486  *           2: There is full confidence that this is a legitimate uid.
1487  *           8: Used for internal purposes.
1488  *           9: Ditto (in mark_usable_uid_certs())
1489  *          10: Ditto (ditto)
1490  * This function assumes that all kbnode flags are cleared on entry.
1491  */
1492 static int
1493 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1494                        u32 curtime, u32 *next_expire)
1495 {
1496   struct key_item *kr;
1497   KBNODE node, uidnode=NULL;
1498   PKT_user_id *uid=NULL;
1499   PKT_public_key *pk = kb->pkt->pkt.public_key;
1500   u32 main_kid[2];
1501   int issigned=0, any_signed = 0;
1502
1503   keyid_from_pk(pk, main_kid);
1504   for (node=kb; node; node = node->next)
1505     {
1506       /* A bit of discussion here: is it better for the web of trust
1507          to be built among only self-signed uids?  On the one hand, a
1508          self-signed uid is a statement that the key owner definitely
1509          intended that uid to be there, but on the other hand, a
1510          signed (but not self-signed) uid does carry trust, of a sort,
1511          even if it is a statement being made by people other than the
1512          key owner "through" the uids on the key owner's key.  I'm
1513          going with the latter.  However, if the user ID was
1514          explicitly revoked, or passively allowed to expire, that
1515          should stop validity through the user ID until it is
1516          resigned.  -dshaw */
1517
1518       if (node->pkt->pkttype == PKT_USER_ID
1519           && !node->pkt->pkt.user_id->is_revoked
1520           && !node->pkt->pkt.user_id->is_expired)
1521         {
1522           if (uidnode && issigned)
1523             {
1524               if (uid->help_full_count >= opt.completes_needed
1525                   || uid->help_marginal_count >= opt.marginals_needed )
1526                 uidnode->flag |= 4;
1527               else if (uid->help_full_count || uid->help_marginal_count)
1528                 uidnode->flag |= 2;
1529               uidnode->flag |= 1;
1530               any_signed = 1;
1531             }
1532           uidnode = node;
1533           uid=uidnode->pkt->pkt.user_id;
1534
1535           /* If the selfsig is going to expire... */
1536           if(uid->expiredate && uid->expiredate<*next_expire)
1537             *next_expire = uid->expiredate;
1538
1539           issigned = 0;
1540           get_validity_counts(pk,uid);
1541           mark_usable_uid_certs (kb, uidnode, main_kid, klist,
1542                                  curtime, next_expire);
1543         }
1544       else if (node->pkt->pkttype == PKT_SIGNATURE
1545                && (node->flag & (1<<8)) && uid)
1546         {
1547           /* Note that we are only seeing unrevoked sigs here */
1548           PKT_signature *sig = node->pkt->pkt.signature;
1549
1550           kr = is_in_klist (klist, sig);
1551           /* If the trust_regexp does not match, it's as if the sig
1552              did not exist.  This is safe for non-trust sigs as well
1553              since we don't accept a regexp on the sig unless it's a
1554              trust sig. */
1555           if (kr && (!kr->trust_regexp
1556                      || opt.trust_model != TM_PGP
1557                      || (uidnode
1558                          && check_regexp(kr->trust_regexp,
1559                                          uidnode->pkt->pkt.user_id->name))))
1560             {
1561               /* Are we part of a trust sig chain?  We always favor
1562                  the latest trust sig, rather than the greater or
1563                  lesser trust sig or value.  I could make a decent
1564                  argument for any of these cases, but this seems to be
1565                  what PGP does, and I'd like to be compatible. -dms */
1566               if (opt.trust_model == TM_PGP
1567                   && sig->trust_depth
1568                   && pk->trust_timestamp <= sig->timestamp)
1569                 {
1570                   unsigned char depth;
1571
1572                   /* If the depth on the signature is less than the
1573                      chain currently has, then use the signature depth
1574                      so we don't increase the depth beyond what the
1575                      signer wanted.  If the depth on the signature is
1576                      more than the chain currently has, then use the
1577                      chain depth so we use as much of the signature
1578                      depth as the chain will permit.  An ultimately
1579                      trusted signature can restart the depth to
1580                      whatever level it likes. */
1581
1582                   if (sig->trust_depth < kr->trust_depth
1583                       || kr->ownertrust == TRUST_ULTIMATE)
1584                     depth = sig->trust_depth;
1585                   else
1586                     depth = kr->trust_depth;
1587
1588                   if (depth)
1589                     {
1590                       if(DBG_TRUST)
1591                         log_debug ("trust sig on %s, sig depth is %d,"
1592                                    " kr depth is %d\n",
1593                                    uidnode->pkt->pkt.user_id->name,
1594                                    sig->trust_depth,
1595                                    kr->trust_depth);
1596
1597                       /* If we got here, we know that:
1598
1599                          this is a trust sig.
1600
1601                          it's a newer trust sig than any previous trust
1602                          sig on this key (not uid).
1603
1604                          it is legal in that it was either generated by an
1605                          ultimate key, or a key that was part of a trust
1606                          chain, and the depth does not violate the
1607                          original trust sig.
1608
1609                          if there is a regexp attached, it matched
1610                          successfully.
1611                       */
1612
1613                       if (DBG_TRUST)
1614                         log_debug ("replacing trust value %d with %d and "
1615                                    "depth %d with %d\n",
1616                                    pk->trust_value,sig->trust_value,
1617                                    pk->trust_depth,depth);
1618
1619                       pk->trust_value = sig->trust_value;
1620                       pk->trust_depth = depth-1;
1621
1622                       /* If the trust sig contains a regexp, record it
1623                          on the pk for the next round. */
1624                       if (sig->trust_regexp)
1625                         pk->trust_regexp = sig->trust_regexp;
1626                     }
1627                 }
1628
1629               if (kr->ownertrust == TRUST_ULTIMATE)
1630                 uid->help_full_count = opt.completes_needed;
1631               else if (kr->ownertrust == TRUST_FULLY)
1632                 uid->help_full_count++;
1633               else if (kr->ownertrust == TRUST_MARGINAL)
1634                 uid->help_marginal_count++;
1635               issigned = 1;
1636             }
1637         }
1638     }
1639
1640   if (uidnode && issigned)
1641     {
1642       if (uid->help_full_count >= opt.completes_needed
1643           || uid->help_marginal_count >= opt.marginals_needed )
1644         uidnode->flag |= 4;
1645       else if (uid->help_full_count || uid->help_marginal_count)
1646         uidnode->flag |= 2;
1647       uidnode->flag |= 1;
1648       any_signed = 1;
1649     }
1650
1651   return any_signed;
1652 }
1653
1654
1655 static int
1656 search_skipfnc (void *opaque, u32 *kid, int dummy_uid_no)
1657 {
1658   (void)dummy_uid_no;
1659   return test_key_hash_table ((KeyHashTable)opaque, kid);
1660 }
1661
1662
1663 /*
1664  * Scan all keys and return a key_array of all suitable keys from
1665  * kllist.  The caller has to pass keydb handle so that we don't use
1666  * to create our own.  Returns either a key_array or NULL in case of
1667  * an error.  No results found are indicated by an empty array.
1668  * Caller hast to release the returned array.
1669  */
1670 static struct key_array *
1671 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1672                    struct key_item *klist, u32 curtime, u32 *next_expire)
1673 {
1674   KBNODE keyblock = NULL;
1675   struct key_array *keys = NULL;
1676   size_t nkeys, maxkeys;
1677   int rc;
1678   KEYDB_SEARCH_DESC desc;
1679
1680   maxkeys = 1000;
1681   keys = xmalloc ((maxkeys+1) * sizeof *keys);
1682   nkeys = 0;
1683
1684   rc = keydb_search_reset (hd);
1685   if (rc)
1686     {
1687       log_error ("keydb_search_reset failed: %s\n", gpg_strerror (rc));
1688       xfree (keys);
1689       return NULL;
1690     }
1691
1692   memset (&desc, 0, sizeof desc);
1693   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1694   desc.skipfnc = search_skipfnc;
1695   desc.skipfncvalue = full_trust;
1696   rc = keydb_search (hd, &desc, 1, NULL);
1697   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1698     {
1699       keys[nkeys].keyblock = NULL;
1700       return keys;
1701     }
1702   if (rc)
1703     {
1704       log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
1705       xfree (keys);
1706       return NULL;
1707     }
1708
1709   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1710   do
1711     {
1712       PKT_public_key *pk;
1713
1714       if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1715         continue;
1716
1717       rc = keydb_get_keyblock (hd, &keyblock);
1718       if (rc)
1719         {
1720           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
1721           xfree (keys);
1722           return NULL;
1723         }
1724
1725       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1726         {
1727           log_debug ("ooops: invalid pkttype %d encountered\n",
1728                      keyblock->pkt->pkttype);
1729           dump_kbnode (keyblock);
1730           release_kbnode(keyblock);
1731           continue;
1732         }
1733
1734       /* prepare the keyblock for further processing */
1735       merge_keys_and_selfsig (keyblock);
1736       clear_kbnode_flags (keyblock);
1737       pk = keyblock->pkt->pkt.public_key;
1738       if (pk->has_expired || pk->flags.revoked)
1739         {
1740           /* it does not make sense to look further at those keys */
1741           mark_keyblock_seen (full_trust, keyblock);
1742         }
1743       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1744         {
1745           KBNODE node;
1746
1747           if (pk->expiredate && pk->expiredate >= curtime
1748               && pk->expiredate < *next_expire)
1749             *next_expire = pk->expiredate;
1750
1751           if (nkeys == maxkeys) {
1752             maxkeys += 1000;
1753             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
1754           }
1755           keys[nkeys++].keyblock = keyblock;
1756
1757           /* Optimization - if all uids are fully trusted, then we
1758              never need to consider this key as a candidate again. */
1759
1760           for (node=keyblock; node; node = node->next)
1761             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1762               break;
1763
1764           if(node==NULL)
1765             mark_keyblock_seen (full_trust, keyblock);
1766
1767           keyblock = NULL;
1768         }
1769
1770       release_kbnode (keyblock);
1771       keyblock = NULL;
1772     }
1773   while (!(rc = keydb_search (hd, &desc, 1, NULL))
1774          || gpg_err_code (rc) == GPG_ERR_LEGACY_KEY);
1775
1776   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
1777     {
1778       log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
1779       xfree (keys);
1780       return NULL;
1781     }
1782
1783   keys[nkeys].keyblock = NULL;
1784   return keys;
1785 }
1786
1787 /* Caller must sync */
1788 static void
1789 reset_trust_records(void)
1790 {
1791   TRUSTREC rec;
1792   ulong recnum;
1793   int count = 0, nreset = 0;
1794
1795   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
1796     {
1797       if(rec.rectype==RECTYPE_TRUST)
1798         {
1799           count++;
1800           if(rec.r.trust.min_ownertrust)
1801             {
1802               rec.r.trust.min_ownertrust=0;
1803               write_record(&rec);
1804             }
1805
1806         }
1807       else if(rec.rectype==RECTYPE_VALID
1808               && ((rec.r.valid.validity&TRUST_MASK)
1809                   || rec.r.valid.marginal_count
1810                   || rec.r.valid.full_count))
1811         {
1812           rec.r.valid.validity &= ~TRUST_MASK;
1813           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1814           nreset++;
1815           write_record(&rec);
1816         }
1817
1818     }
1819
1820   if (opt.verbose)
1821     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1822               count, nreset);
1823 }
1824
1825 /*
1826  * Run the key validation procedure.
1827  *
1828  * This works this way:
1829  * Step 1: Find all ultimately trusted keys (UTK).
1830  *         mark them all as seen and put them into klist.
1831  * Step 2: loop max_cert_times
1832  * Step 3:   if OWNERTRUST of any key in klist is undefined
1833  *             ask user to assign ownertrust
1834  * Step 4:   Loop over all keys in the keyDB which are not marked seen
1835  * Step 5:     if key is revoked or expired
1836  *                mark key as seen
1837  *                continue loop at Step 4
1838  * Step 6:     For each user ID of that key signed by a key in klist
1839  *                Calculate validity by counting trusted signatures.
1840  *                Set validity of user ID
1841  * Step 7:     If any signed user ID was found
1842  *                mark key as seen
1843  *             End Loop
1844  * Step 8:   Build a new klist from all fully trusted keys from step 6
1845  *           End Loop
1846  *         Ready
1847  *
1848  */
1849 static int
1850 validate_keys (int interactive)
1851 {
1852   int rc = 0;
1853   int quit=0;
1854   struct key_item *klist = NULL;
1855   struct key_item *k;
1856   struct key_array *keys = NULL;
1857   struct key_array *kar;
1858   KEYDB_HANDLE kdb = NULL;
1859   KBNODE node;
1860   int depth;
1861   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1862   KeyHashTable stored,used,full_trust;
1863   u32 start_time, next_expire;
1864
1865   /* Make sure we have all sigs cached.  TODO: This is going to
1866      require some architectual re-thinking, as it is agonizingly slow.
1867      Perhaps combine this with reset_trust_records(), or only check
1868      the caches on keys that are actually involved in the web of
1869      trust. */
1870   keydb_rebuild_caches(0);
1871
1872   start_time = make_timestamp ();
1873   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1874   stored = new_key_hash_table ();
1875   used = new_key_hash_table ();
1876   full_trust = new_key_hash_table ();
1877
1878   kdb = keydb_new ();
1879   reset_trust_records();
1880
1881   /* Fixme: Instead of always building a UTK list, we could just build it
1882    * here when needed */
1883   if (!utk_list)
1884     {
1885       if (!opt.quiet)
1886         log_info (_("no ultimately trusted keys found\n"));
1887       goto leave;
1888     }
1889
1890   /* mark all UTKs as used and fully_trusted and set validity to
1891      ultimate */
1892   for (k=utk_list; k; k = k->next)
1893     {
1894       KBNODE keyblock;
1895       PKT_public_key *pk;
1896
1897       keyblock = get_pubkeyblock (k->kid);
1898       if (!keyblock)
1899         {
1900           log_error (_("public key of ultimately"
1901                        " trusted key %s not found\n"), keystr(k->kid));
1902           continue;
1903         }
1904       mark_keyblock_seen (used, keyblock);
1905       mark_keyblock_seen (stored, keyblock);
1906       mark_keyblock_seen (full_trust, keyblock);
1907       pk = keyblock->pkt->pkt.public_key;
1908       for (node=keyblock; node; node = node->next)
1909         {
1910           if (node->pkt->pkttype == PKT_USER_ID)
1911             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1912         }
1913       if ( pk->expiredate && pk->expiredate >= start_time
1914            && pk->expiredate < next_expire)
1915         next_expire = pk->expiredate;
1916
1917       release_kbnode (keyblock);
1918       do_sync ();
1919     }
1920
1921   klist = utk_list;
1922
1923   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1924            opt.marginals_needed,opt.completes_needed,trust_model_string());
1925
1926   for (depth=0; depth < opt.max_cert_depth; depth++)
1927     {
1928       int valids=0,key_count;
1929       /* See whether we should assign ownertrust values to the keys in
1930          klist.  */
1931       ot_unknown = ot_undefined = ot_never = 0;
1932       ot_marginal = ot_full = ot_ultimate = 0;
1933       for (k=klist; k; k = k->next)
1934         {
1935           int min=0;
1936
1937           /* 120 and 60 are as per RFC2440 */
1938           if(k->trust_value>=120)
1939             min=TRUST_FULLY;
1940           else if(k->trust_value>=60)
1941             min=TRUST_MARGINAL;
1942
1943           if(min!=k->min_ownertrust)
1944             update_min_ownertrust(k->kid,min);
1945
1946           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1947             {
1948               k->ownertrust = ask_ownertrust (k->kid,min);
1949
1950               if (k->ownertrust == (unsigned int)(-1))
1951                 {
1952                   quit=1;
1953                   goto leave;
1954                 }
1955             }
1956
1957           /* This can happen during transition from an old trustdb
1958              before trust sigs.  It can also happen if a user uses two
1959              different versions of GnuPG or changes the --trust-model
1960              setting. */
1961           if(k->ownertrust<min)
1962             {
1963               if(DBG_TRUST)
1964                 log_debug("key %08lX%08lX:"
1965                           " overriding ownertrust '%s' with '%s'\n",
1966                           (ulong)k->kid[0],(ulong)k->kid[1],
1967                           trust_value_to_string(k->ownertrust),
1968                           trust_value_to_string(min));
1969
1970               k->ownertrust=min;
1971             }
1972
1973           if (k->ownertrust == TRUST_UNKNOWN)
1974             ot_unknown++;
1975           else if (k->ownertrust == TRUST_UNDEFINED)
1976             ot_undefined++;
1977           else if (k->ownertrust == TRUST_NEVER)
1978             ot_never++;
1979           else if (k->ownertrust == TRUST_MARGINAL)
1980             ot_marginal++;
1981           else if (k->ownertrust == TRUST_FULLY)
1982             ot_full++;
1983           else if (k->ownertrust == TRUST_ULTIMATE)
1984             ot_ultimate++;
1985
1986           valids++;
1987         }
1988
1989       /* Find all keys which are signed by a key in kdlist */
1990       keys = validate_key_list (kdb, full_trust, klist,
1991                                 start_time, &next_expire);
1992       if (!keys)
1993         {
1994           log_error ("validate_key_list failed\n");
1995           rc = GPG_ERR_GENERAL;
1996           goto leave;
1997         }
1998
1999       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2000         ;
2001
2002       /* Store the calculated valididation status somewhere */
2003       if (opt.verbose > 1 && DBG_TRUST)
2004         dump_key_array (depth, keys);
2005
2006       for (kar=keys; kar->keyblock; kar++)
2007           store_validation_status (depth, kar->keyblock, stored);
2008
2009       log_info (_("depth: %d  valid: %3d  signed: %3d"
2010                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
2011                 depth, valids, key_count, ot_unknown, ot_undefined,
2012                 ot_never, ot_marginal, ot_full, ot_ultimate );
2013
2014       /* Build a new kdlist from all fully valid keys in KEYS */
2015       if (klist != utk_list)
2016         release_key_items (klist);
2017       klist = NULL;
2018       for (kar=keys; kar->keyblock; kar++)
2019         {
2020           for (node=kar->keyblock; node; node = node->next)
2021             {
2022               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2023                 {
2024                   u32 kid[2];
2025
2026                   /* have we used this key already? */
2027                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2028                   if(test_key_hash_table(used,kid)==0)
2029                     {
2030                       /* Normally we add both the primary and subkey
2031                          ids to the hash via mark_keyblock_seen, but
2032                          since we aren't using this hash as a skipfnc,
2033                          that doesn't matter here. */
2034                       add_key_hash_table (used,kid);
2035                       k = new_key_item ();
2036                       k->kid[0]=kid[0];
2037                       k->kid[1]=kid[1];
2038                       k->ownertrust =
2039                         (tdb_get_ownertrust
2040                          (kar->keyblock->pkt->pkt.public_key) & TRUST_MASK);
2041                       k->min_ownertrust = tdb_get_min_ownertrust
2042                         (kar->keyblock->pkt->pkt.public_key);
2043                       k->trust_depth=
2044                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2045                       k->trust_value=
2046                         kar->keyblock->pkt->pkt.public_key->trust_value;
2047                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2048                         k->trust_regexp=
2049                           xstrdup(kar->keyblock->pkt->
2050                                    pkt.public_key->trust_regexp);
2051                       k->next = klist;
2052                       klist = k;
2053                       break;
2054                     }
2055                 }
2056             }
2057         }
2058       release_key_array (keys);
2059       keys = NULL;
2060       if (!klist)
2061         break; /* no need to dive in deeper */
2062     }
2063
2064  leave:
2065   keydb_release (kdb);
2066   release_key_array (keys);
2067   release_key_items (klist);
2068   release_key_hash_table (full_trust);
2069   release_key_hash_table (used);
2070   release_key_hash_table (stored);
2071   if (!rc && !quit) /* mark trustDB as checked */
2072     {
2073       if (next_expire == 0xffffffff || next_expire < start_time )
2074         tdbio_write_nextcheck (0);
2075       else
2076         {
2077           tdbio_write_nextcheck (next_expire);
2078           log_info (_("next trustdb check due at %s\n"),
2079                     strtimestamp (next_expire));
2080         }
2081
2082       if(tdbio_update_version_record()!=0)
2083         {
2084           log_error(_("unable to update trustdb version record: "
2085                       "write failed: %s\n"), gpg_strerror (rc));
2086           tdbio_invalid();
2087         }
2088
2089       do_sync ();
2090       pending_check_trustdb = 0;
2091     }
2092
2093   return rc;
2094 }