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