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