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