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