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