g10: Extend TOFU_STATS to always show the validity
[gnupg.git] / g10 / tofu.c
1 /* tofu.c - TOFU trust model.
2  * Copyright (C) 2015, 2016 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 /* TODO:
21
22    - Format the fingerprints nicely when printing (similar to gpg
23      --list-keys)
24  */
25
26 #include <config.h>
27 #include <stdio.h>
28 #include <sys/stat.h>
29 #include <stdarg.h>
30 #include <sqlite3.h>
31 #include <time.h>
32
33 #include "gpg.h"
34 #include "types.h"
35 #include "logging.h"
36 #include "stringhelp.h"
37 #include "options.h"
38 #include "mbox-util.h"
39 #include "i18n.h"
40 #include "ttyio.h"
41 #include "trustdb.h"
42 #include "mkdir_p.h"
43 #include "gpgsql.h"
44 #include "status.h"
45 #include "sqrtu32.h"
46
47 #include "tofu.h"
48
49
50 #define CONTROL_L ('L' - 'A' + 1)
51
52 /* Number of signed messages required to indicate that enough history
53  * is available for basic trust.  */
54 #define BASIC_TRUST_THRESHOLD  10
55 /* Number of signed messages required to indicate that a lot of
56  * history is available.  */
57 #define FULL_TRUST_THRESHOLD  100
58
59
60 /* An struct with data pertaining to the tofu DB.
61
62    To initialize this data structure, call opendbs().  Cleanup is done
63    when the CTRL object is released.  To get a handle to a database,
64    use the getdb() function.  This will either return an existing
65    handle or open a new DB connection, as appropriate.  */
66 struct tofu_dbs_s
67 {
68   sqlite3 *db;
69   char *want_lock_file;
70   time_t want_lock_file_ctime;
71
72   struct
73   {
74     sqlite3_stmt *savepoint_batch;
75     sqlite3_stmt *savepoint_batch_commit;
76
77     sqlite3_stmt *record_binding_get_old_policy;
78     sqlite3_stmt *record_binding_update;
79     sqlite3_stmt *get_policy_select_policy_and_conflict;
80     sqlite3_stmt *get_trust_bindings_with_this_email;
81     sqlite3_stmt *get_trust_gather_other_user_ids;
82     sqlite3_stmt *get_trust_gather_signature_stats;
83     sqlite3_stmt *get_trust_gather_encryption_stats;
84     sqlite3_stmt *register_already_seen;
85     sqlite3_stmt *register_signature;
86     sqlite3_stmt *register_encryption;
87   } s;
88
89   int in_batch_transaction;
90   int in_transaction;
91   time_t batch_update_started;
92 };
93
94
95 #define STRINGIFY(s) STRINGIFY2(s)
96 #define STRINGIFY2(s) #s
97
98 /* The grouping parameters when collecting signature statistics.  */
99
100 /* If a message is signed a couple of hours in the future, just assume
101    some clock skew.  */
102 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
103 /* Days.  */
104 #define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
105 #define TIME_AGO_SMALL_THRESHOLD (7 * TIME_AGO_UNIT_SMALL)
106 /* Months.  */
107 #define TIME_AGO_UNIT_MEDIUM (30 * 24 * 60 * 60)
108 #define TIME_AGO_MEDIUM_THRESHOLD (2 * TIME_AGO_UNIT_MEDIUM)
109 /* Years.  */
110 #define TIME_AGO_UNIT_LARGE (365 * 24 * 60 * 60)
111 #define TIME_AGO_LARGE_THRESHOLD (2 * TIME_AGO_UNIT_LARGE)
112
113 /* Local prototypes.  */
114 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
115 static char *email_from_user_id (const char *user_id);
116
117
118 \f
119 const char *
120 tofu_policy_str (enum tofu_policy policy)
121 {
122   switch (policy)
123     {
124     case TOFU_POLICY_NONE: return "none";
125     case TOFU_POLICY_AUTO: return "auto";
126     case TOFU_POLICY_GOOD: return "good";
127     case TOFU_POLICY_UNKNOWN: return "unknown";
128     case TOFU_POLICY_BAD: return "bad";
129     case TOFU_POLICY_ASK: return "ask";
130     default: return "???";
131     }
132 }
133
134 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
135    (e.g., TRUST_BAD) in light of the current configuration.  */
136 int
137 tofu_policy_to_trust_level (enum tofu_policy policy)
138 {
139   if (policy == TOFU_POLICY_AUTO)
140     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
141     policy = opt.tofu_default_policy;
142
143   switch (policy)
144     {
145     case TOFU_POLICY_AUTO:
146       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
147          to marginal trust.  */
148       return TRUST_MARGINAL;
149     case TOFU_POLICY_GOOD:
150       return TRUST_FULLY;
151     case TOFU_POLICY_UNKNOWN:
152       return TRUST_UNKNOWN;
153     case TOFU_POLICY_BAD:
154       return TRUST_NEVER;
155     case TOFU_POLICY_ASK:
156       return TRUST_UNKNOWN;
157     default:
158       log_bug ("Bad value for trust policy: %d\n",
159                opt.tofu_default_policy);
160       return 0;
161     }
162 }
163
164
165 \f
166 /* Start a transaction on DB.  If ONLY_BATCH is set, then this will
167    start a batch transaction if we haven't started a batch transaction
168    and one has been requested.  */
169 static gpg_error_t
170 begin_transaction (ctrl_t ctrl, int only_batch)
171 {
172   tofu_dbs_t dbs = ctrl->tofu.dbs;
173   int rc;
174   char *err = NULL;
175
176   log_assert (dbs);
177
178   /* If we've been in batch update mode for a while (on average, more
179    * than 500 ms), to prevent starving other gpg processes, we drop
180    * and retake the batch lock.
181    *
182    * Note: if we wanted higher resolution, we could use
183    * npth_clock_gettime.  */
184   if (/* No real transactions.  */
185       dbs->in_transaction == 0
186       /* There is an open batch transaction.  */
187       && dbs->in_batch_transaction
188       /* And some time has gone by since it was started.  */
189       && dbs->batch_update_started != gnupg_get_time ())
190     {
191       struct stat statbuf;
192
193       /* If we are in a batch update, then batch updates better have
194          been enabled.  */
195       log_assert (ctrl->tofu.batch_updated_wanted);
196
197       /* Check if another process wants to run.  (We just ignore any
198        * stat failure.  A waiter might have to wait a bit longer, but
199        * otherwise there should be no impact.)  */
200       if (stat (dbs->want_lock_file, &statbuf) == 0
201           && statbuf.st_ctime != dbs->want_lock_file_ctime)
202         {
203           end_transaction (ctrl, 2);
204
205           /* Yield to allow another process a chance to run.  Note:
206            * testing suggests that anything less than a 100ms tends to
207            * not result in the other process getting the lock.  */
208           gnupg_usleep (100000);
209         }
210       else
211         dbs->batch_update_started = gnupg_get_time ();
212     }
213
214   if (/* We don't have an open batch transaction.  */
215       !dbs->in_batch_transaction
216       && (/* Batch mode is enabled or we are starting a new transaction.  */
217           ctrl->tofu.batch_updated_wanted || dbs->in_transaction == 0))
218     {
219       struct stat statbuf;
220
221       /* We are in batch mode, but we don't have an open batch
222        * transaction.  Since the batch save point must be the outer
223        * save point, it must be taken before the inner save point.  */
224       log_assert (dbs->in_transaction == 0);
225
226       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
227                           NULL, NULL, &err,
228                           "begin immediate transaction;", GPGSQL_ARG_END);
229       if (rc)
230         {
231           log_error (_("error beginning transaction on TOFU database: %s\n"),
232                      err);
233           sqlite3_free (err);
234           return gpg_error (GPG_ERR_GENERAL);
235         }
236
237       dbs->in_batch_transaction = 1;
238       dbs->batch_update_started = gnupg_get_time ();
239
240       if (stat (dbs->want_lock_file, &statbuf) == 0)
241         dbs->want_lock_file_ctime = statbuf.st_ctime;
242     }
243
244   if (only_batch)
245     return 0;
246
247   log_assert (dbs->in_transaction >= 0);
248   dbs->in_transaction ++;
249
250   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
251                            "savepoint inner%d;",
252                            dbs->in_transaction);
253   if (rc)
254     {
255       log_error (_("error beginning transaction on TOFU database: %s\n"),
256                  err);
257       sqlite3_free (err);
258       return gpg_error (GPG_ERR_GENERAL);
259     }
260
261   return 0;
262 }
263
264
265 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
266  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
267  * this ends any open batch transaction even if we are still in batch
268  * mode.  */
269 static gpg_error_t
270 end_transaction (ctrl_t ctrl, int only_batch)
271 {
272   tofu_dbs_t dbs = ctrl->tofu.dbs;
273   int rc;
274   char *err = NULL;
275
276   if (only_batch || (! only_batch && dbs->in_transaction == 1))
277     {
278       if (!dbs)
279         return 0;  /* Shortcut to allow for easier cleanup code.  */
280
281       /* If we are releasing the batch transaction, then we better not
282          be in a normal transaction.  */
283       if (only_batch)
284         log_assert (dbs->in_transaction == 0);
285
286       if (/* Batch mode disabled?  */
287           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
288           /* But, we still have an open batch transaction?  */
289           && dbs->in_batch_transaction)
290         {
291           /* The batch transaction is still in open, but we've left
292            * batch mode.  */
293           dbs->in_batch_transaction = 0;
294           dbs->in_transaction = 0;
295
296           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
297                              NULL, NULL, &err,
298                              "commit transaction;", GPGSQL_ARG_END);
299           if (rc)
300             {
301               log_error (_("error committing transaction on TOFU database: %s\n"),
302                          err);
303               sqlite3_free (err);
304               return gpg_error (GPG_ERR_GENERAL);
305             }
306
307           return 0;
308         }
309
310       if (only_batch)
311         return 0;
312     }
313
314   log_assert (dbs);
315   log_assert (dbs->in_transaction > 0);
316
317   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
318                            "release inner%d;", dbs->in_transaction);
319
320   dbs->in_transaction --;
321
322   if (rc)
323     {
324       log_error (_("error committing transaction on TOFU database: %s\n"),
325                  err);
326       sqlite3_free (err);
327       return gpg_error (GPG_ERR_GENERAL);
328     }
329
330   return 0;
331 }
332
333
334 static gpg_error_t
335 rollback_transaction (ctrl_t ctrl)
336 {
337   tofu_dbs_t dbs = ctrl->tofu.dbs;
338   int rc;
339   char *err = NULL;
340
341   log_assert (dbs);
342   log_assert (dbs->in_transaction > 0);
343
344   /* Be careful to not any progress made by closed transactions in
345      batch mode.  */
346   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
347                            "rollback to inner%d;",
348                            dbs->in_transaction);
349
350   dbs->in_transaction --;
351
352   if (rc)
353     {
354       log_error (_("error rolling back transaction on TOFU database: %s\n"),
355                  err);
356       sqlite3_free (err);
357       return gpg_error (GPG_ERR_GENERAL);
358     }
359
360   return 0;
361 }
362
363 void
364 tofu_begin_batch_update (ctrl_t ctrl)
365 {
366   ctrl->tofu.batch_updated_wanted ++;
367 }
368
369 void
370 tofu_end_batch_update (ctrl_t ctrl)
371 {
372   log_assert (ctrl->tofu.batch_updated_wanted > 0);
373   ctrl->tofu.batch_updated_wanted --;
374   end_transaction (ctrl, 1);
375 }
376
377 /* Suspend any extant batch transaction (it is safe to call this even
378    no batch transaction has been started).  Note: you cannot suspend a
379    batch transaction if you are in a normal transaction.  The batch
380    transaction can be resumed explicitly by calling
381    tofu_resume_batch_transaction or implicitly by starting a normal
382    transaction.  */
383 static void
384 tofu_suspend_batch_transaction (ctrl_t ctrl)
385 {
386   end_transaction (ctrl, 2);
387 }
388
389 /* Resume a batch transaction if there is no extant batch transaction
390    and one has been requested using tofu_begin_batch_transaction.  */
391 static void
392 tofu_resume_batch_transaction (ctrl_t ctrl)
393 {
394   begin_transaction (ctrl, 1);
395 }
396
397
398 \f
399 /* Wrapper around strtol which prints a warning in case of a
400  * conversion error.  On success the converted value is stored at
401  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
402  * and an error code is returned.  */
403 static gpg_error_t
404 string_to_long (long *r_value, const char *string, long fallback, int line)
405 {
406   gpg_error_t err;
407   char *tail = NULL;
408
409   gpg_err_set_errno (0);
410   *r_value = strtol (string, &tail, 0);
411   if (errno || !(!strcmp (tail, ".0") || !*tail))
412     {
413       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
414       log_debug ("%s:%d: "
415                  "strtol failed for DB returned string (tail=%.10s): %s\n",
416                  __FILE__, line, tail, gpg_strerror (err));
417       *r_value = fallback;
418     }
419   else
420     err = 0;
421
422   return err;
423 }
424
425
426 /* Wrapper around strtoul which prints a warning in case of a
427  * conversion error.  On success the converted value is stored at
428  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
429  * and an error code is returned.  */
430 static gpg_error_t
431 string_to_ulong (unsigned long *r_value, const char *string,
432                  unsigned long fallback, int line)
433 {
434   gpg_error_t err;
435   char *tail = NULL;
436
437   gpg_err_set_errno (0);
438   *r_value = strtoul (string, &tail, 0);
439   if (errno || !(!strcmp (tail, ".0") || !*tail))
440     {
441       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
442       log_debug ("%s:%d: "
443                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
444                  __FILE__, line, tail, gpg_strerror (err));
445       *r_value = fallback;
446     }
447   else
448     err = 0;
449
450   return err;
451 }
452
453
454
455 /* Collect results of a select count (*) ...; style query.  Aborts if
456    the argument is not a valid integer (or real of the form X.0).  */
457 static int
458 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
459                              char **azColName)
460 {
461   unsigned long int *count = cookie;
462
463   (void) azColName;
464
465   log_assert (argc == 1);
466
467   if (string_to_ulong (count, argv[0], 0, __LINE__))
468     return 1; /* Abort.  */
469   return 0;
470 }
471
472 static int
473 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
474                              char **azColName, sqlite3_stmt *stmt)
475 {
476   (void) stmt;
477   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
478 }
479
480 /* We expect a single integer column whose name is "version".  COOKIE
481    must point to an int.  This function always aborts.  On error or a
482    if the version is bad, sets *VERSION to -1.  */
483 static int
484 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
485 {
486   int *version = cookie;
487
488   if (argc != 1 || strcmp (azColName[0], "version") != 0)
489     {
490       *version = -1;
491       return 1;
492     }
493
494   if (strcmp (argv[0], "1") == 0)
495     *version = 1;
496   else
497     {
498       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
499       *version = -1;
500     }
501
502   /* Don't run again.  */
503   return 1;
504 }
505
506 static int
507 check_utks (sqlite3 *db)
508 {
509   int rc;
510   char *err = NULL;
511   struct key_item *utks;
512   struct key_item *ki;
513   int utk_count;
514   char *utks_string = NULL;
515   char keyid_str[16+1];
516   long utks_unchanged = 0;
517
518   /* An early version of the v1 format did not include the list of
519    * known ultimately trusted keys.
520    *
521    * This list is used to detect when the set of ultimately trusted
522    * keys changes.  We need to detect this to invalidate the effective
523    * policy, which can change if an ultimately trusted key is added or
524    * removed.  */
525   rc = sqlite3_exec (db,
526                      "create table if not exists ultimately_trusted_keys"
527                      " (keyid);\n",
528                      NULL, NULL, &err);
529   if (rc)
530     {
531       log_error (_("error creating 'ultimately_trusted_keys' TOFU table: %s\n"),
532                  err);
533       sqlite3_free (err);
534       goto out;
535     }
536
537
538   utks = tdb_utks ();
539   for (ki = utks, utk_count = 0; ki; ki = ki->next, utk_count ++)
540     ;
541
542   if (utk_count)
543     {
544       /* Build a list of keyids of the form "XXX","YYY","ZZZ".  */
545       int len = (1 + 16 + 1 + 1) * utk_count;
546       int o = 0;
547
548       utks_string = xmalloc (len);
549       *utks_string = 0;
550       for (ki = utks, utk_count = 0; ki; ki = ki->next, utk_count ++)
551         {
552           utks_string[o ++] = '\'';
553           format_keyid (ki->kid, KF_LONG,
554                         keyid_str, sizeof (keyid_str));
555           memcpy (&utks_string[o], keyid_str, 16);
556           o += 16;
557           utks_string[o ++] = '\'';
558           utks_string[o ++] = ',';
559         }
560       utks_string[o - 1] = 0;
561       log_assert (o == len);
562     }
563
564   rc = gpgsql_exec_printf
565     (db, get_single_unsigned_long_cb, &utks_unchanged, &err,
566      "select"
567      /* Removed UTKs?  (Known UTKs in current UTKs.)  */
568      "  ((select count(*) from ultimately_trusted_keys"
569      "     where (keyid in (%s))) == %d)"
570      " and"
571      /* New UTKs?  */
572      "  ((select count(*) from ultimately_trusted_keys"
573      "     where keyid not in (%s)) == 0);",
574      utks_string ? utks_string : "",
575      utk_count,
576      utks_string ? utks_string : "");
577   xfree (utks_string);
578   if (rc)
579     {
580       log_error (_("TOFU DB error"));
581       print_further_info ("checking if ultimately trusted keys changed: %s",
582                          err);
583       sqlite3_free (err);
584       goto out;
585     }
586
587   if (utks_unchanged)
588     goto out;
589
590   if (DBG_TRUST)
591     log_debug ("TOFU: ultimately trusted keys changed.\n");
592
593   /* Given that the set of ultimately trusted keys
594    * changed, clear any cached policies.  */
595   rc = gpgsql_exec_printf
596     (db, NULL, NULL, &err,
597      "update bindings set effective_policy = %d;",
598      TOFU_POLICY_NONE);
599   if (rc)
600     {
601       log_error (_("TOFU DB error"));
602       print_further_info ("clearing cached policies: %s", err);
603       sqlite3_free (err);
604       goto out;
605     }
606
607   /* Now, update the UTK table.  */
608   rc = sqlite3_exec (db,
609                      "drop table ultimately_trusted_keys;",
610                      NULL, NULL, &err);
611   if (rc)
612     {
613       log_error (_("TOFU DB error"));
614       print_further_info ("dropping ultimately_trusted_keys: %s", err);
615       sqlite3_free (err);
616       goto out;
617     }
618
619   rc = sqlite3_exec (db,
620                      "create table if not exists"
621                      " ultimately_trusted_keys (keyid);\n",
622                      NULL, NULL, &err);
623   if (rc)
624     {
625       log_error (_("TOFU DB error"));
626       print_further_info ("creating ultimately_trusted_keys: %s", err);
627       sqlite3_free (err);
628       goto out;
629     }
630
631   for (ki = utks; ki; ki = ki->next)
632     {
633       format_keyid (ki->kid, KF_LONG,
634                     keyid_str, sizeof (keyid_str));
635       rc = gpgsql_exec_printf
636         (db, NULL, NULL, &err,
637          "insert into ultimately_trusted_keys values ('%s');",
638          keyid_str);
639       if (rc)
640         {
641           log_error (_("TOFU DB error"));
642           print_further_info ("updating ultimately_trusted_keys: %s",
643                               err);
644           sqlite3_free (err);
645           goto out;
646         }
647     }
648
649  out:
650   return rc;
651 }
652
653 /* If the DB is new, initialize it.  Otherwise, check the DB's
654    version.
655
656    Return 0 if the database is okay and 1 otherwise.  */
657 static int
658 initdb (sqlite3 *db)
659 {
660   char *err = NULL;
661   int rc;
662   unsigned long int count;
663   int version = -1;
664
665   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
666   if (rc)
667     {
668       log_error (_("error beginning transaction on TOFU database: %s\n"),
669                  err);
670       sqlite3_free (err);
671       return 1;
672     }
673
674   /* If the DB has no tables, then assume this is a new DB that needs
675      to be initialized.  */
676   rc = sqlite3_exec (db,
677                      "select count(*) from sqlite_master where type='table';",
678                      get_single_unsigned_long_cb, &count, &err);
679   if (rc)
680     {
681       log_error (_("error reading TOFU database: %s\n"), err);
682       print_further_info ("query available tables");
683       sqlite3_free (err);
684       goto out;
685     }
686   else if (count != 0)
687     /* Assume that the DB is already initialized.  Make sure the
688        version is okay.  */
689     {
690       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
691                          &version, &err);
692       if (rc == SQLITE_ABORT && version == 1)
693         /* Happy, happy, joy, joy.  */
694         {
695           sqlite3_free (err);
696           rc = 0;
697           goto out;
698         }
699       else if (rc == SQLITE_ABORT && version == -1)
700         /* Unsupported version.  */
701         {
702           /* An error message was already displayed.  */
703           sqlite3_free (err);
704           goto out;
705         }
706       else if (rc)
707         /* Some error.  */
708         {
709           log_error (_("error determining TOFU database's version: %s\n"), err);
710           sqlite3_free (err);
711           goto out;
712         }
713       else
714         {
715           /* Unexpected success.  This can only happen if there are no
716              rows.  (select returned 0, but expected ABORT.)  */
717           log_error (_("error determining TOFU database's version: %s\n"),
718                      gpg_strerror (GPG_ERR_NO_DATA));
719           rc = 1;
720           goto out;
721         }
722     }
723
724   /* Create the version table.  */
725   rc = sqlite3_exec (db,
726                      "create table version (version INTEGER);",
727                      NULL, NULL, &err);
728   if (rc)
729     {
730       log_error (_("error initializing TOFU database: %s\n"), err);
731       print_further_info ("create version");
732       sqlite3_free (err);
733       goto out;
734     }
735
736   /* Initialize the version table, which contains a single integer
737      value.  */
738   rc = sqlite3_exec (db,
739                      "insert into version values (1);",
740                      NULL, NULL, &err);
741   if (rc)
742     {
743       log_error (_("error initializing TOFU database: %s\n"), err);
744       print_further_info ("insert version");
745       sqlite3_free (err);
746       goto out;
747     }
748
749   /* The list of <fingerprint, email> bindings and auxiliary data.
750    *
751    *  OID is a unique ID identifying this binding (and used by the
752    *    signatures table, see below).  Note: OIDs will never be
753    *    reused.
754    *
755    *  FINGERPRINT: The key's fingerprint.
756    *
757    *  EMAIL: The normalized email address.
758    *
759    *  USER_ID: The unmodified user id from which EMAIL was extracted.
760    *
761    *  TIME: The time this binding was first observed.
762    *
763    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
764    *
765    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
766    *    a binding <0xdeadbeef, foo@example.com> and then we observe
767    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
768    *    (they have the same email address).  When we observe the
769    *    latter binding, we warn the user about the conflict and ask
770    *    for a policy decision about the new binding.  We also change
771    *    the old binding's policy to ask if it was auto.  So that we
772    *     know why this occurred, we also set conflict to 0xbaddecaf.
773    */
774   rc = gpgsql_exec_printf
775       (db, NULL, NULL, &err,
776        "create table bindings\n"
777        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
778        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
779        "  policy INTEGER CHECK (policy in (%d, %d, %d, %d, %d)),\n"
780        "  conflict STRING,\n"
781        "  unique (fingerprint, email));\n"
782        "create index bindings_fingerprint_email\n"
783        " on bindings (fingerprint, email);\n"
784        "create index bindings_email on bindings (email);\n",
785        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
786        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
787   if (rc)
788     {
789       log_error (_("error initializing TOFU database: %s\n"), err);
790       print_further_info ("create bindings");
791       sqlite3_free (err);
792       goto out;
793     }
794
795   /* The signatures that we have observed.
796    *
797    * BINDING refers to a record in the bindings table, which
798    * describes the binding (i.e., this is a foreign key that
799    * references bindings.oid).
800    *
801    * SIG_DIGEST is the digest stored in the signature.
802    *
803    * SIG_TIME is the timestamp stored in the signature.
804    *
805    * ORIGIN is a free-form string that describes who fed this
806    * signature to GnuPG (e.g., email:claws).
807    *
808    * TIME is the time this signature was registered.  */
809   rc = sqlite3_exec (db,
810                          "create table signatures "
811                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
812                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
813                          "  primary key (binding, sig_digest, origin));",
814                          NULL, NULL, &err);
815   if (rc)
816     {
817       log_error (_("error initializing TOFU database: %s\n"), err);
818       print_further_info ("create signatures");
819       sqlite3_free (err);
820       goto out;
821     }
822
823  out:
824   if (! rc)
825     {
826       /* Early version of the v1 format did not include the encryption
827          table.  Add it.  */
828       rc = sqlite3_exec (db,
829                          "create table if not exists encryptions"
830                          " (binding INTEGER NOT NULL,"
831                          "  time INTEGER);"
832                          "create index if not exists encryptions_binding"
833                          " on encryptions (binding);\n",
834                          NULL, NULL, &err);
835       if (rc)
836         {
837           log_error (_("error creating 'encryptions' TOFU table: %s\n"),
838                      err);
839           sqlite3_free (err);
840         }
841     }
842   if (! rc)
843     {
844       /* The effective policy for a binding.  If a key is ultimately
845        * trusted, then the effective policy of all of its bindings is
846        * good.  Likewise if a key is signed by an ultimately trusted
847        * key, etc.  If the effective policy is NONE, then we need to
848        * recompute the effective policy.  Otherwise, the effective
849        * policy is considered to be up to date, i.e., effective_policy
850        * is a cache of the computed policy.  */
851       rc = gpgsql_exec_printf
852         (db, NULL, NULL, &err,
853          "alter table bindings"
854          " add column effective_policy INTEGER"
855          " DEFAULT %d"
856          " CHECK (effective_policy in (%d, %d, %d, %d, %d, %d));",
857          TOFU_POLICY_NONE,
858          TOFU_POLICY_NONE, TOFU_POLICY_AUTO, TOFU_POLICY_GOOD,
859          TOFU_POLICY_UNKNOWN, TOFU_POLICY_BAD, TOFU_POLICY_ASK);
860       if (rc)
861         {
862           if (rc == SQLITE_ERROR)
863             /* Almost certainly "duplicate column name", which we can
864              * safely ignore.  */
865             rc = 0;
866           else
867             log_error (_("adding column effective_policy to bindings DB: %s\n"),
868                        err);
869           sqlite3_free (err);
870         }
871     }
872
873   if (! rc)
874     rc = check_utks (db);
875
876   if (rc)
877     {
878       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
879       if (rc)
880         {
881           log_error (_("error rolling back transaction on TOFU database: %s\n"),
882                      err);
883           sqlite3_free (err);
884         }
885       return 1;
886     }
887   else
888     {
889       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
890       if (rc)
891         {
892           log_error (_("error committing transaction on TOFU database: %s\n"),
893                      err);
894           sqlite3_free (err);
895           return 1;
896         }
897       return 0;
898     }
899 }
900
901 static int
902 busy_handler (void *cookie, int call_count)
903 {
904   ctrl_t ctrl = cookie;
905   tofu_dbs_t dbs = ctrl->tofu.dbs;
906
907   (void) call_count;
908
909   /* Update the want-lock-file time stamp (specifically, the ctime) so
910    * that the current owner knows that we (well, someone) want the
911    * lock.  */
912   if (dbs)
913     {
914       /* Note: we don't fail if we can't create the lock file: this
915        * process will have to wait a bit longer, but otherwise nothing
916        * horrible should happen.  */
917
918       estream_t fp;
919
920       fp = es_fopen (dbs->want_lock_file, "w");
921       if (! fp)
922         log_debug ("TOFU: Error opening '%s': %s\n",
923                    dbs->want_lock_file, strerror (errno));
924       else
925         es_fclose (fp);
926     }
927
928   /* Call again.  */
929   return 1;
930 }
931
932 /* Create a new DB handle.  Returns NULL on error.  */
933 /* FIXME: Change to return an error code for better reporting by the
934    caller.  */
935 static tofu_dbs_t
936 opendbs (ctrl_t ctrl)
937 {
938   char *filename;
939   sqlite3 *db;
940   int rc;
941
942   if (!ctrl->tofu.dbs)
943     {
944       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
945
946       rc = sqlite3_open (filename, &db);
947       if (rc)
948         {
949           log_error (_("error opening TOFU database '%s': %s\n"),
950                      filename, sqlite3_errmsg (db));
951           /* Even if an error occurs, DB is guaranteed to be valid.  */
952           sqlite3_close (db);
953           db = NULL;
954         }
955
956       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
957          before failing.  */
958       if (db)
959         {
960           sqlite3_busy_timeout (db, 5 * 1000);
961           sqlite3_busy_handler (db, busy_handler, ctrl);
962         }
963
964       if (db && initdb (db))
965         {
966           sqlite3_close (db);
967           db = NULL;
968         }
969
970       if (db)
971         {
972           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
973           ctrl->tofu.dbs->db = db;
974           ctrl->tofu.dbs->want_lock_file = xasprintf ("%s-want-lock", filename);
975         }
976
977       xfree (filename);
978     }
979   else
980     log_assert (ctrl->tofu.dbs->db);
981
982   return ctrl->tofu.dbs;
983 }
984
985
986 /* Release all of the resources associated with the DB handle.  */
987 void
988 tofu_closedbs (ctrl_t ctrl)
989 {
990   tofu_dbs_t dbs;
991   sqlite3_stmt **statements;
992
993   dbs = ctrl->tofu.dbs;
994   if (!dbs)
995     return;  /* Not initialized.  */
996
997   log_assert (dbs->in_transaction == 0);
998
999   end_transaction (ctrl, 2);
1000
1001   /* Arghh, that is a surprising use of the struct.  */
1002   for (statements = (void *) &dbs->s;
1003        (void *) statements < (void *) &(&dbs->s)[1];
1004        statements ++)
1005     sqlite3_finalize (*statements);
1006
1007   sqlite3_close (dbs->db);
1008   xfree (dbs->want_lock_file);
1009   xfree (dbs);
1010   ctrl->tofu.dbs = NULL;
1011 }
1012
1013
1014 /* Collect results of a select min (foo) ...; style query.  Aborts if
1015    the argument is not a valid integer (or real of the form X.0).  */
1016 static int
1017 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
1018 {
1019   long *count = cookie;
1020
1021   (void) azColName;
1022
1023   log_assert (argc == 1);
1024
1025   if (string_to_long (count, argv[0], 0, __LINE__))
1026     return 1; /* Abort.  */
1027
1028   return 0;
1029 }
1030
1031 static int
1032 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
1033                      sqlite3_stmt *stmt)
1034 {
1035   (void) stmt;
1036   return get_single_long_cb (cookie, argc, argv, azColName);
1037 }
1038
1039 /* Record (or update) a trust policy about a (possibly new)
1040    binding.
1041
1042    If SHOW_OLD is set, the binding's old policy is displayed.  */
1043 static gpg_error_t
1044 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1045                 const char *user_id,
1046                 enum tofu_policy policy, enum tofu_policy effective_policy,
1047                 const char *conflict, int set_conflict,
1048                 int show_old, time_t now)
1049 {
1050   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1051   gpg_error_t rc;
1052   char *err = NULL;
1053
1054   if (! (policy == TOFU_POLICY_AUTO
1055          || policy == TOFU_POLICY_GOOD
1056          || policy == TOFU_POLICY_UNKNOWN
1057          || policy == TOFU_POLICY_BAD
1058          || policy == TOFU_POLICY_ASK))
1059     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
1060
1061
1062   if (DBG_TRUST || show_old)
1063     {
1064       /* Get the old policy.  Since this is just for informational
1065        * purposes, there is no need to start a transaction or to die
1066        * if there is a failure.  */
1067
1068       /* policy_old needs to be a long and not an enum tofu_policy,
1069          because we pass it by reference to get_single_long_cb2, which
1070          expects a long.  */
1071       long policy_old = TOFU_POLICY_NONE;
1072
1073       rc = gpgsql_stepx
1074         (dbs->db, &dbs->s.record_binding_get_old_policy,
1075          get_single_long_cb2, &policy_old, &err,
1076          "select policy from bindings where fingerprint = ? and email = ?",
1077          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1078          GPGSQL_ARG_END);
1079       if (rc)
1080         {
1081           log_debug ("TOFU: Error reading from binding database"
1082                      " (reading policy for <key: %s, user id: %s>): %s\n",
1083                      fingerprint, email, err);
1084           sqlite3_free (err);
1085         }
1086
1087       if (policy_old != TOFU_POLICY_NONE)
1088         (show_old ? log_info : log_debug)
1089           ("Changing TOFU trust policy for binding"
1090            " <key: %s, user id: %s> from %s to %s.\n",
1091            fingerprint, show_old ? user_id : email,
1092            tofu_policy_str (policy_old),
1093            tofu_policy_str (policy));
1094       else
1095         (show_old ? log_info : log_debug)
1096           ("Setting TOFU trust policy for new binding"
1097            " <key: %s, user id: %s> to %s.\n",
1098            fingerprint, show_old ? user_id : email,
1099            tofu_policy_str (policy));
1100     }
1101
1102   if (opt.dry_run)
1103     {
1104       log_info ("TOFU database update skipped due to --dry-run\n");
1105       rc = 0;
1106       goto leave;
1107     }
1108
1109   rc = gpgsql_stepx
1110     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
1111      "insert or replace into bindings\n"
1112      " (oid, fingerprint, email, user_id, time,"
1113      "  policy, conflict, effective_policy)\n"
1114      " values (\n"
1115      /* If we don't explicitly reuse the OID, then SQLite will
1116       * reallocate a new one.  We just need to search for the OID
1117       * based on the fingerprint and email since they are unique.  */
1118      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1119      "  ?, ?, ?, ?, ?,"
1120      /* If SET_CONFLICT is 0, then preserve conflict's current value.  */
1121      "  case ?"
1122      "    when 0 then"
1123      "      (select conflict from bindings where fingerprint = ? and email = ?)"
1124      "    else ?"
1125      "  end,"
1126      "  ?);",
1127      /* oid subquery.  */
1128      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1129      /* values 2 through 6.  */
1130      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1131      GPGSQL_ARG_STRING, user_id,
1132      GPGSQL_ARG_LONG_LONG, (long long) now,
1133      GPGSQL_ARG_INT, (int) policy,
1134      /* conflict subquery.  */
1135      GPGSQL_ARG_INT, set_conflict ? 1 : 0,
1136      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1137      GPGSQL_ARG_STRING, conflict ? conflict : "",
1138      GPGSQL_ARG_INT, (int) effective_policy,
1139      GPGSQL_ARG_END);
1140   if (rc)
1141     {
1142       log_error (_("error updating TOFU database: %s\n"), err);
1143       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
1144                           fingerprint, email, tofu_policy_str (policy));
1145       sqlite3_free (err);
1146       goto leave;
1147     }
1148
1149  leave:
1150   xfree (fingerprint_pp);
1151   return rc;
1152 }
1153
1154
1155 /* Collect the strings returned by a query in a simply string list.
1156    Any NULL values are converted to the empty string.
1157
1158    If a result has 3 rows and each row contains two columns, then the
1159    results are added to the list as follows (the value is parentheses
1160    is the 1-based index in the final list):
1161
1162      row 1, col 2 (6)
1163      row 1, col 1 (5)
1164      row 2, col 2 (4)
1165      row 2, col 1 (3)
1166      row 3, col 2 (2)
1167      row 3, col 1 (1)
1168
1169    This is because add_to_strlist pushes the results onto the front of
1170    the list.  The end result is that the rows are backwards, but the
1171    columns are in the expected order.  */
1172 static int
1173 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
1174 {
1175   int i;
1176   strlist_t *strlist = cookie;
1177
1178   (void) azColName;
1179
1180   for (i = argc - 1; i >= 0; i --)
1181     add_to_strlist (strlist, argv[i] ? argv[i] : "");
1182
1183   return 0;
1184 }
1185
1186 static int
1187 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
1188                      sqlite3_stmt *stmt)
1189 {
1190   (void) stmt;
1191   return strings_collect_cb (cookie, argc, argv, azColName);
1192
1193 }
1194
1195 /* Auxiliary data structure to collect statistics about
1196    signatures.  */
1197 struct signature_stats
1198 {
1199   struct signature_stats *next;
1200
1201   /* The user-assigned policy for this binding.  */
1202   enum tofu_policy policy;
1203
1204   /* How long ago the signature was created (rounded to a multiple of
1205      TIME_AGO_UNIT_SMALL, etc.).  */
1206   long time_ago;
1207   /* Number of signatures during this time.  */
1208   unsigned long count;
1209
1210   /* If the corresponding key/user id has been expired / revoked.  */
1211   int is_expired;
1212   int is_revoked;
1213
1214   /* The key that generated this signature.  */
1215   char fingerprint[1];
1216 };
1217
1218 static void
1219 signature_stats_free (struct signature_stats *stats)
1220 {
1221   while (stats)
1222     {
1223       struct signature_stats *next = stats->next;
1224       xfree (stats);
1225       stats = next;
1226     }
1227 }
1228
1229 static void
1230 signature_stats_prepend (struct signature_stats **statsp,
1231                          const char *fingerprint,
1232                          enum tofu_policy policy,
1233                          long time_ago,
1234                          unsigned long count)
1235 {
1236   struct signature_stats *stats =
1237     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
1238
1239   stats->next = *statsp;
1240   *statsp = stats;
1241
1242   strcpy (stats->fingerprint, fingerprint);
1243   stats->policy = policy;
1244   stats->time_ago = time_ago;
1245   stats->count = count;
1246 }
1247
1248
1249 /* Process rows that contain the four columns:
1250
1251      <fingerprint, policy, time ago, count>.  */
1252 static int
1253 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1254                             char **azColName, sqlite3_stmt *stmt)
1255 {
1256   struct signature_stats **statsp = cookie;
1257   int i = 0;
1258   enum tofu_policy policy;
1259   long time_ago;
1260   unsigned long count;
1261   long along;
1262
1263   (void) azColName;
1264   (void) stmt;
1265
1266   i ++;
1267
1268   if (string_to_long (&along, argv[i], 0, __LINE__))
1269     return 1;  /* Abort */
1270   policy = along;
1271   i ++;
1272
1273   if (! argv[i])
1274     time_ago = 0;
1275   else
1276     {
1277       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
1278         return 1; /* Abort.  */
1279     }
1280   i ++;
1281
1282   /* If time_ago is NULL, then we had no messages, but we still have a
1283      single row, which count(*) turns into 1.  */
1284   if (! argv[i - 1])
1285     count = 0;
1286   else
1287     {
1288       if (string_to_ulong (&count, argv[i], 0, __LINE__))
1289         return 1; /* Abort */
1290     }
1291   i ++;
1292
1293   log_assert (argc == i);
1294
1295   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1296
1297   return 0;
1298 }
1299
1300 /* Convert from seconds to time units.
1301
1302    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1303    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1304 signed long
1305 time_ago_scale (signed long t)
1306 {
1307   if (t < TIME_AGO_UNIT_MEDIUM)
1308     return t / TIME_AGO_UNIT_SMALL;
1309   if (t < TIME_AGO_UNIT_LARGE)
1310     return t / TIME_AGO_UNIT_MEDIUM;
1311   return t / TIME_AGO_UNIT_LARGE;
1312 }
1313
1314
1315 /* Format the first part of a conflict message and return that as a
1316  * malloced string.  */
1317 static char *
1318 format_conflict_msg_part1 (int policy, strlist_t conflict_set,
1319                            const char *email)
1320 {
1321   estream_t fp;
1322   char *fingerprint;
1323   char *tmpstr, *text;
1324
1325   log_assert (conflict_set);
1326   fingerprint = conflict_set->d;
1327
1328   fp = es_fopenmem (0, "rw,samethread");
1329   if (!fp)
1330     log_fatal ("error creating memory stream: %s\n",
1331                gpg_strerror (gpg_error_from_syserror()));
1332
1333   if (policy == TOFU_POLICY_NONE)
1334     {
1335       es_fprintf (fp,
1336                   _("This is the first time the email address \"%s\" is "
1337                     "being used with key %s."),
1338                   email, fingerprint);
1339       es_fputs ("  ", fp);
1340     }
1341   else if (policy == TOFU_POLICY_ASK && conflict_set->next)
1342     {
1343       int conflicts = strlist_length (conflict_set);
1344       es_fprintf (fp, _("The email address \"%s\" is associated with %d keys!"),
1345                   email, conflicts);
1346       if (opt.verbose)
1347         es_fprintf (fp,
1348                     _("  Since this binding's policy was 'auto', it has been "
1349                       "changed to 'ask'."));
1350       es_fputs ("  ", fp);
1351     }
1352
1353   es_fprintf (fp,
1354               _("Please indicate whether this email address should"
1355                 " be associated with key %s or whether you think someone"
1356                 " is impersonating \"%s\"."),
1357               fingerprint, email);
1358   es_fputc ('\n', fp);
1359
1360   es_fputc (0, fp);
1361   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1362     log_fatal ("error snatching memory stream\n");
1363   text = format_text (tmpstr, 0, 72, 80);
1364   es_free (tmpstr);
1365
1366   return text;
1367 }
1368
1369
1370 /* Return 1 if A signed B and B signed A.  */
1371 static int
1372 cross_sigs (const char *email, kbnode_t a, kbnode_t b)
1373 {
1374   int i;
1375
1376   PKT_public_key *a_pk = a->pkt->pkt.public_key;
1377   PKT_public_key *b_pk = b->pkt->pkt.public_key;
1378
1379   char a_keyid[33];
1380   char b_keyid[33];
1381
1382   if (DBG_TRUST)
1383     {
1384       format_keyid (pk_main_keyid (a_pk),
1385                     KF_LONG, a_keyid, sizeof (a_keyid));
1386       format_keyid (pk_main_keyid (b_pk),
1387                     KF_LONG, b_keyid, sizeof (b_keyid));
1388     }
1389
1390   for (i = 0; i < 2; i ++)
1391     {
1392       /* See if SIGNER signed SIGNEE.  */
1393
1394       kbnode_t signer = i == 0 ? a : b;
1395       kbnode_t signee = i == 0 ? b : a;
1396
1397       PKT_public_key *signer_pk = signer->pkt->pkt.public_key;
1398       u32 *signer_kid = pk_main_keyid (signer_pk);
1399       kbnode_t n;
1400
1401       int saw_email = 0;
1402
1403       /* Iterate over SIGNEE's keyblock and see if there is a valid
1404          signature from SIGNER.  */
1405       for (n = signee; n; n = n->next)
1406         {
1407           PKT_signature *sig;
1408
1409           if (n->pkt->pkttype == PKT_USER_ID)
1410             {
1411               if (saw_email)
1412                 /* We're done: we've processed all signatures on the
1413                    user id.  */
1414                 break;
1415               else
1416                 {
1417                   /* See if this is the matching user id.  */
1418                   PKT_user_id *user_id = n->pkt->pkt.user_id;
1419                   char *email2 = email_from_user_id (user_id->name);
1420
1421                   if (strcmp (email, email2) == 0)
1422                     saw_email = 1;
1423
1424                   xfree (email2);
1425                 }
1426             }
1427
1428           if (! saw_email)
1429             continue;
1430
1431           if (n->pkt->pkttype != PKT_SIGNATURE)
1432             continue;
1433
1434           sig = n->pkt->pkt.signature;
1435
1436           if (! (sig->sig_class == 0x10
1437                  || sig->sig_class == 0x11
1438                  || sig->sig_class == 0x12
1439                  || sig->sig_class == 0x13))
1440             /* Not a signature over a user id.  */
1441             continue;
1442
1443           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1444              signer, then it's a match.  */
1445           if (keyid_cmp (sig->keyid, signer_kid) == 0)
1446             /* Match!  */
1447             break;
1448         }
1449       if (! n)
1450         /* We didn't find a signature from signer over signee.  */
1451         {
1452           if (DBG_TRUST)
1453             log_debug ("No cross sig between %s and %s\n",
1454                        a_keyid, b_keyid);
1455           return 0;
1456         }
1457     }
1458
1459   /* A signed B and B signed A.  */
1460   if (DBG_TRUST)
1461     log_debug ("Cross sig between %s and %s\n",
1462                a_keyid, b_keyid);
1463
1464   return 1;
1465 }
1466
1467 /* Return whether the key was signed by an ultimately trusted key.  */
1468 static int
1469 signed_by_utk (const char *email, kbnode_t a)
1470 {
1471   kbnode_t n;
1472   int saw_email = 0;
1473
1474   for (n = a; n; n = n->next)
1475     {
1476       PKT_signature *sig;
1477
1478       if (n->pkt->pkttype == PKT_USER_ID)
1479         {
1480           if (saw_email)
1481             /* We're done: we've processed all signatures on the
1482                user id.  */
1483             break;
1484           else
1485             {
1486               /* See if this is the matching user id.  */
1487               PKT_user_id *user_id = n->pkt->pkt.user_id;
1488               char *email2 = email_from_user_id (user_id->name);
1489
1490               if (strcmp (email, email2) == 0)
1491                 saw_email = 1;
1492
1493               xfree (email2);
1494             }
1495         }
1496
1497       if (! saw_email)
1498         continue;
1499
1500       if (n->pkt->pkttype != PKT_SIGNATURE)
1501         continue;
1502
1503       sig = n->pkt->pkt.signature;
1504
1505       if (! (sig->sig_class == 0x10
1506              || sig->sig_class == 0x11
1507              || sig->sig_class == 0x12
1508              || sig->sig_class == 0x13))
1509         /* Not a signature over a user id.  */
1510         continue;
1511
1512       /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1513          signer, then it's a match.  */
1514       if (tdb_keyid_is_utk (sig->keyid))
1515         {
1516           /* Match!  */
1517           if (DBG_TRUST)
1518             log_debug ("TOFU: %s is signed by an ultimately trusted key.\n",
1519                        pk_keyid_str (a->pkt->pkt.public_key));
1520
1521           return 1;
1522         }
1523     }
1524
1525   if (DBG_TRUST)
1526     log_debug ("TOFU: %s is NOT signed by an ultimately trusted key.\n",
1527                pk_keyid_str (a->pkt->pkt.public_key));
1528
1529   return 0;
1530 }
1531
1532
1533 enum
1534   {
1535     BINDING_NEW = 1 << 0,
1536     BINDING_CONFLICT = 1 << 1,
1537     BINDING_EXPIRED = 1 << 2,
1538     BINDING_REVOKED = 1 << 3
1539   };
1540
1541
1542 /* Ask the user about the binding.  There are three ways we could end
1543  * up here:
1544  *
1545  *   - This is a new binding and there is a conflict
1546  *     (policy == TOFU_POLICY_NONE && conflict_set_count > 1),
1547  *
1548  *   - This is a new binding and opt.tofu_default_policy is set to
1549  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1550  *     TOFU_POLICY_ASK), or,
1551  *
1552  *   - The policy is ask (the user deferred last time) (policy ==
1553  *     TOFU_POLICY_ASK).
1554  *
1555  * Note: this function must not be called while in a transaction!
1556  *
1557  * CONFLICT_SET includes all of the conflicting bindings
1558  * with FINGERPRINT first.  FLAGS is a bit-wise or of
1559  * BINDING_NEW, etc.
1560  */
1561 static void
1562 ask_about_binding (ctrl_t ctrl,
1563                    enum tofu_policy *policy,
1564                    int *trust_level,
1565                    strlist_t conflict_set,
1566                    const char *fingerprint,
1567                    const char *email,
1568                    const char *user_id,
1569                    time_t now)
1570 {
1571   tofu_dbs_t dbs;
1572   strlist_t iter;
1573   int conflict_set_count = strlist_length (conflict_set);
1574   char *sqerr = NULL;
1575   int rc;
1576   estream_t fp;
1577   strlist_t other_user_ids = NULL;
1578   struct signature_stats *stats = NULL;
1579   struct signature_stats *stats_iter = NULL;
1580   char *prompt = NULL;
1581   char *choices;
1582
1583   dbs = ctrl->tofu.dbs;
1584   log_assert (dbs);
1585   log_assert (dbs->in_transaction == 0);
1586
1587   fp = es_fopenmem (0, "rw,samethread");
1588   if (!fp)
1589     log_fatal ("error creating memory stream: %s\n",
1590                gpg_strerror (gpg_error_from_syserror()));
1591
1592   {
1593     char *text = format_conflict_msg_part1 (*policy, conflict_set, email);
1594     es_fputs (text, fp);
1595     es_fputc ('\n', fp);
1596     xfree (text);
1597   }
1598
1599   begin_transaction (ctrl, 0);
1600
1601   /* Find other user ids associated with this key and whether the
1602    * bindings are marked as good or bad.  */
1603   rc = gpgsql_stepx
1604     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1605      strings_collect_cb2, &other_user_ids, &sqerr,
1606      "select user_id, policy from bindings where fingerprint = ?;",
1607      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1608   if (rc)
1609     {
1610       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1611       sqlite3_free (sqerr);
1612       sqerr = NULL;
1613       rc = gpg_error (GPG_ERR_GENERAL);
1614     }
1615
1616   if (other_user_ids)
1617     {
1618       strlist_t strlist_iter;
1619
1620       es_fprintf (fp, _("This key's user IDs:\n"));
1621       for (strlist_iter = other_user_ids;
1622            strlist_iter;
1623            strlist_iter = strlist_iter->next)
1624         {
1625           char *other_user_id = strlist_iter->d;
1626           char *other_thing;
1627           enum tofu_policy other_policy;
1628
1629           log_assert (strlist_iter->next);
1630           strlist_iter = strlist_iter->next;
1631           other_thing = strlist_iter->d;
1632
1633           other_policy = atoi (other_thing);
1634
1635           es_fprintf (fp, "  %s (", other_user_id);
1636           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1637           es_fprintf (fp, ")\n");
1638         }
1639       es_fprintf (fp, "\n");
1640
1641       free_strlist (other_user_ids);
1642     }
1643
1644   /* Get the stats for all the keys in CONFLICT_SET.  */
1645   strlist_rev (&conflict_set);
1646   for (iter = conflict_set; iter && ! rc; iter = iter->next)
1647     {
1648 #define STATS_SQL(table, time, sign)                         \
1649          "select fingerprint, policy, time_ago, count(*)\n" \
1650          " from\n" \
1651          "  (select bindings.*,\n" \
1652          "     "sign" case\n" \
1653          "       when delta ISNULL then 1\n" \
1654          /* From the future (but if its just a couple of hours in the \
1655           * future don't turn it into a warning)?  Or should we use \
1656           * small, medium or large units?  (Note: whatever we do, we \
1657           * keep the value in seconds.  Then when we group, everything \
1658           * that rounds to the same number of seconds is grouped.)  */ \
1659          "      when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then 2\n" \
1660          "      when delta < ("STRINGIFY (TIME_AGO_SMALL_THRESHOLD)")\n" \
1661          "       then 3\n" \
1662          "      when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n" \
1663          "       then 4\n" \
1664          "      when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n" \
1665          "       then 5\n" \
1666          "      else 6\n" \
1667          "     end time_ago,\n" \
1668          "    delta time_ago_raw\n" \
1669          "   from bindings\n" \
1670          "   left join\n" \
1671          "     (select *,\n" \
1672          "        cast(? - " time " as real) delta\n" \
1673          "       from " table ") ss\n" \
1674          "    on ss.binding = bindings.oid)\n" \
1675          " where email = ? and fingerprint = ?\n" \
1676          " group by time_ago\n" \
1677          /* Make sure the current key is first.  */ \
1678          " order by time_ago desc;\n"
1679
1680       /* Use the time when we saw the signature, not when the
1681          signature was created as that can be forged.  */
1682       rc = gpgsql_stepx
1683         (dbs->db, &dbs->s.get_trust_gather_signature_stats,
1684          signature_stats_collect_cb, &stats, &sqerr,
1685          STATS_SQL ("signatures", "time", ""),
1686          GPGSQL_ARG_LONG_LONG, (long long) now,
1687          GPGSQL_ARG_STRING, email,
1688          GPGSQL_ARG_STRING, iter->d,
1689          GPGSQL_ARG_END);
1690       if (rc)
1691         {
1692           rc = gpg_error (GPG_ERR_GENERAL);
1693           break;
1694         }
1695
1696       if (!stats || strcmp (iter->d, stats->fingerprint) != 0)
1697         /* No stats for this binding.  Add a dummy entry.  */
1698         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, 1, 1);
1699
1700       rc = gpgsql_stepx
1701         (dbs->db, &dbs->s.get_trust_gather_encryption_stats,
1702          signature_stats_collect_cb, &stats, &sqerr,
1703          STATS_SQL ("encryptions", "time", "-"),
1704          GPGSQL_ARG_LONG_LONG, (long long) now,
1705          GPGSQL_ARG_STRING, email,
1706          GPGSQL_ARG_STRING, iter->d,
1707          GPGSQL_ARG_END);
1708       if (rc)
1709         {
1710           rc = gpg_error (GPG_ERR_GENERAL);
1711           break;
1712         }
1713
1714 #undef STATS_SQL
1715
1716       if (!stats || strcmp (iter->d, stats->fingerprint) != 0
1717           || stats->time_ago > 0)
1718         /* No stats for this binding.  Add a dummy entry.  */
1719         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, -1, 1);
1720     }
1721   end_transaction (ctrl, 0);
1722   strlist_rev (&conflict_set);
1723   if (rc)
1724     {
1725       strlist_t strlist_iter;
1726
1727       log_error (_("error gathering signature stats: %s\n"), sqerr);
1728       sqlite3_free (sqerr);
1729       sqerr = NULL;
1730
1731       es_fprintf (fp, ngettext("The email address \"%s\" is"
1732                                " associated with %d key:\n",
1733                                "The email address \"%s\" is"
1734                                " associated with %d keys:\n",
1735                                conflict_set_count),
1736                   email, conflict_set_count);
1737       for (strlist_iter = conflict_set;
1738            strlist_iter;
1739            strlist_iter = strlist_iter->next)
1740         es_fprintf (fp, "  %s\n", strlist_iter->d);
1741     }
1742   else
1743     {
1744       char *key = NULL;
1745       strlist_t binding;
1746       int seen_in_past = 0;
1747
1748       es_fprintf (fp, _("Statistics for keys"
1749                         " with the email address \"%s\":\n"),
1750                   email);
1751       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1752         {
1753 #if 0
1754           log_debug ("%s: time_ago: %ld; count: %ld\n",
1755                      stats_iter->fingerprint,
1756                      stats_iter->time_ago,
1757                      stats_iter->count);
1758 #endif
1759
1760           if (! key || strcmp (key, stats_iter->fingerprint))
1761             {
1762               int this_key;
1763               char *key_pp;
1764
1765               key = stats_iter->fingerprint;
1766               this_key = strcmp (key, fingerprint) == 0;
1767               key_pp = format_hexfingerprint (key, NULL, 0);
1768               es_fprintf (fp, "  %s (", key_pp);
1769
1770               /* Find the associated binding.  */
1771               for (binding = conflict_set;
1772                    binding;
1773                    binding = binding->next)
1774                 if (strcmp (key, binding->d) == 0)
1775                   break;
1776               log_assert (binding);
1777
1778               if ((binding->flags & BINDING_REVOKED))
1779                 {
1780                   es_fprintf (fp, _("revoked"));
1781                   es_fprintf (fp, _(", "));
1782                 }
1783               else if ((binding->flags & BINDING_EXPIRED))
1784                 {
1785                   es_fprintf (fp, _("expired"));
1786                   es_fprintf (fp, _(", "));
1787                 }
1788
1789               if (this_key)
1790                 es_fprintf (fp, _("this key"));
1791               else
1792                 es_fprintf (fp, _("policy: %s"),
1793                             tofu_policy_str (stats_iter->policy));
1794               es_fputs ("):\n", fp);
1795               xfree (key_pp);
1796
1797               seen_in_past = 0;
1798             }
1799
1800           if (labs(stats_iter->time_ago) == 1)
1801             {
1802               /* The 1 in this case is the NULL entry.  */
1803               log_assert (stats_iter->count == 1);
1804               stats_iter->count = 0;
1805             }
1806           seen_in_past += stats_iter->count;
1807
1808           es_fputs ("    ", fp);
1809           /* TANSLATORS: This string is concatenated with one of
1810            * the day/week/month strings to form one sentence.  */
1811           if (stats_iter->time_ago > 0)
1812             es_fprintf (fp, ngettext("Verified %d message",
1813                                      "Verified %d messages",
1814                                      seen_in_past), seen_in_past);
1815           else
1816             es_fprintf (fp, ngettext("Encrypted %d message",
1817                                      "Encrypted %d messages",
1818                                      seen_in_past), seen_in_past);
1819
1820           if (!stats_iter->count)
1821             es_fputs (".", fp);
1822           else if (labs(stats_iter->time_ago) == 2)
1823             {
1824               es_fprintf (fp, "in the future.");
1825               /* Reset it.  */
1826               seen_in_past = 0;
1827             }
1828           else
1829             {
1830               if (labs(stats_iter->time_ago) == 3)
1831                 es_fprintf (fp, ngettext(" over the past day.",
1832                                          " over the past %d days.",
1833                                          TIME_AGO_SMALL_THRESHOLD
1834                                          / TIME_AGO_UNIT_SMALL),
1835                             TIME_AGO_SMALL_THRESHOLD
1836                             / TIME_AGO_UNIT_SMALL);
1837               else if (labs(stats_iter->time_ago) == 4)
1838                 es_fprintf (fp, ngettext(" over the past month.",
1839                                          " over the past %d months.",
1840                                          TIME_AGO_MEDIUM_THRESHOLD
1841                                          / TIME_AGO_UNIT_MEDIUM),
1842                             TIME_AGO_MEDIUM_THRESHOLD
1843                             / TIME_AGO_UNIT_MEDIUM);
1844               else if (labs(stats_iter->time_ago) == 5)
1845                 es_fprintf (fp, ngettext(" over the past year.",
1846                                          " over the past %d years.",
1847                                          TIME_AGO_LARGE_THRESHOLD
1848                                          / TIME_AGO_UNIT_LARGE),
1849                             TIME_AGO_LARGE_THRESHOLD
1850                             / TIME_AGO_UNIT_LARGE);
1851               else if (labs(stats_iter->time_ago) == 6)
1852                 es_fprintf (fp, _(" in the past."));
1853               else
1854                 log_assert (! "Broken SQL.\n");
1855             }
1856           es_fputs ("\n", fp);
1857         }
1858     }
1859
1860   if (conflict_set_count > 1 || (conflict_set->flags & BINDING_CONFLICT))
1861     {
1862       /* This is a conflict.  */
1863
1864       /* TRANSLATORS: Please translate the text found in the source
1865        * file below.  We don't directly internationalize that text so
1866        * that we can tweak it without breaking translations.  */
1867       char *text = _("TOFU detected a binding conflict");
1868       char *textbuf;
1869       if (!strcmp (text, "TOFU detected a binding conflict"))
1870         {
1871           /* No translation.  Use the English text.  */
1872           text =
1873             "Normally, an email address is associated with a single key.  "
1874             "However, people sometimes generate a new key if "
1875             "their key is too old or they think it might be compromised.  "
1876             "Alternatively, a new key may indicate a man-in-the-middle "
1877             "attack!  Before accepting this association, you should talk to or "
1878             "call the person to make sure this new key is legitimate.";
1879         }
1880       textbuf = format_text (text, 0, 72, 80);
1881       es_fprintf (fp, "\n%s\n", textbuf);
1882       xfree (textbuf);
1883     }
1884
1885   es_fputc ('\n', fp);
1886
1887   /* Add a NUL terminator.  */
1888   es_fputc (0, fp);
1889   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1890     log_fatal ("error snatching memory stream\n");
1891
1892   /* I think showing the large message once is sufficient.  If we
1893    * would move it right before the cpr_get many lines will scroll
1894    * away and the user might not realize that he merely entered a
1895    * wrong choise (because he does not see that either).  As a small
1896    * benefit we allow C-L to redisplay everything.  */
1897   tty_printf ("%s", prompt);
1898
1899   /* Suspend any transaction: it could take a while until the user
1900      responds.  */
1901   tofu_suspend_batch_transaction (ctrl);
1902   while (1)
1903     {
1904       char *response;
1905
1906       /* TRANSLATORS: Two letters (normally the lower and upper case
1907        * version of the hotkey) for each of the five choices.  If
1908        * there is only one choice in your language, repeat it.  */
1909       choices = _("gG" "aA" "uU" "rR" "bB");
1910       if (strlen (choices) != 10)
1911         log_bug ("Bad TOFU conflict translation!  Please report.");
1912
1913       response = cpr_get
1914         ("tofu.conflict",
1915          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1916       trim_spaces (response);
1917       cpr_kill_prompt ();
1918       if (*response == CONTROL_L)
1919         tty_printf ("%s", prompt);
1920       else if (!response[0])
1921         /* Default to unknown.  Don't save it.  */
1922         {
1923           tty_printf (_("Defaulting to unknown."));
1924           *policy = TOFU_POLICY_UNKNOWN;
1925           break;
1926         }
1927       else if (!response[1])
1928         {
1929           char *choice = strchr (choices, *response);
1930
1931           if (choice)
1932             {
1933               int c = ((size_t) choice - (size_t) choices) / 2;
1934
1935               switch (c)
1936                 {
1937                 case 0: /* Good.  */
1938                   *policy = TOFU_POLICY_GOOD;
1939                   *trust_level = tofu_policy_to_trust_level (*policy);
1940                   break;
1941                 case 1: /* Accept once.  */
1942                   *policy = TOFU_POLICY_ASK;
1943                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1944                   break;
1945                 case 2: /* Unknown.  */
1946                   *policy = TOFU_POLICY_UNKNOWN;
1947                   *trust_level = tofu_policy_to_trust_level (*policy);
1948                   break;
1949                 case 3: /* Reject once.  */
1950                   *policy = TOFU_POLICY_ASK;
1951                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1952                   break;
1953                 case 4: /* Bad.  */
1954                   *policy = TOFU_POLICY_BAD;
1955                   *trust_level = tofu_policy_to_trust_level (*policy);
1956                   break;
1957                 default:
1958                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1959                 }
1960
1961               if (record_binding (dbs, fingerprint, email, user_id,
1962                                   *policy, TOFU_POLICY_NONE, NULL, 0, 0, now))
1963                 {
1964                   /* If there's an error registering the
1965                    * binding, don't save the signature.  */
1966                   *trust_level = _tofu_GET_TRUST_ERROR;
1967                 }
1968               break;
1969             }
1970         }
1971       xfree (response);
1972     }
1973
1974   tofu_resume_batch_transaction (ctrl);
1975
1976   xfree (prompt);
1977
1978   signature_stats_free (stats);
1979 }
1980
1981 /* Return the set of keys that conflict with the binding <fingerprint,
1982    email> (including the binding itself, which will be first in the
1983    list).  For each returned key also sets BINDING_NEW, etc.  */
1984 static strlist_t
1985 build_conflict_set (tofu_dbs_t dbs,
1986                     PKT_public_key *pk, const char *fingerprint,
1987                     const char *email)
1988 {
1989   gpg_error_t rc;
1990   char *sqerr;
1991   strlist_t conflict_set = NULL;
1992   int conflict_set_count;
1993   strlist_t iter;
1994   kbnode_t *kb_all;
1995   KEYDB_HANDLE hd;
1996   int i;
1997
1998   /* Get the fingerprints of any bindings that share the email address
1999    * and whether the bindings have a known conflict.
2000    *
2001    * Note: if the binding in question is in the DB, it will also be
2002    * returned.  Thus, if the result set is empty, then <email,
2003    * fingerprint> is a new binding.  */
2004   rc = gpgsql_stepx
2005     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
2006      strings_collect_cb2, &conflict_set, &sqerr,
2007      "select"
2008      /* A binding should only appear once, but try not to break in the
2009       * case of corruption.  */
2010      "  fingerprint || case sum(conflict NOTNULL) when 0 then '' else '!' end"
2011      " from bindings where email = ?"
2012      "  group by fingerprint"
2013      /* Make sure the current key comes first in the result list (if
2014         it is present).  */
2015      "  order by fingerprint = ? asc, fingerprint desc;",
2016      GPGSQL_ARG_STRING, email,
2017      GPGSQL_ARG_STRING, fingerprint,
2018      GPGSQL_ARG_END);
2019   if (rc)
2020     {
2021       log_error (_("error reading TOFU database: %s\n"), sqerr);
2022       print_further_info ("listing fingerprints");
2023       sqlite3_free (sqerr);
2024       rc = gpg_error (GPG_ERR_GENERAL);
2025       return NULL;
2026     }
2027
2028   /* Set BINDING_CONFLICT if the binding has a known conflict.  This
2029    * allows us to distinguish between bindings where the user
2030    * explicitly set the policy to ask and bindings where we set the
2031    * policy to ask due to a conflict.  */
2032   for (iter = conflict_set; iter; iter = iter->next)
2033     {
2034       int l = strlen (iter->d);
2035       if (!(l == 2 * MAX_FINGERPRINT_LEN
2036             || l == 2 * MAX_FINGERPRINT_LEN + 1))
2037         {
2038           log_error (_("TOFU db corruption detected.\n"));
2039           print_further_info ("fingerprint '%s' is not %d characters long",
2040                               iter->d, 2 * MAX_FINGERPRINT_LEN);
2041         }
2042
2043       if (l >= 1 && iter->d[l - 1] == '!')
2044         {
2045           iter->flags |= BINDING_CONFLICT;
2046           /* Remove the !.  */
2047           iter->d[l - 1] = 0;
2048         }
2049     }
2050
2051   /* If the current binding has not yet been recorded, add it to the
2052    * list.  (The order by above ensures that if it is present, it will
2053    * be first.)  */
2054   if (! (conflict_set && strcmp (conflict_set->d, fingerprint) == 0))
2055     {
2056       add_to_strlist (&conflict_set, fingerprint);
2057       conflict_set->flags |= BINDING_NEW;
2058     }
2059
2060   conflict_set_count = strlist_length (conflict_set);
2061
2062   /* Eliminate false conflicts.  */
2063
2064   if (conflict_set_count == 1)
2065     /* We only have a single key.  There are no false conflicts to
2066        eliminate.  But, we do need to set the flags.  */
2067     {
2068       if (pk->has_expired)
2069         conflict_set->flags |= BINDING_EXPIRED;
2070       if (pk->flags.revoked)
2071         conflict_set->flags |= BINDING_REVOKED;
2072
2073       return conflict_set;
2074     }
2075
2076   /* If two keys have cross signatures, then they are controlled by
2077    * the same person and thus are not in conflict.  */
2078   kb_all = xcalloc (sizeof (kb_all[0]), conflict_set_count);
2079   hd = keydb_new ();
2080   for (i = 0, iter = conflict_set;
2081        i < conflict_set_count;
2082        i ++, iter = iter->next)
2083     {
2084       char *fp = iter->d;
2085       KEYDB_SEARCH_DESC desc;
2086       kbnode_t kb;
2087       PKT_public_key *binding_pk;
2088       kbnode_t n;
2089       int found_user_id;
2090
2091       rc = keydb_search_reset (hd);
2092       if (rc)
2093         {
2094           log_error (_("resetting keydb: %s\n"),
2095                      gpg_strerror (rc));
2096           continue;
2097         }
2098
2099       rc = classify_user_id (fp, &desc, 0);
2100       if (rc)
2101         {
2102           log_error (_("error parsing key specification '%s': %s\n"),
2103                      fp, gpg_strerror (rc));
2104           continue;
2105         }
2106
2107       rc = keydb_search (hd, &desc, 1, NULL);
2108       if (rc)
2109         {
2110           /* Note: it is entirely possible that we don't have the key
2111              corresponding to an entry in the TOFU DB.  This can
2112              happen if we merge two TOFU DBs, but not the key
2113              rings.  */
2114           log_info (_("key \"%s\" not found: %s\n"),
2115                     fp, gpg_strerror (rc));
2116           continue;
2117         }
2118
2119       rc = keydb_get_keyblock (hd, &kb);
2120       if (rc)
2121         {
2122           log_error (_("error reading keyblock: %s\n"),
2123                      gpg_strerror (rc));
2124           print_further_info ("fingerprint: %s", fp);
2125           continue;
2126         }
2127
2128       merge_keys_and_selfsig (kb);
2129
2130       log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2131
2132       kb_all[i] = kb;
2133
2134       /* Since we have the key block, use this opportunity to figure
2135        * out if the binding is expired or revoked.  */
2136       binding_pk = kb->pkt->pkt.public_key;
2137
2138       /* The binding is always expired/revoked if the key is
2139        * expired/revoked.  */
2140       if (binding_pk->has_expired)
2141         iter->flags |= BINDING_EXPIRED;
2142       if (binding_pk->flags.revoked)
2143         iter->flags |= BINDING_REVOKED;
2144
2145       /* The binding is also expired/revoked if the user id is
2146        * expired/revoked.  */
2147       n = kb;
2148       found_user_id = 0;
2149       while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
2150         {
2151           PKT_user_id *user_id2 = n->pkt->pkt.user_id;
2152           char *email2;
2153
2154           if (user_id2->attrib_data)
2155             continue;
2156
2157           email2 = email_from_user_id (user_id2->name);
2158
2159           if (strcmp (email, email2) == 0)
2160             {
2161               found_user_id = 1;
2162
2163               if (user_id2->is_revoked)
2164                 iter->flags |= BINDING_REVOKED;
2165               if (user_id2->is_expired)
2166                 iter->flags |= BINDING_EXPIRED;
2167             }
2168
2169           xfree (email2);
2170         }
2171
2172       if (! found_user_id)
2173         {
2174           log_info (_("TOFU db corruption detected.\n"));
2175           print_further_info ("user id '%s' not on key block '%s'",
2176                               email, fingerprint);
2177         }
2178     }
2179   keydb_release (hd);
2180
2181   /* Now that we have the key blocks, check for cross sigs.  */
2182   {
2183     int j;
2184     strlist_t *prevp;
2185     strlist_t iter_next;
2186     int die[conflict_set_count];
2187
2188     memset (die, 0, sizeof (die));
2189
2190     for (i = 0; i < conflict_set_count; i ++)
2191       {
2192         /* Look for cross sigs between this key (i == 0) or a key
2193          * that has cross sigs with i == 0 (i.e., transitively) */
2194         if (! (i == 0 || die[i]))
2195           continue;
2196
2197         for (j = i + 1; j < conflict_set_count; j ++)
2198           /* Be careful: we might not have a key block for a key.  */
2199           if (kb_all[i] && kb_all[j] && cross_sigs (email, kb_all[i], kb_all[j]))
2200             die[j] = 1;
2201       }
2202
2203     /* Free unconflicting bindings (and all of the key blocks).  */
2204     for (iter = conflict_set, prevp = &conflict_set, i = 0;
2205          iter;
2206          iter = iter_next, i ++)
2207       {
2208         iter_next = iter->next;
2209
2210         release_kbnode (kb_all[i]);
2211
2212         if (die[i])
2213           {
2214             *prevp = iter_next;
2215             iter->next = NULL;
2216             free_strlist (iter);
2217             conflict_set_count --;
2218           }
2219         else
2220           {
2221             prevp = &iter->next;
2222           }
2223       }
2224
2225     /* We shouldn't have removed the head.  */
2226     log_assert (conflict_set);
2227     log_assert (conflict_set_count >= 1);
2228   }
2229   xfree (kb_all);
2230
2231   if (DBG_TRUST)
2232     {
2233       log_debug ("binding <key: %s, email: %s> conflicts:\n",
2234                  fingerprint, email);
2235       for (iter = conflict_set; iter; iter = iter->next)
2236         {
2237           log_debug ("  %s:%s%s%s%s\n",
2238                      iter->d,
2239                      (iter->flags & BINDING_NEW) ? " new" : "",
2240                      (iter->flags & BINDING_CONFLICT) ? " known_conflict" : "",
2241                      (iter->flags & BINDING_EXPIRED) ? " expired" : "",
2242                      (iter->flags & BINDING_REVOKED) ? " revoked" : "");
2243         }
2244     }
2245
2246   return conflict_set;
2247 }
2248
2249
2250 /* Return the effective policy for the binding <FINGERPRINT, EMAIL>
2251  * (email has already been normalized) and any conflict information in
2252  * *CONFLICT_SETP, if CONFLICT_SETP is not NULL.  Returns
2253  * _tofu_GET_POLICY_ERROR if an error occurs.  */
2254 static enum tofu_policy
2255 get_policy (tofu_dbs_t dbs, PKT_public_key *pk,
2256             const char *fingerprint, const char *user_id, const char *email,
2257             strlist_t *conflict_setp, time_t now)
2258 {
2259   int rc;
2260   char *err = NULL;
2261   strlist_t results = NULL;
2262   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
2263   enum tofu_policy effective_policy_orig = TOFU_POLICY_NONE;
2264   enum tofu_policy effective_policy = _tofu_GET_POLICY_ERROR;
2265   long along;
2266   char *conflict_orig = NULL;
2267   char *conflict = NULL;
2268   strlist_t conflict_set = NULL;
2269   int conflict_set_count;
2270
2271   /* Check if the <FINGERPRINT, EMAIL> binding is known
2272      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
2273      still TOFU_POLICY_NONE after executing the query, then the
2274      result set was empty.)  */
2275   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
2276                       strings_collect_cb2, &results, &err,
2277                       "select policy, conflict, effective_policy from bindings\n"
2278                       " where fingerprint = ? and email = ?",
2279                       GPGSQL_ARG_STRING, fingerprint,
2280                       GPGSQL_ARG_STRING, email,
2281                       GPGSQL_ARG_END);
2282   if (rc)
2283     {
2284       log_error (_("error reading TOFU database: %s\n"), err);
2285       print_further_info ("reading the policy");
2286       sqlite3_free (err);
2287       rc = gpg_error (GPG_ERR_GENERAL);
2288       goto out;
2289     }
2290
2291   if (strlist_length (results) == 0)
2292     {
2293       /* No results.  Use the defaults.  */
2294       policy = TOFU_POLICY_NONE;
2295       effective_policy = TOFU_POLICY_NONE;
2296     }
2297   else if (strlist_length (results) == 3)
2298     {
2299       /* Parse and sanity check the results.  */
2300
2301       if (string_to_long (&along, results->d, 0, __LINE__))
2302         {
2303           log_error (_("error reading TOFU database: %s\n"),
2304                      gpg_strerror (GPG_ERR_BAD_DATA));
2305           print_further_info ("bad value for policy: %s", results->d);
2306           goto out;
2307         }
2308       policy = along;
2309
2310       if (! (policy == TOFU_POLICY_AUTO
2311              || policy == TOFU_POLICY_GOOD
2312              || policy == TOFU_POLICY_UNKNOWN
2313              || policy == TOFU_POLICY_BAD
2314              || policy == TOFU_POLICY_ASK))
2315         {
2316           log_error (_("error reading TOFU database: %s\n"),
2317                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
2318           print_further_info ("invalid value for policy (%d)", policy);
2319           effective_policy = _tofu_GET_POLICY_ERROR;
2320           goto out;
2321         }
2322
2323       if (*results->next->d)
2324         conflict = xstrdup (results->next->d);
2325
2326       if (string_to_long (&along, results->next->next->d, 0, __LINE__))
2327         {
2328           log_error (_("error reading TOFU database: %s\n"),
2329                      gpg_strerror (GPG_ERR_BAD_DATA));
2330           print_further_info ("bad value for effective policy: %s",
2331                               results->next->next->d);
2332           goto out;
2333         }
2334       effective_policy = along;
2335
2336       if (! (effective_policy == TOFU_POLICY_NONE
2337              || effective_policy == TOFU_POLICY_AUTO
2338              || effective_policy == TOFU_POLICY_GOOD
2339              || effective_policy == TOFU_POLICY_UNKNOWN
2340              || effective_policy == TOFU_POLICY_BAD
2341              || effective_policy == TOFU_POLICY_ASK))
2342         {
2343           log_error (_("error reading TOFU database: %s\n"),
2344                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
2345           print_further_info ("invalid value for effective_policy (%d)",
2346                               effective_policy);
2347           effective_policy = _tofu_GET_POLICY_ERROR;
2348           goto out;
2349         }
2350     }
2351   else
2352     {
2353       /* The result has the wrong form.  */
2354
2355       log_error (_("error reading TOFU database: %s\n"),
2356                  gpg_strerror (GPG_ERR_BAD_DATA));
2357       print_further_info ("reading policy: expected 3 columns, got %d\n",
2358                           strlist_length (results));
2359       goto out;
2360     }
2361
2362   /* Save the effective policy and conflict so we know if we changed
2363    * them.  */
2364   effective_policy_orig = effective_policy;
2365   conflict_orig = conflict;
2366
2367   /* Unless there is a conflict, if the effective policy is cached,
2368    * just return it.  The reason we don't do this when there is a
2369    * conflict is because of the following scenario: assume A and B
2370    * conflict and B has signed A's key.  Now, later we import A's
2371    * signature on B.  We need to recheck A, but the signature was on
2372    * B, i.e., when B changes, we invalidate B's effective policy, but
2373    * we also need to invalidate A's effective policy.  Instead, we
2374    * assume that conflicts are rare and don't optimize for them, which
2375    * would complicate the code.  */
2376   if (effective_policy != TOFU_POLICY_NONE && !conflict)
2377     goto out;
2378
2379   /* If the user explicitly set the policy, then respect that.  */
2380   if (policy != TOFU_POLICY_AUTO && policy != TOFU_POLICY_NONE)
2381     {
2382       effective_policy = policy;
2383       goto out;
2384     }
2385
2386   /* Unless proven wrong, assume the effective policy is 'auto'.  */
2387   effective_policy = TOFU_POLICY_AUTO;
2388
2389   /* See if the key is ultimately trusted.  */
2390   {
2391     u32 kid[2];
2392
2393     keyid_from_pk (pk, kid);
2394     if (tdb_keyid_is_utk (kid))
2395       {
2396         effective_policy = TOFU_POLICY_GOOD;
2397         goto out;
2398       }
2399   }
2400
2401   /* See if the key is signed by an ultimately trusted key.  */
2402   {
2403     int fingerprint_raw_len = strlen (fingerprint) / 2;
2404     char fingerprint_raw[fingerprint_raw_len];
2405     int len = 0;
2406
2407     if (fingerprint_raw_len != 20
2408         || ((len = hex2bin (fingerprint,
2409                             fingerprint_raw, fingerprint_raw_len))
2410             != strlen (fingerprint)))
2411       {
2412         if (DBG_TRUST)
2413           log_debug ("TOFU: Bad fingerprint: %s (len: %zd, parsed: %d)\n",
2414                      fingerprint, strlen (fingerprint), len);
2415       }
2416     else
2417       {
2418         int lookup_err;
2419         kbnode_t kb;
2420
2421         lookup_err = get_pubkey_byfprint (NULL, &kb,
2422                                           fingerprint_raw,
2423                                           fingerprint_raw_len);
2424         if (lookup_err)
2425           {
2426             if (DBG_TRUST)
2427               log_debug ("TOFU: Looking up %s: %s\n",
2428                          fingerprint, gpg_strerror (lookup_err));
2429           }
2430         else
2431           {
2432             int is_signed_by_utk = signed_by_utk (email, kb);
2433             release_kbnode (kb);
2434             if (is_signed_by_utk)
2435               {
2436                 effective_policy = TOFU_POLICY_GOOD;
2437                 goto out;
2438               }
2439           }
2440       }
2441   }
2442
2443   /* Check for any conflicts / see if a previously discovered conflict
2444    * disappeared.  The latter can happen if the conflicting bindings
2445    * are now cross signed, for instance.  */
2446
2447   conflict_set = build_conflict_set (dbs, pk, fingerprint, email);
2448   conflict_set_count = strlist_length (conflict_set);
2449   if (conflict_set_count == 0)
2450     {
2451       /* build_conflict_set should always at least return the current
2452          binding.  Something went wrong.  */
2453       effective_policy = _tofu_GET_POLICY_ERROR;
2454       goto out;
2455     }
2456
2457   if (conflict_set_count == 1
2458       && (conflict_set->flags & BINDING_NEW))
2459     {
2460       /* We've never observed a binding with this email address and we
2461        * have a default policy, which is not to ask the user.  */
2462
2463       /* If we've seen this binding, then we've seen this email and
2464        * policy couldn't possibly be TOFU_POLICY_NONE.  */
2465       log_assert (policy == TOFU_POLICY_NONE);
2466
2467       if (DBG_TRUST)
2468         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
2469                    fingerprint, email);
2470
2471       effective_policy = TOFU_POLICY_AUTO;
2472       goto out;
2473     }
2474
2475   if (conflict_set_count == 1
2476       && (conflict_set->flags & BINDING_CONFLICT))
2477     {
2478       /* No known conflicts now, but there was a conflict.  That is,
2479        * at somepoint there was a conflict, but it went away.  A
2480        * conflict can go away if there is now a cross sig between the
2481        * two keys.  In this case, we just silently clear the
2482        * conflict.  */
2483
2484       if (DBG_TRUST)
2485         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
2486                    fingerprint, email);
2487
2488       effective_policy = TOFU_POLICY_AUTO;
2489       conflict = NULL;
2490
2491       goto out;
2492     }
2493
2494   if (conflict_set_count == 1)
2495     {
2496       /* No conflicts and never marked as conflicting.  */
2497
2498       log_assert (!conflict);
2499
2500       effective_policy = TOFU_POLICY_AUTO;
2501
2502       goto out;
2503     }
2504
2505   /* There is a conflicting key.  */
2506   log_assert (conflict_set_count > 1);
2507   effective_policy = TOFU_POLICY_ASK;
2508   conflict = xstrdup (conflict_set->next->d);
2509
2510  out:
2511   log_assert (policy == _tofu_GET_POLICY_ERROR
2512               || policy == TOFU_POLICY_NONE
2513               || policy == TOFU_POLICY_AUTO
2514               || policy == TOFU_POLICY_GOOD
2515               || policy == TOFU_POLICY_UNKNOWN
2516               || policy == TOFU_POLICY_BAD
2517               || policy == TOFU_POLICY_ASK);
2518   /* Everything but NONE.  */
2519   log_assert (effective_policy == _tofu_GET_POLICY_ERROR
2520               || effective_policy == TOFU_POLICY_AUTO
2521               || effective_policy == TOFU_POLICY_GOOD
2522               || effective_policy == TOFU_POLICY_UNKNOWN
2523               || effective_policy == TOFU_POLICY_BAD
2524               || effective_policy == TOFU_POLICY_ASK);
2525
2526   if (effective_policy != TOFU_POLICY_ASK && conflict)
2527     conflict = NULL;
2528
2529   /* If we don't have a record of this binding, its effective policy
2530    * changed, or conflict changed, update the DB.  */
2531   if (effective_policy != _tofu_GET_POLICY_ERROR
2532       && (/* New binding.  */
2533           policy == TOFU_POLICY_NONE
2534           /* effective_policy changed.  */
2535           || effective_policy != effective_policy_orig
2536           /* conflict changed.  */
2537           || (conflict != conflict_orig
2538               && (!conflict || !conflict_orig
2539                   || strcmp (conflict, conflict_orig) != 0))))
2540     {
2541       if (record_binding (dbs, fingerprint, email, user_id,
2542                           policy == TOFU_POLICY_NONE ? TOFU_POLICY_AUTO : policy,
2543                           effective_policy, conflict, 1, 0, now) != 0)
2544         log_error (_("error setting TOFU binding's policy"
2545                      " to %s\n"), tofu_policy_str (policy));
2546     }
2547
2548   /* If the caller wants the set of conflicts, return it.  */
2549   if (effective_policy == TOFU_POLICY_ASK && conflict_setp)
2550     {
2551       if (! conflict_set)
2552         conflict_set = build_conflict_set (dbs, pk, fingerprint, email);
2553       *conflict_setp = conflict_set;
2554     }
2555   else
2556     {
2557       free_strlist (conflict_set);
2558
2559       if (conflict_setp)
2560         *conflict_setp = NULL;
2561     }
2562
2563   xfree (conflict_orig);
2564   if (conflict != conflict_orig)
2565     xfree (conflict);
2566   free_strlist (results);
2567
2568   return effective_policy;
2569 }
2570
2571
2572 /* Return the trust level (TRUST_NEVER, etc.) for the binding
2573  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
2574  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
2575  * returns _tofu_GET_TRUST_ERROR.
2576  *
2577  * PK is the public key object for FINGERPRINT.
2578  *
2579  * USER_ID is the unadulterated user id.
2580  *
2581  * If MAY_ASK is set, then we may interact with the user.  This is
2582  * necessary if there is a conflict or the binding's policy is
2583  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
2584  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
2585  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
2586  * function must not be called while in a transaction!  */
2587 static enum tofu_policy
2588 get_trust (ctrl_t ctrl, PKT_public_key *pk,
2589            const char *fingerprint, const char *email,
2590            const char *user_id, int may_ask, time_t now)
2591 {
2592   tofu_dbs_t dbs = ctrl->tofu.dbs;
2593   int in_transaction = 0;
2594   enum tofu_policy policy;
2595   int rc;
2596   char *sqerr = NULL;
2597   strlist_t conflict_set = NULL;
2598   int trust_level = TRUST_UNKNOWN;
2599   strlist_t iter;
2600
2601   log_assert (dbs);
2602
2603   if (may_ask)
2604     log_assert (dbs->in_transaction == 0);
2605
2606   if (opt.batch)
2607     may_ask = 0;
2608
2609   log_assert (pk_is_primary (pk));
2610
2611   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
2612      levels.  */
2613   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
2614               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
2615               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
2616               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
2617               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
2618               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
2619               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
2620
2621   /* If the key is ultimately trusted, there is nothing to do.  */
2622   {
2623     u32 kid[2];
2624
2625     keyid_from_pk (pk, kid);
2626     if (tdb_keyid_is_utk (kid))
2627       {
2628         trust_level = TRUST_ULTIMATE;
2629         goto out;
2630       }
2631   }
2632
2633   begin_transaction (ctrl, 0);
2634   in_transaction = 1;
2635
2636   policy = get_policy (dbs, pk, fingerprint, user_id, email, &conflict_set, now);
2637   if (policy == TOFU_POLICY_AUTO)
2638     {
2639       policy = opt.tofu_default_policy;
2640       if (DBG_TRUST)
2641         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is"
2642                    " auto (default: %s).\n",
2643                    fingerprint, email,
2644                    tofu_policy_str (opt.tofu_default_policy));
2645     }
2646   switch (policy)
2647     {
2648     case TOFU_POLICY_AUTO:
2649     case TOFU_POLICY_GOOD:
2650     case TOFU_POLICY_UNKNOWN:
2651     case TOFU_POLICY_BAD:
2652       /* The saved judgement is auto -> auto, good, unknown or bad.
2653        * We don't need to ask the user anything.  */
2654       if (DBG_TRUST)
2655         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
2656                    fingerprint, email, tofu_policy_str (policy));
2657       trust_level = tofu_policy_to_trust_level (policy);
2658       goto out;
2659
2660     case TOFU_POLICY_ASK:
2661       /* We need to ask the user what to do.  */
2662       break;
2663
2664     case _tofu_GET_POLICY_ERROR:
2665       trust_level = _tofu_GET_TRUST_ERROR;
2666       goto out;
2667
2668     default:
2669       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2670     }
2671
2672
2673   /* We get here if:
2674    *
2675    *   1. The saved policy is auto and the default policy is ask
2676    *      (get_policy() == TOFU_POLICY_AUTO
2677    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2678    *
2679    *   2. The saved policy is ask (either last time the user selected
2680    *      accept once or reject once or there was a conflict and this
2681    *      binding's policy was changed from auto to ask)
2682    *      (policy == TOFU_POLICY_ASK).
2683    */
2684   log_assert (policy == TOFU_POLICY_ASK);
2685
2686   if (may_ask)
2687     {
2688       /* We can't be in a normal transaction in ask_about_binding.  */
2689       end_transaction (ctrl, 0);
2690       in_transaction = 0;
2691
2692       /* If we get here, we need to ask the user about the binding.  */
2693       ask_about_binding (ctrl,
2694                          &policy,
2695                          &trust_level,
2696                          conflict_set,
2697                          fingerprint,
2698                          email,
2699                          user_id,
2700                          now);
2701     }
2702   else
2703     trust_level = TRUST_UNDEFINED;
2704
2705   /* Mark any conflicting bindings that have an automatic policy as
2706    * now requiring confirmation.  Note: we do this after we ask for
2707    * confirmation so that when the current policy is printed, it is
2708    * correct.  */
2709   if (! in_transaction)
2710     {
2711       begin_transaction (ctrl, 0);
2712       in_transaction = 1;
2713     }
2714
2715   /* The conflict set should always contain at least one element:
2716    * the current key.  */
2717   log_assert (conflict_set);
2718
2719   for (iter = conflict_set->next; iter; iter = iter->next)
2720     {
2721       /* We don't immediately set the effective policy to 'ask,
2722          because  */
2723       rc = gpgsql_exec_printf
2724         (dbs->db, NULL, NULL, &sqerr,
2725          "update bindings set effective_policy = %d, conflict = %Q"
2726          " where email = %Q and fingerprint = %Q and effective_policy != %d;",
2727          TOFU_POLICY_NONE, fingerprint,
2728          email, iter->d, TOFU_POLICY_ASK);
2729       if (rc)
2730         {
2731           log_error (_("error changing TOFU policy: %s\n"), sqerr);
2732           print_further_info ("binding: <key: %s, user id: %s>",
2733                               fingerprint, user_id);
2734           sqlite3_free (sqerr);
2735           sqerr = NULL;
2736           rc = gpg_error (GPG_ERR_GENERAL);
2737         }
2738       else if (DBG_TRUST)
2739         log_debug ("Set %s to conflict with %s\n",
2740                    iter->d, fingerprint);
2741     }
2742
2743  out:
2744   if (in_transaction)
2745     end_transaction (ctrl, 0);
2746
2747   free_strlist (conflict_set);
2748
2749   return trust_level;
2750 }
2751
2752
2753 /* Return a malloced string of the form
2754  *    "7 months, 1 day, 5 minutes, 0 seconds"
2755  * The caller should replace all '~' in the returned string by a space
2756  * and also free the returned string.
2757  *
2758  * This is actually a bad hack which may not work correctly with all
2759  * languages.
2760  */
2761 static char *
2762 time_ago_str (long long int t)
2763 {
2764   estream_t fp;
2765   int years = 0;
2766   int months = 0;
2767   int days = 0;
2768   int hours = 0;
2769   int minutes = 0;
2770   int seconds = 0;
2771
2772   /* The number of units that we've printed so far.  */
2773   int count = 0;
2774   /* The first unit that we printed (year = 0, month = 1,
2775      etc.).  */
2776   int first = -1;
2777   /* The current unit.  */
2778   int i = 0;
2779
2780   char *str;
2781
2782   /* It would be nice to use a macro to do this, but gettext
2783      works on the unpreprocessed code.  */
2784 #define MIN_SECS (60)
2785 #define HOUR_SECS (60 * MIN_SECS)
2786 #define DAY_SECS (24 * HOUR_SECS)
2787 #define MONTH_SECS (30 * DAY_SECS)
2788 #define YEAR_SECS (365 * DAY_SECS)
2789
2790   if (t > YEAR_SECS)
2791     {
2792       years = t / YEAR_SECS;
2793       t -= years * YEAR_SECS;
2794     }
2795   if (t > MONTH_SECS)
2796     {
2797       months = t / MONTH_SECS;
2798       t -= months * MONTH_SECS;
2799     }
2800   if (t > DAY_SECS)
2801     {
2802       days = t / DAY_SECS;
2803       t -= days * DAY_SECS;
2804     }
2805   if (t > HOUR_SECS)
2806     {
2807       hours = t / HOUR_SECS;
2808       t -= hours * HOUR_SECS;
2809     }
2810   if (t > MIN_SECS)
2811     {
2812       minutes = t / MIN_SECS;
2813       t -= minutes * MIN_SECS;
2814     }
2815   seconds = t;
2816
2817 #undef MIN_SECS
2818 #undef HOUR_SECS
2819 #undef DAY_SECS
2820 #undef MONTH_SECS
2821 #undef YEAR_SECS
2822
2823   fp = es_fopenmem (0, "rw,samethread");
2824   if (! fp)
2825     log_fatal ("error creating memory stream: %s\n",
2826                gpg_strerror (gpg_error_from_syserror()));
2827
2828   if (years)
2829     {
2830       /* TRANSLATORS: The tilde ('~') is used here to indicate a
2831        * non-breakable space  */
2832       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
2833       count ++;
2834       first = i;
2835     }
2836   i ++;
2837   if ((first == -1 || i - first <= 3) && count <= 0 && months)
2838     {
2839       if (count)
2840         es_fprintf (fp, ", ");
2841       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
2842       count ++;
2843       first = i;
2844     }
2845   i ++;
2846   if ((first == -1 || i - first <= 3) && count <= 0 && days)
2847     {
2848       if (count)
2849         es_fprintf (fp, ", ");
2850       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
2851       count ++;
2852       first = i;
2853     }
2854   i ++;
2855   if ((first == -1 || i - first <= 3) && count <= 0 && hours)
2856     {
2857       if (count)
2858         es_fprintf (fp, ", ");
2859       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
2860       count ++;
2861       first = i;
2862     }
2863   i ++;
2864   if ((first == -1 || i - first <= 3) && count <= 0 && minutes)
2865     {
2866       if (count)
2867         es_fprintf (fp, ", ");
2868       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
2869       count ++;
2870       first = i;
2871     }
2872   i ++;
2873   if ((first == -1 || i - first <= 3) && count <= 0)
2874     {
2875       if (count)
2876         es_fprintf (fp, ", ");
2877       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
2878     }
2879
2880   es_fputc (0, fp);
2881   if (es_fclose_snatch (fp, (void **) &str, NULL))
2882     log_fatal ("error snatching memory stream\n");
2883
2884   return str;
2885 }
2886
2887
2888 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2889  * write a "tfs" record to that stream. */
2890 static void
2891 write_stats_status (estream_t fp,
2892                     enum tofu_policy policy,
2893                     unsigned long signature_count,
2894                     unsigned long signature_first_seen,
2895                     unsigned long signature_most_recent,
2896                     unsigned long encryption_count,
2897                     unsigned long encryption_first_done,
2898                     unsigned long encryption_most_recent)
2899 {
2900   int summary;
2901   int validity;
2902   unsigned long messages;
2903
2904   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
2905      sum of the magnitudes (m = a + b) to ensure a balance between
2906      verified signatures and encrypted messages.  */
2907   messages = sqrtu32 (signature_count * signature_count
2908                       + encryption_count * encryption_count);
2909
2910   if (messages < 1)
2911     validity = 1; /* Key without history.  */
2912   else if (messages < 2 * BASIC_TRUST_THRESHOLD)
2913     validity = 2; /* Key with too little history.  */
2914   else if (messages < 2 * FULL_TRUST_THRESHOLD)
2915     validity = 3; /* Key with enough history for basic trust.  */
2916   else
2917     validity = 4; /* Key with a lot of history.  */
2918
2919   if (policy == TOFU_POLICY_ASK)
2920     summary = 0; /* Key requires attention.  */
2921   else
2922     summary = validity;
2923
2924   if (fp)
2925     {
2926       es_fprintf (fp, "tfs:1:%d:%lu:%lu:%s:%lu:%lu:%lu:%lu:%d:\n",
2927                   summary, signature_count, encryption_count,
2928                   tofu_policy_str (policy),
2929                   signature_first_seen, signature_most_recent,
2930                   encryption_first_done, encryption_most_recent,
2931                   validity);
2932     }
2933   else
2934     {
2935       write_status_printf (STATUS_TOFU_STATS,
2936                            "%d %lu %lu %s %lu %lu %lu %lu %d",
2937                            summary,
2938                            signature_count,
2939                            encryption_count,
2940                            tofu_policy_str (policy),
2941                            signature_first_seen,
2942                            signature_most_recent,
2943                            encryption_first_done,
2944                            encryption_most_recent,
2945                            validity);
2946     }
2947 }
2948
2949 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2950  * to OUTFP.
2951  *
2952  * Returns whether the caller should call show_warning after iterating
2953  * over all user ids.
2954  */
2955 static int
2956 show_statistics (tofu_dbs_t dbs, PKT_public_key *pk, const char *fingerprint,
2957                  const char *email, const char *user_id,
2958                  estream_t outfp, time_t now)
2959 {
2960   enum tofu_policy policy =
2961     get_policy (dbs, pk, fingerprint, user_id, email, NULL, now);
2962
2963   char *fingerprint_pp;
2964   int rc;
2965   strlist_t strlist = NULL;
2966   char *err = NULL;
2967
2968   unsigned long signature_first_seen = 0;
2969   unsigned long signature_most_recent = 0;
2970   unsigned long signature_count = 0;
2971   unsigned long encryption_first_done = 0;
2972   unsigned long encryption_most_recent = 0;
2973   unsigned long encryption_count = 0;
2974
2975   int show_warning = 0;
2976
2977   (void) user_id;
2978
2979   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2980
2981   /* Get the signature stats.  */
2982   rc = gpgsql_exec_printf
2983     (dbs->db, strings_collect_cb, &strlist, &err,
2984      "select count (*), min (signatures.time), max (signatures.time)\n"
2985      " from signatures\n"
2986      " left join bindings on signatures.binding = bindings.oid\n"
2987      " where fingerprint = %Q and email = %Q;",
2988      fingerprint, email);
2989   if (rc)
2990     {
2991       log_error (_("error reading TOFU database: %s\n"), err);
2992       print_further_info ("getting signature statistics");
2993       sqlite3_free (err);
2994       rc = gpg_error (GPG_ERR_GENERAL);
2995       goto out;
2996     }
2997
2998   if (strlist)
2999     {
3000       /* We expect exactly 3 elements.  */
3001       log_assert (strlist->next);
3002       log_assert (strlist->next->next);
3003       log_assert (! strlist->next->next->next);
3004
3005       string_to_ulong (&signature_count, strlist->d, -1, __LINE__);
3006       string_to_ulong (&signature_first_seen, strlist->next->d, -1, __LINE__);
3007       string_to_ulong (&signature_most_recent,
3008                        strlist->next->next->d, -1, __LINE__);
3009
3010       free_strlist (strlist);
3011       strlist = NULL;
3012     }
3013
3014   /* Get the encryption stats.  */
3015   rc = gpgsql_exec_printf
3016     (dbs->db, strings_collect_cb, &strlist, &err,
3017      "select count (*), min (encryptions.time), max (encryptions.time)\n"
3018      " from encryptions\n"
3019      " left join bindings on encryptions.binding = bindings.oid\n"
3020      " where fingerprint = %Q and email = %Q;",
3021      fingerprint, email);
3022   if (rc)
3023     {
3024       log_error (_("error reading TOFU database: %s\n"), err);
3025       print_further_info ("getting encryption statistics");
3026       sqlite3_free (err);
3027       rc = gpg_error (GPG_ERR_GENERAL);
3028       goto out;
3029     }
3030
3031   if (strlist)
3032     {
3033       /* We expect exactly 3 elements.  */
3034       log_assert (strlist->next);
3035       log_assert (strlist->next->next);
3036       log_assert (! strlist->next->next->next);
3037
3038       string_to_ulong (&encryption_count, strlist->d, -1, __LINE__);
3039       string_to_ulong (&encryption_first_done, strlist->next->d, -1, __LINE__);
3040       string_to_ulong (&encryption_most_recent,
3041                        strlist->next->next->d, -1, __LINE__);
3042
3043       free_strlist (strlist);
3044       strlist = NULL;
3045     }
3046
3047   if (!outfp)
3048     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
3049                                   email, strlen (email), 0);
3050
3051   write_stats_status (outfp, policy,
3052                       signature_count,
3053                       signature_first_seen,
3054                       signature_most_recent,
3055                       encryption_count,
3056                       encryption_first_done,
3057                       encryption_most_recent);
3058
3059   if (!outfp)
3060     {
3061       estream_t fp;
3062       char *msg;
3063
3064       fp = es_fopenmem (0, "rw,samethread");
3065       if (! fp)
3066         log_fatal ("error creating memory stream: %s\n",
3067                    gpg_strerror (gpg_error_from_syserror()));
3068
3069       es_fprintf (fp, _("%s: "), email);
3070
3071       if (signature_count == 0)
3072         {
3073           es_fprintf (fp, _("Verified %ld signatures"), 0L);
3074           es_fputc ('\n', fp);
3075         }
3076       else
3077         {
3078           char *first_seen_ago_str = time_ago_str (now - signature_first_seen);
3079
3080           /* TRANSLATORS: The final %s is replaced by a string like
3081              "7 months, 1 day, 5 minutes, 0 seconds". */
3082           es_fprintf (fp,
3083                       ngettext("Verified %ld signature in the past %s",
3084                                "Verified %ld signatures in the past %s",
3085                                signature_count),
3086                       signature_count, first_seen_ago_str);
3087
3088           xfree (first_seen_ago_str);
3089         }
3090
3091       if (encryption_count == 0)
3092         {
3093           es_fprintf (fp, _(", and encrypted %ld messages"), 0L);
3094         }
3095       else
3096         {
3097           char *first_done_ago_str = time_ago_str (now - encryption_first_done);
3098
3099           /* TRANSLATORS: The final %s is replaced by a string like
3100              "7 months, 1 day, 5 minutes, 0 seconds". */
3101           es_fprintf (fp,
3102                       ngettext(", and encrypted %ld message in the past %s",
3103                                ", and encrypted %ld messages in the past %s",
3104                                encryption_count),
3105                       encryption_count, first_done_ago_str);
3106
3107           xfree (first_done_ago_str);
3108         }
3109
3110       if (opt.verbose)
3111         {
3112           es_fputs ("  ", fp);
3113           es_fputc ('(', fp);
3114           es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
3115           es_fputs (").\n", fp);
3116         }
3117       else
3118         es_fputs (".\n", fp);
3119
3120
3121       {
3122         char *tmpmsg, *p;
3123         es_fputc (0, fp);
3124         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
3125           log_fatal ("error snatching memory stream\n");
3126         msg = format_text (tmpmsg, 0, 72, 80);
3127         es_free (tmpmsg);
3128
3129         /* Print a status line but suppress the trailing LF.
3130          * Spaces are not percent escaped. */
3131         if (*msg)
3132           write_status_buffer (STATUS_TOFU_STATS_LONG,
3133                                msg, strlen (msg)-1, -1);
3134
3135         /* Remove the non-breaking space markers.  */
3136         for (p=msg; *p; p++)
3137           if (*p == '~')
3138             *p = ' ';
3139       }
3140
3141       log_string (GPGRT_LOG_INFO, msg);
3142       xfree (msg);
3143
3144       if (policy == TOFU_POLICY_AUTO)
3145         {
3146           if (signature_count == 0)
3147             log_info (_("Warning: we have yet to see"
3148                         " a message signed using this key and user id!\n"));
3149           else if (signature_count == 1)
3150             log_info (_("Warning: we've only seen one message"
3151                         " signed using this key and user id!\n"));
3152
3153           if (encryption_count == 0)
3154             log_info (_("Warning: you have yet to encrypt"
3155                         " a message to this key!\n"));
3156           else if (encryption_count == 1)
3157             log_info (_("Warning: you have only encrypted"
3158                         " one message to this key!\n"));
3159
3160           /* Cf. write_stats_status  */
3161           if (sqrtu32 (encryption_count * encryption_count
3162                        + signature_count * signature_count)
3163               < 2 * BASIC_TRUST_THRESHOLD)
3164             show_warning = 1;
3165         }
3166     }
3167
3168  out:
3169   xfree (fingerprint_pp);
3170
3171   return show_warning;
3172 }
3173
3174 static void
3175 show_warning (const char *fingerprint, strlist_t user_id_list)
3176 {
3177   char *set_policy_command;
3178   char *text;
3179   char *tmpmsg;
3180
3181   set_policy_command =
3182     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
3183
3184   tmpmsg = xasprintf
3185     (ngettext
3186      ("Warning: if you think you've seen more signatures "
3187       "by this key and user id, then this key might be a "
3188       "forgery!  Carefully examine the email address for small "
3189       "variations.  If the key is suspect, then use\n"
3190       "  %s\n"
3191       "to mark it as being bad.\n",
3192       "Warning: if you think you've seen more signatures "
3193       "by this key and these user ids, then this key might be a "
3194       "forgery!  Carefully examine the email addresses for small "
3195       "variations.  If the key is suspect, then use\n"
3196       "  %s\n"
3197       "to mark it as being bad.\n",
3198       strlist_length (user_id_list)),
3199      set_policy_command);
3200
3201   text = format_text (tmpmsg, 0, 72, 80);
3202   xfree (tmpmsg);
3203   log_string (GPGRT_LOG_INFO, text);
3204   xfree (text);
3205
3206   es_free (set_policy_command);
3207 }
3208
3209
3210 /* Extract the email address from a user id and normalize it.  If the
3211    user id doesn't contain an email address, then we use the whole
3212    user_id and normalize that.  The returned string must be freed.  */
3213 static char *
3214 email_from_user_id (const char *user_id)
3215 {
3216   char *email = mailbox_from_userid (user_id);
3217   if (! email)
3218     {
3219       /* Hmm, no email address was provided or we are out of core.  Just
3220          take the lower-case version of the whole user id.  It could be
3221          a hostname, for instance.  */
3222       email = ascii_strlwr (xstrdup (user_id));
3223     }
3224
3225   return email;
3226 }
3227
3228 /* Register the signature with the bindings <fingerprint, USER_ID>,
3229    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
3230    the primary key packet PK.
3231
3232    SIG_DIGEST_BIN is the binary representation of the message's
3233    digest.  SIG_DIGEST_BIN_LEN is its length.
3234
3235    SIG_TIME is the time that the signature was generated.
3236
3237    ORIGIN is a free-formed string describing the origin of the
3238    signature.  If this was from an email and the Claws MUA was used,
3239    then this should be something like: "email:claws".  If this is
3240    NULL, the default is simply "unknown".
3241
3242    If MAY_ASK is 1, then this function may interact with the user.
3243    This is necessary if there is a conflict or the binding's policy is
3244    TOFU_POLICY_ASK.
3245
3246    This function returns 0 on success and an error code if an error
3247    occurred.  */
3248 gpg_error_t
3249 tofu_register_signature (ctrl_t ctrl,
3250                          PKT_public_key *pk, strlist_t user_id_list,
3251                          const byte *sig_digest_bin, int sig_digest_bin_len,
3252                          time_t sig_time, const char *origin)
3253 {
3254   time_t now = gnupg_get_time ();
3255   gpg_error_t rc;
3256   tofu_dbs_t dbs;
3257   char *fingerprint = NULL;
3258   strlist_t user_id;
3259   char *email = NULL;
3260   char *err = NULL;
3261   char *sig_digest;
3262   unsigned long c;
3263
3264   dbs = opendbs (ctrl);
3265   if (! dbs)
3266     {
3267       rc = gpg_error (GPG_ERR_GENERAL);
3268       log_error (_("error opening TOFU database: %s\n"),
3269                  gpg_strerror (rc));
3270       return rc;
3271     }
3272
3273   /* We do a query and then an insert.  Make sure they are atomic
3274      by wrapping them in a transaction.  */
3275   rc = begin_transaction (ctrl, 0);
3276   if (rc)
3277     return rc;
3278
3279   log_assert (pk_is_primary (pk));
3280
3281   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
3282   fingerprint = hexfingerprint (pk, NULL, 0);
3283
3284   if (! origin)
3285     /* The default origin is simply "unknown".  */
3286     origin = "unknown";
3287
3288   for (user_id = user_id_list; user_id; user_id = user_id->next)
3289     {
3290       email = email_from_user_id (user_id->d);
3291
3292       if (DBG_TRUST)
3293         log_debug ("TOFU: Registering signature %s with binding"
3294                    " <key: %s, user id: %s>\n",
3295                    sig_digest, fingerprint, email);
3296
3297       /* Make sure the binding exists and record any TOFU
3298          conflicts.  */
3299       if (get_trust (ctrl, pk, fingerprint, email, user_id->d, 0, now)
3300           == _tofu_GET_TRUST_ERROR)
3301         {
3302           rc = gpg_error (GPG_ERR_GENERAL);
3303           xfree (email);
3304           break;
3305         }
3306
3307       /* If we've already seen this signature before, then don't add
3308          it again.  */
3309       rc = gpgsql_stepx
3310         (dbs->db, &dbs->s.register_already_seen,
3311          get_single_unsigned_long_cb2, &c, &err,
3312          "select count (*)\n"
3313          " from signatures left join bindings\n"
3314          "  on signatures.binding = bindings.oid\n"
3315          " where fingerprint = ? and email = ? and sig_time = ?\n"
3316          "  and sig_digest = ?",
3317          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3318          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3319          GPGSQL_ARG_STRING, sig_digest,
3320          GPGSQL_ARG_END);
3321       if (rc)
3322         {
3323           log_error (_("error reading TOFU database: %s\n"), err);
3324           print_further_info ("checking existence");
3325           sqlite3_free (err);
3326           rc = gpg_error (GPG_ERR_GENERAL);
3327         }
3328       else if (c > 1)
3329         /* Duplicates!  This should not happen.  In particular,
3330            because <fingerprint, email, sig_time, sig_digest> is the
3331            primary key!  */
3332         log_debug ("SIGNATURES DB contains duplicate records"
3333                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3334                    " origin: %s>."
3335                    "  Please report.\n",
3336                    fingerprint, email, (unsigned long) sig_time,
3337                    sig_digest, origin);
3338       else if (c == 1)
3339         {
3340           if (DBG_TRUST)
3341             log_debug ("Already observed the signature and binding"
3342                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3343                        " origin: %s>\n",
3344                        fingerprint, email, (unsigned long) sig_time,
3345                        sig_digest, origin);
3346         }
3347       else if (opt.dry_run)
3348         {
3349           log_info ("TOFU database update skipped due to --dry-run\n");
3350         }
3351       else
3352         /* This is the first time that we've seen this signature and
3353            binding.  Record it.  */
3354         {
3355           if (DBG_TRUST)
3356             log_debug ("TOFU: Saving signature"
3357                        " <key: %s, user id: %s, sig: %s>\n",
3358                        fingerprint, email, sig_digest);
3359
3360           log_assert (c == 0);
3361
3362           rc = gpgsql_stepx
3363             (dbs->db, &dbs->s.register_signature, NULL, NULL, &err,
3364              "insert into signatures\n"
3365              " (binding, sig_digest, origin, sig_time, time)\n"
3366              " values\n"
3367              " ((select oid from bindings\n"
3368              "    where fingerprint = ? and email = ?),\n"
3369              "  ?, ?, ?, ?);",
3370              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3371              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
3372              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3373              GPGSQL_ARG_LONG_LONG, (long long) now,
3374              GPGSQL_ARG_END);
3375           if (rc)
3376             {
3377               log_error (_("error updating TOFU database: %s\n"), err);
3378               print_further_info ("insert signatures");
3379               sqlite3_free (err);
3380               rc = gpg_error (GPG_ERR_GENERAL);
3381             }
3382         }
3383
3384       xfree (email);
3385
3386       if (rc)
3387         break;
3388     }
3389
3390   if (rc)
3391     rollback_transaction (ctrl);
3392   else
3393     rc = end_transaction (ctrl, 0);
3394
3395   xfree (fingerprint);
3396   xfree (sig_digest);
3397
3398   return rc;
3399 }
3400
3401 gpg_error_t
3402 tofu_register_encryption (ctrl_t ctrl,
3403                           PKT_public_key *pk, strlist_t user_id_list,
3404                           int may_ask)
3405 {
3406   time_t now = gnupg_get_time ();
3407   gpg_error_t rc = 0;
3408   tofu_dbs_t dbs;
3409   kbnode_t kb = NULL;
3410   int free_user_id_list = 0;
3411   char *fingerprint = NULL;
3412   strlist_t user_id;
3413   char *err = NULL;
3414
3415   dbs = opendbs (ctrl);
3416   if (! dbs)
3417     {
3418       rc = gpg_error (GPG_ERR_GENERAL);
3419       log_error (_("error opening TOFU database: %s\n"),
3420                  gpg_strerror (rc));
3421       return rc;
3422     }
3423
3424   if (/* We need the key block to find the primary key.  */
3425       ! pk_is_primary (pk)
3426       /* We need the key block to find all user ids.  */
3427       || ! user_id_list)
3428     kb = get_pubkeyblock (pk->keyid);
3429
3430   /* Make sure PK is a primary key.  */
3431   if (! pk_is_primary (pk))
3432     pk = kb->pkt->pkt.public_key;
3433
3434   if (! user_id_list)
3435     {
3436       /* Use all non-revoked user ids.  Do use expired user ids.  */
3437       kbnode_t n = kb;
3438
3439       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3440         {
3441           PKT_user_id *uid = n->pkt->pkt.user_id;
3442
3443           if (uid->is_revoked)
3444             continue;
3445
3446           add_to_strlist (&user_id_list, uid->name);
3447         }
3448
3449       free_user_id_list = 1;
3450
3451       if (! user_id_list)
3452         log_info (_("WARNING: Encrypting to %s, which has no"
3453                     "non-revoked user ids.\n"),
3454                   keystr (pk->keyid));
3455     }
3456
3457   fingerprint = hexfingerprint (pk, NULL, 0);
3458
3459   tofu_begin_batch_update (ctrl);
3460   tofu_resume_batch_transaction (ctrl);
3461
3462   for (user_id = user_id_list; user_id; user_id = user_id->next)
3463     {
3464       char *email = email_from_user_id (user_id->d);
3465
3466       /* Make sure the binding exists and that we recognize any
3467          conflicts.  */
3468       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3469                           may_ask, now);
3470       if (tl == _tofu_GET_TRUST_ERROR)
3471         {
3472           /* An error.  */
3473           rc = gpg_error (GPG_ERR_GENERAL);
3474           xfree (email);
3475           goto die;
3476         }
3477
3478       rc = gpgsql_stepx
3479         (dbs->db, &dbs->s.register_encryption, NULL, NULL, &err,
3480          "insert into encryptions\n"
3481          " (binding, time)\n"
3482          " values\n"
3483          " ((select oid from bindings\n"
3484          "    where fingerprint = ? and email = ?),\n"
3485          "  ?);",
3486          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3487          GPGSQL_ARG_LONG_LONG, (long long) now,
3488          GPGSQL_ARG_END);
3489       if (rc)
3490         {
3491           log_error (_("error updating TOFU database: %s\n"), err);
3492           print_further_info ("insert encryption");
3493           sqlite3_free (err);
3494           rc = gpg_error (GPG_ERR_GENERAL);
3495         }
3496
3497       xfree (email);
3498     }
3499
3500  die:
3501   tofu_end_batch_update (ctrl);
3502
3503   if (kb)
3504     release_kbnode (kb);
3505
3506   if (free_user_id_list)
3507     free_strlist (user_id_list);
3508
3509   xfree (fingerprint);
3510
3511   return rc;
3512 }
3513
3514
3515 /* Combine a trust level returned from the TOFU trust model with a
3516    trust level returned by the PGP trust model.  This is primarily of
3517    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
3518
3519    This function ors together the upper bits (the values not covered
3520    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
3521 int
3522 tofu_wot_trust_combine (int tofu_base, int wot_base)
3523 {
3524   int tofu = tofu_base & TRUST_MASK;
3525   int wot = wot_base & TRUST_MASK;
3526   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
3527
3528   log_assert (tofu == TRUST_UNKNOWN
3529               || tofu == TRUST_EXPIRED
3530               || tofu == TRUST_UNDEFINED
3531               || tofu == TRUST_NEVER
3532               || tofu == TRUST_MARGINAL
3533               || tofu == TRUST_FULLY
3534               || tofu == TRUST_ULTIMATE);
3535   log_assert (wot == TRUST_UNKNOWN
3536               || wot == TRUST_EXPIRED
3537               || wot == TRUST_UNDEFINED
3538               || wot == TRUST_NEVER
3539               || wot == TRUST_MARGINAL
3540               || wot == TRUST_FULLY
3541               || wot == TRUST_ULTIMATE);
3542
3543   /* We first consider negative trust policys.  These trump positive
3544      trust policies.  */
3545   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
3546     /* TRUST_NEVER trumps everything else.  */
3547     return upper | TRUST_NEVER;
3548   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
3549     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
3550     return upper | TRUST_EXPIRED;
3551
3552   /* Now we only have positive or neutral trust policies.  We take
3553      the max.  */
3554   if (tofu == TRUST_ULTIMATE)
3555     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
3556   if (wot == TRUST_ULTIMATE)
3557     return upper | TRUST_ULTIMATE;
3558
3559   if (tofu == TRUST_FULLY)
3560     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
3561   if (wot == TRUST_FULLY)
3562     return upper | TRUST_FULLY;
3563
3564   if (tofu == TRUST_MARGINAL)
3565     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
3566   if (wot == TRUST_MARGINAL)
3567     return upper | TRUST_MARGINAL;
3568
3569   if (tofu == TRUST_UNDEFINED)
3570     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
3571   if (wot == TRUST_UNDEFINED)
3572     return upper | TRUST_UNDEFINED;
3573
3574   return upper | TRUST_UNKNOWN;
3575 }
3576
3577
3578 /* Write a "tfs" record for a --with-colons listing.  */
3579 gpg_error_t
3580 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
3581                        PKT_public_key *pk, const char *user_id)
3582 {
3583   time_t now = gnupg_get_time ();
3584   gpg_error_t err;
3585   tofu_dbs_t dbs;
3586   char *fingerprint;
3587   char *email;
3588
3589   if (!*user_id)
3590     return 0;  /* No TOFU stats possible for an empty ID.  */
3591
3592   dbs = opendbs (ctrl);
3593   if (!dbs)
3594     {
3595       err = gpg_error (GPG_ERR_GENERAL);
3596       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
3597       return err;
3598     }
3599
3600   fingerprint = hexfingerprint (pk, NULL, 0);
3601   email = email_from_user_id (user_id);
3602
3603   show_statistics (dbs, pk, fingerprint, email, user_id, fp, now);
3604
3605   xfree (email);
3606   xfree (fingerprint);
3607   return 0;
3608 }
3609
3610
3611 /* Return the validity (TRUST_NEVER, etc.) of the bindings
3612    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
3613    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
3614
3615    PK is the primary key packet.
3616
3617    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
3618    will be prompted to choose a policy.  If MAY_ASK is 0 and the
3619    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
3620
3621    Returns TRUST_UNDEFINED if an error occurs.  */
3622 int
3623 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
3624                    int may_ask)
3625 {
3626   time_t now = gnupg_get_time ();
3627   tofu_dbs_t dbs;
3628   char *fingerprint = NULL;
3629   strlist_t user_id;
3630   int trust_level = TRUST_UNKNOWN;
3631   int bindings = 0;
3632   int bindings_valid = 0;
3633   int need_warning = 0;
3634
3635   dbs = opendbs (ctrl);
3636   if (! dbs)
3637     {
3638       log_error (_("error opening TOFU database: %s\n"),
3639                  gpg_strerror (GPG_ERR_GENERAL));
3640       return TRUST_UNDEFINED;
3641     }
3642
3643   fingerprint = hexfingerprint (pk, NULL, 0);
3644
3645   tofu_begin_batch_update (ctrl);
3646   /* Start the batch transaction now.  */
3647   tofu_resume_batch_transaction (ctrl);
3648
3649   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
3650     {
3651       char *email = email_from_user_id (user_id->d);
3652
3653       /* Always call get_trust to make sure the binding is
3654          registered.  */
3655       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3656                           may_ask, now);
3657       if (tl == _tofu_GET_TRUST_ERROR)
3658         {
3659           /* An error.  */
3660           trust_level = TRUST_UNDEFINED;
3661           xfree (email);
3662           goto die;
3663         }
3664
3665       if (DBG_TRUST)
3666         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
3667                    fingerprint, email,
3668                    trust_value_to_string (tl),
3669                    user_id->flags ? " (but expired)" : "");
3670
3671       if (user_id->flags)
3672         tl = TRUST_EXPIRED;
3673
3674       if (tl != TRUST_EXPIRED)
3675         bindings_valid ++;
3676
3677       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
3678         need_warning |=
3679           show_statistics (dbs, pk, fingerprint, email, user_id->d, NULL, now);
3680
3681       if (tl == TRUST_NEVER)
3682         trust_level = TRUST_NEVER;
3683       else if (tl == TRUST_EXPIRED)
3684         /* Ignore expired bindings in the trust calculation.  */
3685         ;
3686       else if (tl > trust_level)
3687         {
3688           /* The expected values: */
3689           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
3690                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
3691                       || tl == TRUST_ULTIMATE);
3692
3693           /* We assume the following ordering:  */
3694           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
3695           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
3696           log_assert (TRUST_MARGINAL < TRUST_FULLY);
3697           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
3698
3699           trust_level = tl;
3700         }
3701
3702       xfree (email);
3703     }
3704
3705   if (need_warning)
3706     show_warning (fingerprint, user_id_list);
3707
3708  die:
3709   tofu_end_batch_update (ctrl);
3710
3711   xfree (fingerprint);
3712
3713   if (bindings_valid == 0)
3714     {
3715       if (DBG_TRUST)
3716         log_debug ("no (of %d) valid bindings."
3717                    "  Can't get TOFU validity for this set of user ids.\n",
3718                    bindings);
3719       return TRUST_NEVER;
3720     }
3721
3722   return trust_level;
3723 }
3724
3725 /* Set the policy for all non-revoked user ids in the keyblock KB to
3726    POLICY.
3727
3728    If no key is available with the specified key id, then this
3729    function returns GPG_ERR_NO_PUBKEY.
3730
3731    Returns 0 on success and an error code otherwise.  */
3732 gpg_error_t
3733 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
3734 {
3735   gpg_error_t err;
3736   time_t now = gnupg_get_time ();
3737   tofu_dbs_t dbs;
3738   PKT_public_key *pk;
3739   char *fingerprint = NULL;
3740
3741   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
3742   pk = kb->pkt->pkt.public_key;
3743
3744   dbs = opendbs (ctrl);
3745   if (! dbs)
3746     {
3747       log_error (_("error opening TOFU database: %s\n"),
3748                  gpg_strerror (GPG_ERR_GENERAL));
3749       return gpg_error (GPG_ERR_GENERAL);
3750     }
3751
3752   if (DBG_TRUST)
3753     log_debug ("Setting TOFU policy for %s to %s\n",
3754                keystr (pk->keyid), tofu_policy_str (policy));
3755   if (! pk_is_primary (pk))
3756     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
3757
3758   fingerprint = hexfingerprint (pk, NULL, 0);
3759
3760   begin_transaction (ctrl, 0);
3761
3762   for (; kb; kb = kb->next)
3763     {
3764       PKT_user_id *user_id;
3765       char *email;
3766
3767       if (kb->pkt->pkttype != PKT_USER_ID)
3768         continue;
3769
3770       user_id = kb->pkt->pkt.user_id;
3771       if (user_id->is_revoked)
3772         /* Skip revoked user ids.  (Don't skip expired user ids, the
3773            expiry can be changed.)  */
3774         continue;
3775
3776       email = email_from_user_id (user_id->name);
3777
3778       err = record_binding (dbs, fingerprint, email, user_id->name,
3779                             policy, TOFU_POLICY_NONE, NULL, 0, 1, now);
3780       if (err)
3781         {
3782           log_error (_("error setting policy for key %s, user id \"%s\": %s"),
3783                      fingerprint, email, gpg_strerror (err));
3784           xfree (email);
3785           break;
3786         }
3787
3788       xfree (email);
3789     }
3790
3791   if (err)
3792     rollback_transaction (ctrl);
3793   else
3794     end_transaction (ctrl, 0);
3795
3796   xfree (fingerprint);
3797   return err;
3798 }
3799
3800 /* Set the TOFU policy for all non-revoked user ids in the KEY with
3801    the key id KEYID to POLICY.
3802
3803    If no key is available with the specified key id, then this
3804    function returns GPG_ERR_NO_PUBKEY.
3805
3806    Returns 0 on success and an error code otherwise.  */
3807 gpg_error_t
3808 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
3809 {
3810   kbnode_t keyblock = get_pubkeyblock (keyid);
3811   if (! keyblock)
3812     return gpg_error (GPG_ERR_NO_PUBKEY);
3813
3814   return tofu_set_policy (ctrl, keyblock, policy);
3815 }
3816
3817 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3818    policy has been set for the binding, sets *POLICY to
3819    TOFU_POLICY_NONE.
3820
3821    PK is a primary public key and USER_ID is a user id.
3822
3823    Returns 0 on success and an error code otherwise.  */
3824 gpg_error_t
3825 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3826                  enum tofu_policy *policy)
3827 {
3828   time_t now = gnupg_get_time ();
3829   tofu_dbs_t dbs;
3830   char *fingerprint;
3831   char *email;
3832
3833   /* Make sure PK is a primary key.  */
3834   log_assert (pk_is_primary (pk));
3835
3836   dbs = opendbs (ctrl);
3837   if (! dbs)
3838     {
3839       log_error (_("error opening TOFU database: %s\n"),
3840                  gpg_strerror (GPG_ERR_GENERAL));
3841       return gpg_error (GPG_ERR_GENERAL);
3842     }
3843
3844   fingerprint = hexfingerprint (pk, NULL, 0);
3845
3846   email = email_from_user_id (user_id->name);
3847
3848   *policy = get_policy (dbs, pk, fingerprint, user_id->name, email, NULL, now);
3849
3850   xfree (email);
3851   xfree (fingerprint);
3852   if (*policy == _tofu_GET_POLICY_ERROR)
3853     return gpg_error (GPG_ERR_GENERAL);
3854   return 0;
3855 }
3856
3857 gpg_error_t
3858 tofu_notice_key_changed (ctrl_t ctrl, kbnode_t kb)
3859 {
3860   tofu_dbs_t dbs;
3861   PKT_public_key *pk;
3862   char *fingerprint;
3863   char *sqlerr = NULL;
3864   int rc;
3865
3866   /* Make sure PK is a primary key.  */
3867   setup_main_keyids (kb);
3868   pk = kb->pkt->pkt.public_key;
3869   log_assert (pk_is_primary (pk));
3870
3871   dbs = opendbs (ctrl);
3872   if (! dbs)
3873     {
3874       log_error (_("error opening TOFU database: %s\n"),
3875                  gpg_strerror (GPG_ERR_GENERAL));
3876       return gpg_error (GPG_ERR_GENERAL);
3877     }
3878
3879   fingerprint = hexfingerprint (pk, NULL, 0);
3880
3881   rc = gpgsql_stepx (dbs->db, NULL, NULL, NULL, &sqlerr,
3882                      "update bindings set effective_policy = ?"
3883                      " where fingerprint = ?;",
3884                      GPGSQL_ARG_INT, (int) TOFU_POLICY_NONE,
3885                      GPGSQL_ARG_STRING, fingerprint,
3886                      GPGSQL_ARG_END);
3887   xfree (fingerprint);
3888
3889   if (rc == _tofu_GET_POLICY_ERROR)
3890     return gpg_error (GPG_ERR_GENERAL);
3891   return 0;
3892 }