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