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