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