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