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