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