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