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