gpg: Change TOFU_STATS to return timestamps.
[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 <http://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
32 #include "gpg.h"
33 #include "types.h"
34 #include "logging.h"
35 #include "stringhelp.h"
36 #include "options.h"
37 #include "mbox-util.h"
38 #include "i18n.h"
39 #include "ttyio.h"
40 #include "trustdb.h"
41 #include "mkdir_p.h"
42 #include "gpgsql.h"
43 #include "status.h"
44
45 #include "tofu.h"
46
47
48 #define CONTROL_L ('L' - 'A' + 1)
49
50 /* Number of signed messages required to indicate that enough history
51  * is available for basic trust.  */
52 #define BASIC_TRUST_THRESHOLD  10
53 /* Number of signed messages required to indicate that a lot of
54  * history is available.  */
55 #define FULL_TRUST_THRESHOLD  100
56
57
58 /* An struct with data pertaining to the tofu DB.
59
60    To initialize this data structure, call opendbs().  Cleanup is done
61    when the CTRL object is released.  To get a handle to a database,
62    use the getdb() function.  This will either return an existing
63    handle or open a new DB connection, as appropriate.  */
64 struct tofu_dbs_s
65 {
66   sqlite3 *db;
67
68   struct
69   {
70     sqlite3_stmt *savepoint_batch;
71     sqlite3_stmt *savepoint_batch_commit;
72
73     sqlite3_stmt *savepoint_inner;
74     sqlite3_stmt *savepoint_inner_commit;
75
76     sqlite3_stmt *record_binding_get_old_policy;
77     sqlite3_stmt *record_binding_update;
78     sqlite3_stmt *record_binding_update2;
79     sqlite3_stmt *get_policy_select_policy_and_conflict;
80     sqlite3_stmt *get_trust_bindings_with_this_email;
81     sqlite3_stmt *get_trust_gather_other_user_ids;
82     sqlite3_stmt *get_trust_gather_other_keys;
83     sqlite3_stmt *register_already_seen;
84     sqlite3_stmt *register_insert;
85   } s;
86
87   int batch_update;
88 };
89
90
91 #define STRINGIFY(s) STRINGIFY2(s)
92 #define STRINGIFY2(s) #s
93
94 /* The grouping parameters when collecting signature statistics.  */
95
96 /* If a message is signed a couple of hours in the future, just assume
97    some clock skew.  */
98 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
99 #if 0
100 #  define TIME_AGO_UNIT_SMALL 60
101 #  define TIME_AGO_MEDIUM_THRESHOLD (60 * TIME_AGO_UNIT_SMALL)
102 #  define TIME_AGO_UNIT_MEDIUM (60 * 60)
103 #  define TIME_AGO_LARGE_THRESHOLD (24 * 60 * TIME_AGO_UNIT_SMALL)
104 #  define TIME_AGO_UNIT_LARGE (24 * 60 * 60)
105 #else
106 #  define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
107 #  define TIME_AGO_MEDIUM_THRESHOLD (4 * TIME_AGO_UNIT_SMALL)
108 #  define TIME_AGO_UNIT_MEDIUM (7 * 24 * 60 * 60)
109 #  define TIME_AGO_LARGE_THRESHOLD (28 * TIME_AGO_UNIT_SMALL)
110 #  define TIME_AGO_UNIT_LARGE (30 * 24 * 60 * 60)
111 #endif
112
113 /* Local prototypes.  */
114 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
115
116
117 \f
118 const char *
119 tofu_policy_str (enum tofu_policy policy)
120 {
121   switch (policy)
122     {
123     case TOFU_POLICY_NONE: return "none";
124     case TOFU_POLICY_AUTO: return "auto";
125     case TOFU_POLICY_GOOD: return "good";
126     case TOFU_POLICY_UNKNOWN: return "unknown";
127     case TOFU_POLICY_BAD: return "bad";
128     case TOFU_POLICY_ASK: return "ask";
129     default: return "???";
130     }
131 }
132
133 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
134    (e.g., TRUST_BAD) in light of the current configuration.  */
135 int
136 tofu_policy_to_trust_level (enum tofu_policy policy)
137 {
138   if (policy == TOFU_POLICY_AUTO)
139     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
140     policy = opt.tofu_default_policy;
141
142   switch (policy)
143     {
144     case TOFU_POLICY_AUTO:
145       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
146          to marginal trust.  */
147       return TRUST_MARGINAL;
148     case TOFU_POLICY_GOOD:
149       return TRUST_FULLY;
150     case TOFU_POLICY_UNKNOWN:
151       return TRUST_UNKNOWN;
152     case TOFU_POLICY_BAD:
153       return TRUST_NEVER;
154     case TOFU_POLICY_ASK:
155       return TRUST_UNKNOWN;
156     default:
157       log_bug ("Bad value for trust policy: %d\n",
158                opt.tofu_default_policy);
159       return 0;
160     }
161 }
162
163
164 \f
165 /* Start a transaction on DB.  */
166 static gpg_error_t
167 begin_transaction (ctrl_t ctrl, int only_batch)
168 {
169   tofu_dbs_t dbs = ctrl->tofu.dbs;
170   int rc;
171   char *err = NULL;
172
173   log_assert (dbs);
174
175   if (ctrl->tofu.batch_update_ref
176       && ctrl->tofu.batch_update_started != gnupg_get_time ())
177     {
178       /* We've been in batch update mode for a while (on average, more
179        * than 500 ms).  To prevent starving other gpg processes, we
180        * drop and retake the batch lock.
181        *
182        * Note: if we wanted higher resolution, we could use
183        * npth_clock_gettime.  */
184       if (dbs->batch_update)
185         end_transaction (ctrl, 1);
186
187       ctrl->tofu.batch_update_started = gnupg_get_time ();
188
189       /* Yield to allow another process a chance to run.  */
190       gpgrt_yield ();
191     }
192
193   if (ctrl->tofu.batch_update_ref && !dbs->batch_update)
194     {
195       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
196                           NULL, NULL, &err,
197                           "savepoint batch;", SQLITE_ARG_END);
198       if (rc)
199         {
200           log_error (_("error beginning transaction on TOFU database: %s\n"),
201                      err);
202           sqlite3_free (err);
203           return gpg_error (GPG_ERR_GENERAL);
204         }
205
206       dbs->batch_update = 1;
207     }
208
209   if (only_batch)
210     return 0;
211
212   rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_inner,
213                       NULL, NULL, &err,
214                       "savepoint inner;", SQLITE_ARG_END);
215   if (rc)
216     {
217       log_error (_("error beginning transaction on TOFU database: %s\n"),
218                  err);
219       sqlite3_free (err);
220       return gpg_error (GPG_ERR_GENERAL);
221     }
222
223   return 0;
224 }
225
226
227 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
228  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
229  * this ends any open batch transaction even if we are still in batch
230  * mode.  */
231 static gpg_error_t
232 end_transaction (ctrl_t ctrl, int only_batch)
233 {
234   tofu_dbs_t dbs = ctrl->tofu.dbs;
235   int rc;
236   char *err = NULL;
237
238   if (!dbs)
239     return 0;  /* Shortcut to allow for easier cleanup code.  */
240
241   if ((!ctrl->tofu.batch_update_ref || only_batch == 2) && dbs->batch_update)
242     {
243       /* The batch transaction is still in open, but we left batch
244        * mode.  */
245       dbs->batch_update = 0;
246
247       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
248                           NULL, NULL, &err,
249                           "release batch;", SQLITE_ARG_END);
250       if (rc)
251         {
252           log_error (_("error committing transaction on TOFU database: %s\n"),
253                      err);
254           sqlite3_free (err);
255           return gpg_error (GPG_ERR_GENERAL);
256         }
257
258       /* Releasing an outer transaction releases an open inner
259          transactions.  We're done.  */
260       return 0;
261     }
262
263   if (only_batch)
264     return 0;
265
266   rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_inner_commit,
267                       NULL, NULL, &err,
268                       "release inner;", SQLITE_ARG_END);
269   if (rc)
270     {
271       log_error (_("error committing transaction on TOFU database: %s\n"),
272                  err);
273       sqlite3_free (err);
274       return gpg_error (GPG_ERR_GENERAL);
275     }
276
277   return 0;
278 }
279
280
281 static gpg_error_t
282 rollback_transaction (ctrl_t ctrl)
283 {
284   tofu_dbs_t dbs = ctrl->tofu.dbs;
285   int rc;
286   char *err = NULL;
287
288   if (!dbs)
289     return 0;  /* Shortcut to allow for easier cleanup code.  */
290
291   if (dbs->batch_update)
292     {
293       /* Just undo the most recent update; don't revert any progress
294          made by the batch transaction.  */
295       rc = sqlite3_exec (dbs->db, "rollback to inner;", NULL, NULL, &err);
296     }
297   else
298     {
299       /* Rollback the whole she-bang.  */
300       rc = sqlite3_exec (dbs->db, "rollback;", NULL, NULL, &err);
301     }
302
303   if (rc)
304     {
305       log_error (_("error rolling back transaction on TOFU database: %s\n"),
306                  err);
307       sqlite3_free (err);
308       return gpg_error (GPG_ERR_GENERAL);
309     }
310
311   return 0;
312 }
313
314 void
315 tofu_begin_batch_update (ctrl_t ctrl)
316 {
317   if (!ctrl->tofu.batch_update_ref)
318     ctrl->tofu.batch_update_started = gnupg_get_time ();
319
320   ctrl->tofu.batch_update_ref ++;
321 }
322
323 void
324 tofu_end_batch_update (ctrl_t ctrl)
325 {
326   log_assert (ctrl->tofu.batch_update_ref > 0);
327   ctrl->tofu.batch_update_ref --;
328
329   if (!ctrl->tofu.batch_update_ref)
330     end_transaction (ctrl, 1);
331 }
332
333
334
335 \f
336 /* Wrapper around strtol which prints a warning in case of a
337  * conversion error.  On success the converted value is stored at
338  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
339  * and an error code is returned.  */
340 static gpg_error_t
341 string_to_long (long *r_value, const char *string, long fallback, int line)
342 {
343   gpg_error_t err;
344   char *tail = NULL;
345
346   gpg_err_set_errno (0);
347   *r_value = strtol (string, &tail, 0);
348   if (errno || !(!strcmp (tail, ".0") || !*tail))
349     {
350       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
351       log_debug ("%s:%d: "
352                  "strtol failed for DB returned string (tail=%.10s): %s\n",
353                  __FILE__, line, tail, gpg_strerror (err));
354       *r_value = fallback;
355     }
356   else
357     err = 0;
358
359   return err;
360 }
361
362
363 /* Wrapper around strtoul which prints a warning in case of a
364  * conversion error.  On success the converted value is stored at
365  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
366  * and an error code is returned.  */
367 static gpg_error_t
368 string_to_ulong (unsigned long *r_value, const char *string,
369                  unsigned long fallback, int line)
370 {
371   gpg_error_t err;
372   char *tail = NULL;
373
374   gpg_err_set_errno (0);
375   *r_value = strtoul (string, &tail, 0);
376   if (errno || !(!strcmp (tail, ".0") || !*tail))
377     {
378       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
379       log_debug ("%s:%d: "
380                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
381                  __FILE__, line, tail, gpg_strerror (err));
382       *r_value = fallback;
383     }
384   else
385     err = 0;
386
387   return err;
388 }
389
390
391
392 /* Collect results of a select count (*) ...; style query.  Aborts if
393    the argument is not a valid integer (or real of the form X.0).  */
394 static int
395 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
396                              char **azColName)
397 {
398   unsigned long int *count = cookie;
399
400   (void) azColName;
401
402   log_assert (argc == 1);
403
404   if (string_to_ulong (count, argv[0], 0, __LINE__))
405     return 1; /* Abort.  */
406   return 0;
407 }
408
409 static int
410 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
411                              char **azColName, sqlite3_stmt *stmt)
412 {
413   (void) stmt;
414   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
415 }
416
417 /* We expect a single integer column whose name is "version".  COOKIE
418    must point to an int.  This function always aborts.  On error or a
419    if the version is bad, sets *VERSION to -1.  */
420 static int
421 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
422 {
423   int *version = cookie;
424
425   if (argc != 1 || strcmp (azColName[0], "version") != 0)
426     {
427       *version = -1;
428       return 1;
429     }
430
431   if (strcmp (argv[0], "1") == 0)
432     *version = 1;
433   else
434     {
435       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
436       *version = -1;
437     }
438
439   /* Don't run again.  */
440   return 1;
441 }
442
443
444 /* If the DB is new, initialize it.  Otherwise, check the DB's
445    version.
446
447    Return 0 if the database is okay and 1 otherwise.  */
448 static int
449 initdb (sqlite3 *db)
450 {
451   char *err = NULL;
452   int rc;
453   unsigned long int count;
454   int version = -1;
455
456   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
457   if (rc)
458     {
459       log_error (_("error beginning transaction on TOFU database: %s\n"),
460                  err);
461       sqlite3_free (err);
462       return 1;
463     }
464
465   /* If the DB has no tables, then assume this is a new DB that needs
466      to be initialized.  */
467   rc = sqlite3_exec (db,
468                      "select count(*) from sqlite_master where type='table';",
469                      get_single_unsigned_long_cb, &count, &err);
470   if (rc)
471     {
472       log_error (_("error reading TOFU database: %s\n"), err);
473       print_further_info ("query available tables");
474       sqlite3_free (err);
475       goto out;
476     }
477   else if (count != 0)
478     /* Assume that the DB is already initialized.  Make sure the
479        version is okay.  */
480     {
481       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
482                          &version, &err);
483       if (rc == SQLITE_ABORT && version == 1)
484         /* Happy, happy, joy, joy.  */
485         {
486           sqlite3_free (err);
487           rc = 0;
488           goto out;
489         }
490       else if (rc == SQLITE_ABORT && version == -1)
491         /* Unsupported version.  */
492         {
493           /* An error message was already displayed.  */
494           sqlite3_free (err);
495           goto out;
496         }
497       else if (rc)
498         /* Some error.  */
499         {
500           log_error (_("error determining TOFU database's version: %s\n"), err);
501           sqlite3_free (err);
502           goto out;
503         }
504       else
505         {
506           /* Unexpected success.  This can only happen if there are no
507              rows.  (select returned 0, but expected ABORT.)  */
508           log_error (_("error determining TOFU database's version: %s\n"),
509                      gpg_strerror (GPG_ERR_NO_DATA));
510           rc = 1;
511           goto out;
512         }
513     }
514
515   /* Create the version table.  */
516   rc = sqlite3_exec (db,
517                      "create table version (version INTEGER);",
518                      NULL, NULL, &err);
519   if (rc)
520     {
521       log_error (_("error initializing TOFU database: %s\n"), err);
522       print_further_info ("create version");
523       sqlite3_free (err);
524       goto out;
525     }
526
527   /* Initialize the version table, which contains a single integer
528      value.  */
529   rc = sqlite3_exec (db,
530                      "insert into version values (1);",
531                      NULL, NULL, &err);
532   if (rc)
533     {
534       log_error (_("error initializing TOFU database: %s\n"), err);
535       print_further_info ("insert version");
536       sqlite3_free (err);
537       goto out;
538     }
539
540   /* The list of <fingerprint, email> bindings and auxiliary data.
541    *
542    *  OID is a unique ID identifying this binding (and used by the
543    *    signatures table, see below).  Note: OIDs will never be
544    *    reused.
545    *
546    *  FINGERPRINT: The key's fingerprint.
547    *
548    *  EMAIL: The normalized email address.
549    *
550    *  USER_ID: The unmodified user id from which EMAIL was extracted.
551    *
552    *  TIME: The time this binding was first observed.
553    *
554    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
555    *
556    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
557    *    a binding <0xdeadbeef, foo@example.com> and then we observe
558    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
559    *    (they have the same email address).  When we observe the
560    *    latter binding, we warn the user about the conflict and ask
561    *    for a policy decision about the new binding.  We also change
562    *    the old binding's policy to ask if it was auto.  So that we
563    *     know why this occurred, we also set conflict to 0xbaddecaf.
564    */
565   rc = gpgsql_exec_printf
566       (db, NULL, NULL, &err,
567        "create table bindings\n"
568        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
569        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
570        "  policy BOOLEAN CHECK (policy in (%d, %d, %d, %d, %d)),\n"
571        "  conflict STRING,\n"
572        "  unique (fingerprint, email));\n"
573        "create index bindings_fingerprint_email\n"
574        " on bindings (fingerprint, email);\n"
575        "create index bindings_email on bindings (email);\n",
576        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
577        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
578   if (rc)
579     {
580       log_error (_("error initializing TOFU database: %s\n"), err);
581       print_further_info ("create bindings");
582       sqlite3_free (err);
583       goto out;
584     }
585
586   /* The signatures that we have observed.
587    *
588    * BINDING refers to a record in the bindings table, which
589    * describes the binding (i.e., this is a foreign key that
590    * references bindings.oid).
591    *
592    * SIG_DIGEST is the digest stored in the signature.
593    *
594    * SIG_TIME is the timestamp stored in the signature.
595    *
596    * ORIGIN is a free-form string that describes who fed this
597    * signature to GnuPG (e.g., email:claws).
598    *
599    * TIME is the time this signature was registered.  */
600   rc = sqlite3_exec (db,
601                          "create table signatures "
602                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
603                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
604                          "  primary key (binding, sig_digest, origin));",
605                          NULL, NULL, &err);
606   if (rc)
607     {
608       log_error (_("error initializing TOFU database: %s\n"), err);
609       print_further_info ("create signatures");
610       sqlite3_free (err);
611       goto out;
612     }
613
614  out:
615   if (rc)
616     {
617       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
618       if (rc)
619         {
620           log_error (_("error rolling back transaction on TOFU database: %s\n"),
621                      err);
622           sqlite3_free (err);
623         }
624       return 1;
625     }
626   else
627     {
628       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
629       if (rc)
630         {
631           log_error (_("error committing transaction on TOFU database: %s\n"),
632                      err);
633           sqlite3_free (err);
634           return 1;
635         }
636       return 0;
637     }
638 }
639
640
641 /* Create a new DB handle.  Returns NULL on error.  */
642 /* FIXME: Change to return an error code for better reporting by the
643    caller.  */
644 static tofu_dbs_t
645 opendbs (ctrl_t ctrl)
646 {
647   char *filename;
648   sqlite3 *db;
649   int rc;
650
651   if (!ctrl->tofu.dbs)
652     {
653       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
654
655       rc = sqlite3_open (filename, &db);
656       if (rc)
657         {
658           log_error (_("error opening TOFU database '%s': %s\n"),
659                      filename, sqlite3_errmsg (db));
660           /* Even if an error occurs, DB is guaranteed to be valid.  */
661           sqlite3_close (db);
662           db = NULL;
663         }
664       xfree (filename);
665
666       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
667          before failing.  */
668       if (db)
669         sqlite3_busy_timeout (db, 5 * 1000);
670
671       if (db && initdb (db))
672         {
673           sqlite3_close (db);
674           db = NULL;
675         }
676
677       if (db)
678         {
679           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
680           ctrl->tofu.dbs->db = db;
681         }
682     }
683   else
684     log_assert (ctrl->tofu.dbs->db);
685
686   return ctrl->tofu.dbs;
687 }
688
689
690 /* Release all of the resources associated with the DB handle.  */
691 void
692 tofu_closedbs (ctrl_t ctrl)
693 {
694   tofu_dbs_t dbs;
695   sqlite3_stmt **statements;
696
697   dbs = ctrl->tofu.dbs;
698   if (!dbs)
699     return;  /* Not initialized.  */
700
701   if (dbs->batch_update)
702     end_transaction (ctrl, 2);
703
704   /* Arghh, that is asurprising use of the struct.  */
705   for (statements = (void *) &dbs->s;
706        (void *) statements < (void *) &(&dbs->s)[1];
707        statements ++)
708     sqlite3_finalize (*statements);
709
710   sqlite3_close (dbs->db);
711   xfree (dbs);
712   ctrl->tofu.dbs = NULL;
713 }
714
715
716 /* Collect results of a select min (foo) ...; style query.  Aborts if
717    the argument is not a valid integer (or real of the form X.0).  */
718 static int
719 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
720 {
721   long *count = cookie;
722
723   (void) azColName;
724
725   log_assert (argc == 1);
726
727   if (string_to_long (count, argv[0], 0, __LINE__))
728     return 1; /* Abort.  */
729
730   return 0;
731 }
732
733 static int
734 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
735                      sqlite3_stmt *stmt)
736 {
737   (void) stmt;
738   return get_single_long_cb (cookie, argc, argv, azColName);
739 }
740
741 /* Record (or update) a trust policy about a (possibly new)
742    binding.
743
744    If SHOW_OLD is set, the binding's old policy is displayed.  */
745 static gpg_error_t
746 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
747                 const char *user_id, enum tofu_policy policy, int show_old)
748 {
749   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
750   gpg_error_t rc;
751   char *err = NULL;
752   /* policy_old needs to be a long and not an enum tofu_policy,
753      because we pass it by reference to get_single_long_cb2, which
754      expects a long.  */
755   long policy_old = TOFU_POLICY_NONE;
756
757   if (! (policy == TOFU_POLICY_AUTO
758          || policy == TOFU_POLICY_GOOD
759          || policy == TOFU_POLICY_UNKNOWN
760          || policy == TOFU_POLICY_BAD
761          || policy == TOFU_POLICY_ASK))
762     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
763
764
765   if (show_old)
766     {
767       /* Get the old policy.  Since this is just for informational
768        * purposes, there is no need to start a transaction or to die
769        * if there is a failure.  */
770       rc = gpgsql_stepx
771         (dbs->db, &dbs->s.record_binding_get_old_policy,
772          get_single_long_cb2, &policy_old, &err,
773          "select policy from bindings where fingerprint = ? and email = ?",
774          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
775          SQLITE_ARG_END);
776       if (rc)
777         {
778           log_debug ("TOFU: Error reading from binding database"
779                      " (reading policy for <%s, %s>): %s\n",
780                      fingerprint, email, err);
781           sqlite3_free (err);
782         }
783     }
784
785   if (DBG_TRUST)
786     {
787       if (policy_old != TOFU_POLICY_NONE)
788         log_debug ("Changing TOFU trust policy for binding <%s, %s>"
789                    " from %s to %s.\n",
790                    fingerprint, email,
791                    tofu_policy_str (policy_old),
792                    tofu_policy_str (policy));
793       else
794         log_debug ("Set TOFU trust policy for binding <%s, %s> to %s.\n",
795                    fingerprint, email,
796                    tofu_policy_str (policy));
797     }
798
799   if (policy_old == policy)
800     {
801       rc = 0;
802       goto leave; /* Nothing to do.  */
803     }
804
805   if (opt.dry_run)
806     {
807       log_info ("TOFU database update skipped due to --dry-run\n");
808       rc = 0;
809       goto leave;
810     }
811
812   rc = gpgsql_stepx
813     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
814      "insert or replace into bindings\n"
815      " (oid, fingerprint, email, user_id, time, policy)\n"
816      " values (\n"
817      /* If we don't explicitly reuse the OID, then SQLite will
818         reallocate a new one.  We just need to search for the OID
819         based on the fingerprint and email since they are unique.  */
820      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
821      "  ?, ?, ?, strftime('%s','now'), ?);",
822      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
823      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
824      SQLITE_ARG_STRING, user_id, SQLITE_ARG_INT, (int) policy,
825      SQLITE_ARG_END);
826   if (rc)
827     {
828       log_error (_("error updating TOFU database: %s\n"), err);
829       print_further_info (" insert bindings <%s, %s> = %s",
830                           fingerprint, email, tofu_policy_str (policy));
831       sqlite3_free (err);
832       goto leave;
833     }
834
835  leave:
836   xfree (fingerprint_pp);
837   return rc;
838 }
839
840
841 /* Collect the strings returned by a query in a simply string list.
842    Any NULL values are converted to the empty string.
843
844    If a result has 3 rows and each row contains two columns, then the
845    results are added to the list as follows (the value is parentheses
846    is the 1-based index in the final list):
847
848      row 1, col 2 (6)
849      row 1, col 1 (5)
850      row 2, col 2 (4)
851      row 2, col 1 (3)
852      row 3, col 2 (2)
853      row 3, col 1 (1)
854
855    This is because add_to_strlist pushes the results onto the front of
856    the list.  The end result is that the rows are backwards, but the
857    columns are in the expected order.  */
858 static int
859 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
860 {
861   int i;
862   strlist_t *strlist = cookie;
863
864   (void) azColName;
865
866   for (i = argc - 1; i >= 0; i --)
867     add_to_strlist (strlist, argv[i] ? argv[i] : "");
868
869   return 0;
870 }
871
872 static int
873 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
874                      sqlite3_stmt *stmt)
875 {
876   (void) stmt;
877   return strings_collect_cb (cookie, argc, argv, azColName);
878
879 }
880
881 /* Auxiliary data structure to collect statistics about
882    signatures.  */
883 struct signature_stats
884 {
885   struct signature_stats *next;
886
887   /* The user-assigned policy for this binding.  */
888   enum tofu_policy policy;
889
890   /* How long ago the signature was created (rounded to a multiple of
891      TIME_AGO_UNIT_SMALL, etc.).  */
892   long time_ago;
893   /* Number of signatures during this time.  */
894   unsigned long count;
895
896   /* The key that generated this signature.  */
897   char fingerprint[1];
898 };
899
900 static void
901 signature_stats_free (struct signature_stats *stats)
902 {
903   while (stats)
904     {
905       struct signature_stats *next = stats->next;
906       xfree (stats);
907       stats = next;
908     }
909 }
910
911 static void
912 signature_stats_prepend (struct signature_stats **statsp,
913                          const char *fingerprint,
914                          enum tofu_policy policy,
915                          long time_ago,
916                          unsigned long count)
917 {
918   struct signature_stats *stats =
919     xmalloc (sizeof (*stats) + strlen (fingerprint));
920
921   stats->next = *statsp;
922   *statsp = stats;
923
924   strcpy (stats->fingerprint, fingerprint);
925   stats->policy = policy;
926   stats->time_ago = time_ago;
927   stats->count = count;
928 }
929
930
931 /* Process rows that contain the four columns:
932
933      <fingerprint, policy, time ago, count>.  */
934 static int
935 signature_stats_collect_cb (void *cookie, int argc, char **argv,
936                             char **azColName, sqlite3_stmt *stmt)
937 {
938   struct signature_stats **statsp = cookie;
939   int i = 0;
940   enum tofu_policy policy;
941   long time_ago;
942   unsigned long count;
943   long along;
944
945   (void) azColName;
946   (void) stmt;
947
948   i ++;
949
950   if (string_to_long (&along, argv[i], 0, __LINE__))
951     return 1;  /* Abort */
952   policy = along;
953   i ++;
954
955   if (! argv[i])
956     time_ago = 0;
957   else
958     {
959       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
960         return 1; /* Abort.  */
961     }
962   i ++;
963
964   /* If time_ago is NULL, then we had no messages, but we still have a
965      single row, which count(*) turns into 1.  */
966   if (! argv[i - 1])
967     count = 0;
968   else
969     {
970       if (string_to_ulong (&count, argv[i], 0, __LINE__))
971         return 1; /* Abort */
972     }
973   i ++;
974
975   log_assert (argc == i);
976
977   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
978
979   return 0;
980 }
981
982 /* Convert from seconds to time units.
983
984    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
985    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
986 signed long
987 time_ago_scale (signed long t)
988 {
989   if (t < TIME_AGO_UNIT_MEDIUM)
990     return t / TIME_AGO_UNIT_SMALL;
991   if (t < TIME_AGO_UNIT_LARGE)
992     return t / TIME_AGO_UNIT_MEDIUM;
993   return t / TIME_AGO_UNIT_LARGE;
994 }
995
996
997 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
998    already been normalized) and any conflict information in *CONFLICT
999    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1000    occurs.  */
1001 static enum tofu_policy
1002 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1003             char **conflict)
1004 {
1005   int rc;
1006   char *err = NULL;
1007   strlist_t strlist = NULL;
1008   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1009   long along;
1010
1011   /* Check if the <FINGERPRINT, EMAIL> binding is known
1012      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1013      still TOFU_POLICY_NONE after executing the query, then the
1014      result set was empty.)  */
1015   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1016                       strings_collect_cb2, &strlist, &err,
1017                       "select policy, conflict from bindings\n"
1018                       " where fingerprint = ? and email = ?",
1019                       SQLITE_ARG_STRING, fingerprint,
1020                       SQLITE_ARG_STRING, email,
1021                       SQLITE_ARG_END);
1022   if (rc)
1023     {
1024       log_error (_("error reading TOFU database: %s\n"), err);
1025       print_further_info ("checking for existing bad bindings");
1026       sqlite3_free (err);
1027       goto out;
1028     }
1029
1030   if (strlist_length (strlist) == 0)
1031     /* No results.  */
1032     {
1033       policy = TOFU_POLICY_NONE;
1034       goto out;
1035     }
1036   else if (strlist_length (strlist) != 2)
1037     /* The result has the wrong form.  */
1038     {
1039       log_error (_("error reading TOFU database: %s\n"),
1040                  gpg_strerror (GPG_ERR_BAD_DATA));
1041       print_further_info ("checking for existing bad bindings:"
1042                           " expected 2 results, got %d\n",
1043                           strlist_length (strlist));
1044       goto out;
1045     }
1046
1047   /* The result has the right form.  */
1048
1049   if (string_to_long (&along, strlist->d, 0, __LINE__))
1050     {
1051       log_error (_("error reading TOFU database: %s\n"),
1052                  gpg_strerror (GPG_ERR_BAD_DATA));
1053       print_further_info ("bad value for policy: %s", strlist->d);
1054       goto out;
1055     }
1056   policy = along;
1057
1058   if (! (policy == TOFU_POLICY_AUTO
1059          || policy == TOFU_POLICY_GOOD
1060          || policy == TOFU_POLICY_UNKNOWN
1061          || policy == TOFU_POLICY_BAD
1062          || policy == TOFU_POLICY_ASK))
1063     {
1064       log_error (_("error reading TOFU database: %s\n"),
1065                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1066       print_further_info ("invalid value for policy (%d)", policy);
1067       policy = _tofu_GET_POLICY_ERROR;
1068       goto out;
1069     }
1070
1071
1072   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1073      just in case, we do the check again here and ignore the conflict
1074      is POLICY is not TOFU_POLICY_ASK.  */
1075   if (conflict)
1076     {
1077       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1078         *conflict = xstrdup (strlist->next->d);
1079       else
1080         *conflict = NULL;
1081     }
1082
1083  out:
1084   log_assert (policy == _tofu_GET_POLICY_ERROR
1085               || policy == TOFU_POLICY_NONE
1086               || policy == TOFU_POLICY_AUTO
1087               || policy == TOFU_POLICY_GOOD
1088               || policy == TOFU_POLICY_UNKNOWN
1089               || policy == TOFU_POLICY_BAD
1090               || policy == TOFU_POLICY_ASK);
1091
1092   free_strlist (strlist);
1093
1094   return policy;
1095 }
1096
1097
1098 /* Format the first part of a conflict message and return that as a
1099  * malloced string.  */
1100 static char *
1101 format_conflict_msg_part1 (int policy, const char *conflict,
1102                            const char *fingerprint, const char *email)
1103 {
1104   estream_t fp;
1105   char *binding;
1106   int binding_shown = 0;
1107   char *tmpstr, *text;
1108
1109   binding = xasprintf ("<%s, %s>", fingerprint, email);
1110
1111   fp = es_fopenmem (0, "rw,samethread");
1112   if (!fp)
1113     log_fatal ("error creating memory stream: %s\n",
1114                gpg_strerror (gpg_error_from_syserror()));
1115
1116   if (policy == TOFU_POLICY_NONE)
1117     {
1118       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1119       es_fputs ("  ", fp);
1120       binding_shown = 1;
1121     }
1122   else if (policy == TOFU_POLICY_ASK
1123            /* If there the conflict is with itself, then don't
1124             * display this message.  */
1125            && conflict && strcmp (conflict, fingerprint))
1126     {
1127       es_fprintf (fp,
1128                   _("The key with fingerprint %s raised a conflict "
1129                     "with the binding %s."
1130                     "  Since this binding's policy was 'auto', it was "
1131                     "changed to 'ask'."),
1132                   conflict, binding);
1133       es_fputs ("  ", fp);
1134       binding_shown = 1;
1135     }
1136
1137   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1138      blank or by two empty strings.  */
1139   es_fprintf (fp,
1140               _("Please indicate whether you believe the binding %s%s"
1141                 "is legitimate (the key belongs to the stated owner) "
1142                 "or a forgery (bad)."),
1143               binding_shown ? "" : binding,
1144               binding_shown ? "" : " ");
1145   es_fputc ('\n', fp);
1146
1147   xfree (binding);
1148
1149   es_fputc (0, fp);
1150   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1151     log_fatal ("error snatching memory stream\n");
1152   text = format_text (tmpstr, 0, 72, 80);
1153   es_free (tmpstr);
1154
1155   return text;
1156 }
1157
1158
1159 /* Ask the user about the binding.  There are three ways we could end
1160  * up here:
1161  *
1162  *   - This is a new binding and there is a conflict
1163  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1164  *
1165  *   - This is a new binding and opt.tofu_default_policy is set to
1166  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1167  *     TOFU_POLICY_ASK), or,
1168  *
1169  *   - The policy is ask (the user deferred last time) (policy ==
1170  *     TOFU_POLICY_ASK).
1171  */
1172 static void
1173 ask_about_binding (tofu_dbs_t dbs,
1174                    enum tofu_policy *policy,
1175                    int *trust_level,
1176                    int bindings_with_this_email_count,
1177                    strlist_t bindings_with_this_email,
1178                    char *conflict,
1179                    const char *fingerprint,
1180                    const char *email,
1181                    const char *user_id)
1182 {
1183   char *sqerr = NULL;
1184   int rc;
1185   estream_t fp;
1186   strlist_t other_user_ids = NULL;
1187   struct signature_stats *stats = NULL;
1188   struct signature_stats *stats_iter = NULL;
1189   char *prompt;
1190   char *choices;
1191
1192   fp = es_fopenmem (0, "rw,samethread");
1193   if (!fp)
1194     log_fatal ("error creating memory stream: %s\n",
1195                gpg_strerror (gpg_error_from_syserror()));
1196
1197   {
1198     char *text = format_conflict_msg_part1 (*policy, conflict,
1199                                             fingerprint, email);
1200     es_fputs (text, fp);
1201     es_fputc ('\n', fp);
1202     xfree (text);
1203   }
1204
1205   /* Find other user ids associated with this key and whether the
1206    * bindings are marked as good or bad.  */
1207   rc = gpgsql_stepx
1208     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1209      strings_collect_cb2, &other_user_ids, &sqerr,
1210      "select user_id, policy from bindings where fingerprint = ?;",
1211      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_END);
1212   if (rc)
1213     {
1214       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1215       sqlite3_free (sqerr);
1216       sqerr = NULL;
1217     }
1218
1219   if (other_user_ids)
1220     {
1221       strlist_t strlist_iter;
1222
1223       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1224       for (strlist_iter = other_user_ids;
1225            strlist_iter;
1226            strlist_iter = strlist_iter->next)
1227         {
1228           char *other_user_id = strlist_iter->d;
1229           char *other_thing;
1230           enum tofu_policy other_policy;
1231
1232           log_assert (strlist_iter->next);
1233           strlist_iter = strlist_iter->next;
1234           other_thing = strlist_iter->d;
1235
1236           other_policy = atoi (other_thing);
1237
1238           es_fprintf (fp, "  %s (", other_user_id);
1239           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1240           es_fprintf (fp, ")\n");
1241         }
1242       es_fprintf (fp, "\n");
1243
1244       free_strlist (other_user_ids);
1245     }
1246
1247   /* Find other keys associated with this email address.  */
1248   /* FIXME: When generating the statistics, do we want the time
1249      embedded in the signature (column 'sig_time') or the time that
1250      we first verified the signature (column 'time').  */
1251   rc = gpgsql_stepx
1252     (dbs->db, &dbs->s.get_trust_gather_other_keys,
1253      signature_stats_collect_cb, &stats, &sqerr,
1254      "select fingerprint, policy, time_ago, count(*)\n"
1255      " from (select bindings.*,\n"
1256      "        case\n"
1257      /* From the future (but if its just a couple of hours in the
1258       * future don't turn it into a warning)?  Or should we use
1259       * small, medium or large units?  (Note: whatever we do, we
1260       * keep the value in seconds.  Then when we group, everything
1261       * that rounds to the same number of seconds is grouped.)  */
1262      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1263      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1264      "          then max(0,\n"
1265      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1266      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1267      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1268      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1269      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1270      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1271      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1272      "        end time_ago,\n"
1273      "        delta time_ago_raw\n"
1274      "       from bindings\n"
1275      "       left join\n"
1276      "         (select *,\n"
1277      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1278      "           from signatures) ss\n"
1279      "        on ss.binding = bindings.oid)\n"
1280      " where email = ?\n"
1281      " group by fingerprint, time_ago\n"
1282      /* Make sure the current key is first.  */
1283      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1284      SQLITE_ARG_STRING, email, SQLITE_ARG_STRING, fingerprint,
1285      SQLITE_ARG_END);
1286   if (rc)
1287     {
1288       strlist_t strlist_iter;
1289
1290       log_error (_("error gathering signature stats: %s\n"), sqerr);
1291       sqlite3_free (sqerr);
1292       sqerr = NULL;
1293
1294       es_fprintf (fp, ngettext("The email address \"%s\" is"
1295                                " associated with %d key:\n",
1296                                "The email address \"%s\" is"
1297                                " associated with %d keys:\n",
1298                                bindings_with_this_email_count),
1299                   email, bindings_with_this_email_count);
1300       for (strlist_iter = bindings_with_this_email;
1301            strlist_iter;
1302            strlist_iter = strlist_iter->next)
1303         es_fprintf (fp, "  %s\n", strlist_iter->d);
1304     }
1305   else
1306     {
1307       char *key = NULL;
1308
1309       if (! stats || strcmp (stats->fingerprint, fingerprint))
1310         {
1311           /* If we have already added this key to the DB, then it will
1312            * be first (see the above select).  Since the first key on
1313            * the list is not this key, we must not yet have verified any
1314            * messages signed by this key.  Add a dummy entry.  */
1315           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1316         }
1317
1318       es_fprintf (fp, _("Statistics for keys with the email address \"%s\":\n"),
1319                   email);
1320       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1321         {
1322           if (! key || strcmp (key, stats_iter->fingerprint))
1323             {
1324               int this_key;
1325               char *key_pp;
1326
1327               key = stats_iter->fingerprint;
1328               this_key = strcmp (key, fingerprint) == 0;
1329               key_pp = format_hexfingerprint (key, NULL, 0);
1330               es_fprintf (fp, "  %s (", key_pp);
1331               if (this_key)
1332                 es_fprintf (fp, _("this key"));
1333               else
1334                 es_fprintf (fp, _("policy: %s"),
1335                             tofu_policy_str (stats_iter->policy));
1336               es_fputs ("):\n", fp);
1337               xfree (key_pp);
1338             }
1339
1340           es_fputs ("    ", fp);
1341           if (stats_iter->time_ago == -1)
1342             es_fprintf (fp, ngettext("%ld message signed in the future.",
1343                                      "%ld messages signed in the future.",
1344                                      stats_iter->count), stats_iter->count);
1345           else
1346             {
1347               long t_scaled = time_ago_scale (stats_iter->time_ago);
1348
1349               /* TANSLATORS: This string is concatenated with one of
1350                * the day/week/month strings to form one sentence.  */
1351               es_fprintf (fp, ngettext("%ld message signed",
1352                                        "%ld messages signed",
1353                                        stats_iter->count), stats_iter->count);
1354               if (!stats_iter->count)
1355                 es_fputs (".", fp);
1356               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1357                 es_fprintf (fp, ngettext(" over the past %ld day.",
1358                                          " over the past %ld days.",
1359                                          t_scaled), t_scaled);
1360               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1361                 es_fprintf (fp, ngettext(" over the past %ld week.",
1362                                          " over the past %ld weeks.",
1363                                          t_scaled), t_scaled);
1364               else
1365                 es_fprintf (fp, ngettext(" over the past %ld month.",
1366                                          " over the past %ld months.",
1367                                          t_scaled), t_scaled);
1368             }
1369           es_fputs ("\n", fp);
1370         }
1371     }
1372
1373
1374   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1375       || (*policy == TOFU_POLICY_ASK && conflict))
1376     {
1377       /* This is a conflict.  */
1378
1379       /* TRANSLATORS: Please translate the text found in the source
1380        * file below.  We don't directly internationalize that text so
1381        * that we can tweak it without breaking translations.  */
1382       char *text = _("TOFU detected a binding conflict");
1383       char *textbuf;
1384       if (!strcmp (text, "TOFU detected a binding conflict"))
1385         {
1386           /* No translation.  Use the English text.  */
1387           text =
1388             "Normally, there is only a single key associated with an email "
1389             "address.  However, people sometimes generate a new key if "
1390             "their key is too old or they think it might be compromised.  "
1391             "Alternatively, a new key may indicate a man-in-the-middle "
1392             "attack!  Before accepting this key, you should talk to or "
1393             "call the person to make sure this new key is legitimate.";
1394         }
1395       textbuf = format_text (text, 0, 72, 80);
1396       es_fprintf (fp, "\n%s\n", text);
1397       xfree (textbuf);
1398     }
1399
1400   es_fputc ('\n', fp);
1401
1402   /* Add a NUL terminator.  */
1403   es_fputc (0, fp);
1404   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1405     log_fatal ("error snatching memory stream\n");
1406
1407   /* I think showing the large message once is sufficient.  If we
1408    * would move it right before the cpr_get many lines will scroll
1409    * away and the user might not realize that he merely entered a
1410    * wrong choise (because he does not see that either).  As a small
1411    * benefit we allow C-L to redisplay everything.  */
1412   tty_printf ("%s", prompt);
1413   while (1)
1414     {
1415       char *response;
1416
1417       /* TRANSLATORS: Two letters (normally the lower and upper case
1418        * version of the hotkey) for each of the five choices.  If
1419        * there is only one choice in your language, repeat it.  */
1420       choices = _("gG" "aA" "uU" "rR" "bB");
1421       if (strlen (choices) != 10)
1422         log_bug ("Bad TOFU conflict translation!  Please report.");
1423
1424       response = cpr_get
1425         ("tofu.conflict",
1426          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1427       trim_spaces (response);
1428       cpr_kill_prompt ();
1429       if (*response == CONTROL_L)
1430         tty_printf ("%s", prompt);
1431       else if (strlen (response) == 1)
1432         {
1433           char *choice = strchr (choices, *response);
1434           if (choice)
1435             {
1436               int c = ((size_t) choice - (size_t) choices) / 2;
1437
1438               switch (c)
1439                 {
1440                 case 0: /* Good.  */
1441                   *policy = TOFU_POLICY_GOOD;
1442                   *trust_level = tofu_policy_to_trust_level (*policy);
1443                   break;
1444                 case 1: /* Accept once.  */
1445                   *policy = TOFU_POLICY_ASK;
1446                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1447                   break;
1448                 case 2: /* Unknown.  */
1449                   *policy = TOFU_POLICY_UNKNOWN;
1450                   *trust_level = tofu_policy_to_trust_level (*policy);
1451                   break;
1452                 case 3: /* Reject once.  */
1453                   *policy = TOFU_POLICY_ASK;
1454                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1455                   break;
1456                 case 4: /* Bad.  */
1457                   *policy = TOFU_POLICY_BAD;
1458                   *trust_level = tofu_policy_to_trust_level (*policy);
1459                   break;
1460                 default:
1461                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1462                 }
1463
1464               if (record_binding (dbs, fingerprint, email, user_id,
1465                                   *policy, 0))
1466                 {
1467                   /* If there's an error registering the
1468                    * binding, don't save the signature.  */
1469                   *trust_level = _tofu_GET_TRUST_ERROR;
1470                 }
1471               break;
1472             }
1473         }
1474       xfree (response);
1475     }
1476
1477   xfree (prompt);
1478
1479   signature_stats_free (stats);
1480 }
1481
1482
1483 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1484  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1485  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1486  * returns _tofu_GET_TRUST_ERROR.
1487  *
1488  * PK is the public key object for FINGERPRINT.
1489  *
1490  * USER_ID is the unadulterated user id.
1491  *
1492  * If MAY_ASK is set, then we may interact with the user.  This is
1493  * necessary if there is a conflict or the binding's policy is
1494  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1495  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1496  * we return TRUST_UNDEFINED.  */
1497 static enum tofu_policy
1498 get_trust (tofu_dbs_t dbs, PKT_public_key *pk,
1499            const char *fingerprint, const char *email,
1500            const char *user_id, int may_ask)
1501 {
1502   enum tofu_policy policy;
1503   char *conflict = NULL;
1504   int rc;
1505   char *sqerr = NULL;
1506   strlist_t bindings_with_this_email = NULL;
1507   int bindings_with_this_email_count;
1508   int change_conflicting_to_ask = 0;
1509   int trust_level = TRUST_UNKNOWN;
1510
1511   if (opt.batch)
1512     may_ask = 0;
1513
1514   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1515      levels.  */
1516   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1517               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1518               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1519               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1520               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1521               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1522               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1523
1524   policy = get_policy (dbs, fingerprint, email, &conflict);
1525   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
1526     { /* See if the key is ultimately trusted.  If so, we're done.  */
1527       u32 kid[2];
1528
1529       keyid_from_pk (pk, kid);
1530
1531       if (tdb_keyid_is_utk (kid))
1532         {
1533           if (policy == TOFU_POLICY_NONE)
1534             {
1535               if (record_binding (dbs, fingerprint, email, user_id,
1536                                   TOFU_POLICY_AUTO, 0) != 0)
1537                 {
1538                   log_error (_("error setting TOFU binding's trust level"
1539                                " to %s\n"), "auto");
1540                   trust_level = _tofu_GET_TRUST_ERROR;
1541                   goto out;
1542                 }
1543             }
1544
1545           trust_level = TRUST_ULTIMATE;
1546           goto out;
1547         }
1548     }
1549
1550   if (policy == TOFU_POLICY_AUTO)
1551     {
1552       policy = opt.tofu_default_policy;
1553       if (DBG_TRUST)
1554         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
1555                    fingerprint, email,
1556                    tofu_policy_str (opt.tofu_default_policy));
1557     }
1558   switch (policy)
1559     {
1560     case TOFU_POLICY_AUTO:
1561     case TOFU_POLICY_GOOD:
1562     case TOFU_POLICY_UNKNOWN:
1563     case TOFU_POLICY_BAD:
1564       /* The saved judgement is auto -> auto, good, unknown or bad.
1565        * We don't need to ask the user anything.  */
1566       if (DBG_TRUST)
1567         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
1568                    fingerprint, email, tofu_policy_str (policy));
1569       trust_level = tofu_policy_to_trust_level (policy);
1570       goto out;
1571
1572     case TOFU_POLICY_ASK:
1573       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1574       if (! may_ask)
1575         {
1576           trust_level = TRUST_UNDEFINED;
1577           goto out;
1578         }
1579
1580       break;
1581
1582     case TOFU_POLICY_NONE:
1583       /* The binding is new, we need to check for conflicts.  Case #3
1584        * below.  */
1585       break;
1586
1587     case _tofu_GET_POLICY_ERROR:
1588       trust_level = _tofu_GET_TRUST_ERROR;
1589       goto out;
1590
1591     default:
1592       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1593     }
1594
1595
1596   /* We get here if:
1597    *
1598    *   1. The saved policy is auto and the default policy is ask
1599    *      (get_policy() == TOFU_POLICY_AUTO
1600    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
1601    *
1602    *   2. The saved policy is ask (either last time the user selected
1603    *      accept once or reject once or there was a conflict and this
1604    *      binding's policy was changed from auto to ask)
1605    *      (policy == TOFU_POLICY_ASK), or,
1606    *
1607    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1608    *      (need to check for a conflict).
1609    */
1610
1611   /* Look for conflicts.  This is needed in all 3 cases.
1612    *
1613    * Get the fingerprints of any bindings that share the email
1614    * address.  Note: if the binding in question is in the DB, it will
1615    * also be returned.  Thus, if the result set is empty, then this is
1616    * a new binding.  */
1617   rc = gpgsql_stepx
1618     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1619      strings_collect_cb2, &bindings_with_this_email, &sqerr,
1620      "select distinct fingerprint from bindings where email = ?;",
1621      SQLITE_ARG_STRING, email, SQLITE_ARG_END);
1622   if (rc)
1623     {
1624       log_error (_("error reading TOFU database: %s\n"), sqerr);
1625       print_further_info ("listing fingerprints");
1626       sqlite3_free (sqerr);
1627       goto out;
1628     }
1629
1630   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1631   if (bindings_with_this_email_count == 0
1632       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1633     {
1634       /* New binding with no conflict and a concrete default policy.
1635        *
1636        * We've never observed a binding with this email address
1637        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
1638        * return the current binding if it were in the DB) and we have
1639        * a default policy, which is not to ask the user.
1640        */
1641
1642       /* If we've seen this binding, then we've seen this email and
1643          policy couldn't possibly be TOFU_POLICY_NONE.  */
1644       log_assert (policy == TOFU_POLICY_NONE);
1645
1646       if (DBG_TRUST)
1647         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
1648                    email, fingerprint);
1649
1650       if (record_binding (dbs, fingerprint, email, user_id,
1651                           TOFU_POLICY_AUTO, 0) != 0)
1652         {
1653           log_error (_("error setting TOFU binding's trust level to %s\n"),
1654                        "auto");
1655           trust_level = _tofu_GET_TRUST_ERROR;
1656           goto out;
1657         }
1658
1659       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1660       goto out;
1661     }
1662
1663   if (policy == TOFU_POLICY_NONE)
1664     {
1665       /* This is a new binding and we have a conflict.  Mark any
1666        * conflicting bindings that have an automatic policy as now
1667        * requiring confirmation.  Note: we delay this until after we
1668        * ask for confirmation so that when the current policy is
1669        * printed, it is correct.  */
1670       change_conflicting_to_ask = 1;
1671     }
1672
1673   if (! may_ask)
1674     {
1675       /* We can only get here in the third case (no saved policy) and
1676        * if there is a conflict.  (If the policy was ask (cases #1 and
1677        * #2) and we weren't allowed to ask, we'd have already exited).  */
1678       log_assert (policy == TOFU_POLICY_NONE);
1679
1680       if (record_binding (dbs, fingerprint, email, user_id,
1681                           TOFU_POLICY_ASK, 0) != 0)
1682         log_error (_("error setting TOFU binding's trust level to %s\n"),
1683                    "ask");
1684
1685       trust_level = TRUST_UNDEFINED;
1686       goto out;
1687     }
1688
1689   /* If we get here, we need to ask the user about the binding.  */
1690   ask_about_binding (dbs,
1691                      &policy,
1692                      &trust_level,
1693                      bindings_with_this_email_count,
1694                      bindings_with_this_email,
1695                      conflict,
1696                      fingerprint,
1697                      email,
1698                      user_id);
1699
1700  out:
1701   if (change_conflicting_to_ask)
1702     {
1703       if (! may_ask)
1704         {
1705           /* If we weren't allowed to ask, also update this key as
1706              conflicting with itself.  */
1707           rc = gpgsql_exec_printf
1708             (dbs->db, NULL, NULL, &sqerr,
1709              "update bindings set policy = %d, conflict = %Q"
1710              " where email = %Q"
1711              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
1712              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
1713              TOFU_POLICY_ASK, fingerprint);
1714         }
1715       else
1716         {
1717           rc = gpgsql_exec_printf
1718             (dbs->db, NULL, NULL, &sqerr,
1719              "update bindings set policy = %d, conflict = %Q"
1720              " where email = %Q and fingerprint != %Q and policy = %d;",
1721              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
1722              TOFU_POLICY_AUTO);
1723         }
1724
1725       if (rc)
1726         {
1727           log_error (_("error changing TOFU policy: %s\n"), sqerr);
1728           sqlite3_free (sqerr);
1729           sqerr = NULL;
1730         }
1731     }
1732
1733   xfree (conflict);
1734   free_strlist (bindings_with_this_email);
1735
1736   return trust_level;
1737 }
1738
1739
1740 /* Return a malloced string of the form
1741  *    "7 months, 1 day, 5 minutes, 0 seconds"
1742  * The caller should replace all '~' in the returned string by a space
1743  * and also free the returned string.
1744  *
1745  * This is actually a bad hack which may not work correctly with all
1746  * languages.
1747  */
1748 static char *
1749 time_ago_str (long long int t)
1750 {
1751   estream_t fp;
1752   int years = 0;
1753   int months = 0;
1754   int days = 0;
1755   int hours = 0;
1756   int minutes = 0;
1757   int seconds = 0;
1758
1759   /* The number of units that we've printed so far.  */
1760   int count = 0;
1761   /* The first unit that we printed (year = 0, month = 1,
1762      etc.).  */
1763   int first = -1;
1764   /* The current unit.  */
1765   int i = 0;
1766
1767   char *str;
1768
1769   /* It would be nice to use a macro to do this, but gettext
1770      works on the unpreprocessed code.  */
1771 #define MIN_SECS (60)
1772 #define HOUR_SECS (60 * MIN_SECS)
1773 #define DAY_SECS (24 * HOUR_SECS)
1774 #define MONTH_SECS (30 * DAY_SECS)
1775 #define YEAR_SECS (365 * DAY_SECS)
1776
1777   if (t > YEAR_SECS)
1778     {
1779       years = t / YEAR_SECS;
1780       t -= years * YEAR_SECS;
1781     }
1782   if (t > MONTH_SECS)
1783     {
1784       months = t / MONTH_SECS;
1785       t -= months * MONTH_SECS;
1786     }
1787   if (t > DAY_SECS)
1788     {
1789       days = t / DAY_SECS;
1790       t -= days * DAY_SECS;
1791     }
1792   if (t > HOUR_SECS)
1793     {
1794       hours = t / HOUR_SECS;
1795       t -= hours * HOUR_SECS;
1796     }
1797   if (t > MIN_SECS)
1798     {
1799       minutes = t / MIN_SECS;
1800       t -= minutes * MIN_SECS;
1801     }
1802   seconds = t;
1803
1804 #undef MIN_SECS
1805 #undef HOUR_SECS
1806 #undef DAY_SECS
1807 #undef MONTH_SECS
1808 #undef YEAR_SECS
1809
1810   fp = es_fopenmem (0, "rw,samethread");
1811   if (! fp)
1812     log_fatal ("error creating memory stream: %s\n",
1813                gpg_strerror (gpg_error_from_syserror()));
1814
1815   if (years)
1816     {
1817       /* TRANSLATORS: The tilde ('~') is used here to indicate a
1818        * non-breakable space  */
1819       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
1820       count ++;
1821       first = i;
1822     }
1823   i ++;
1824   if ((first == -1 || i - first <= 3) && months)
1825     {
1826       if (count)
1827         es_fprintf (fp, ", ");
1828       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
1829       count ++;
1830       first = i;
1831     }
1832   i ++;
1833   if ((first == -1 || i - first <= 3) && count < 2 && days)
1834     {
1835       if (count)
1836         es_fprintf (fp, ", ");
1837       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
1838       count ++;
1839       first = i;
1840     }
1841   i ++;
1842   if ((first == -1 || i - first <= 3) && count < 2 && hours)
1843     {
1844       if (count)
1845         es_fprintf (fp, ", ");
1846       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
1847       count ++;
1848       first = i;
1849     }
1850   i ++;
1851   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1852     {
1853       if (count)
1854         es_fprintf (fp, ", ");
1855       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
1856       count ++;
1857       first = i;
1858     }
1859   i ++;
1860   if ((first == -1 || i - first <= 3) && count < 2)
1861     {
1862       if (count)
1863         es_fprintf (fp, ", ");
1864       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
1865     }
1866
1867   es_fputc (0, fp);
1868   if (es_fclose_snatch (fp, (void **) &str, NULL))
1869     log_fatal ("error snatching memory stream\n");
1870
1871   return str;
1872 }
1873
1874
1875 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
1876  * write a "tfs" record to that stream. */
1877 static void
1878 write_stats_status (estream_t fp, long messages, enum tofu_policy policy,
1879                     unsigned long first_seen,
1880                     unsigned long most_recent_seen)
1881 {
1882   const char *validity;
1883
1884   if (messages < 1)
1885     validity = "1"; /* Key without history.  */
1886   else if (messages < BASIC_TRUST_THRESHOLD)
1887     validity = "2"; /* Key with too little history.  */
1888   else if (messages < FULL_TRUST_THRESHOLD)
1889     validity = "3"; /* Key with enough history for basic trust.  */
1890   else
1891     validity = "4"; /* Key with a lot of history.  */
1892
1893   if (fp)
1894     {
1895       es_fprintf (fp, "tfs:1:%s:%ld:0:%s:%lu:%lu:\n",
1896                   validity, messages,
1897                   tofu_policy_str (policy),
1898                   first_seen, most_recent_seen);
1899     }
1900   else
1901     {
1902       char numbuf1[35];
1903       char numbuf2[35];
1904       char numbuf3[35];
1905
1906       snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
1907       *numbuf2 = *numbuf3 = 0;
1908       if (first_seen && most_recent_seen)
1909         {
1910           snprintf (numbuf2, sizeof numbuf2, " %lu", first_seen);
1911           snprintf (numbuf3, sizeof numbuf3, " %lu", most_recent_seen);
1912         }
1913
1914       write_status_strings (STATUS_TOFU_STATS,
1915                             validity, numbuf1, " 0",
1916                             " ", tofu_policy_str (policy),
1917                             numbuf2, numbuf3,
1918                             NULL);
1919     }
1920 }
1921
1922 static void
1923 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
1924                  const char *email, const char *user_id,
1925                  const char *sig_exclude)
1926 {
1927   char *fingerprint_pp;
1928   int rc;
1929   strlist_t strlist = NULL;
1930   char *err = NULL;
1931
1932   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1933
1934   rc = gpgsql_exec_printf
1935     (dbs->db, strings_collect_cb, &strlist, &err,
1936      "select count (*), min (signatures.time), max (signatures.time)\n"
1937      " from signatures\n"
1938      " left join bindings on signatures.binding = bindings.oid\n"
1939      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
1940      fingerprint, email,
1941      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
1942         not NULL.  */
1943      sig_exclude ? "!= '" : "is not NULL",
1944      sig_exclude ? sig_exclude : "",
1945      sig_exclude ? "'" : "");
1946   if (rc)
1947     {
1948       log_error (_("error reading TOFU database: %s\n"), err);
1949       print_further_info ("getting statistics");
1950       sqlite3_free (err);
1951       goto out;
1952     }
1953
1954
1955   write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
1956                                 email, strlen (email), 0);
1957
1958   if (! strlist)
1959     {
1960       log_info (_("Have never verified a message signed by key %s!\n"),
1961                 fingerprint_pp);
1962       write_stats_status (NULL, 0, TOFU_POLICY_NONE, 0, 0);
1963     }
1964   else
1965     {
1966       unsigned long now = gnupg_get_time ();
1967       signed long messages;
1968       unsigned long first_seen;
1969       unsigned long most_recent_seen;
1970
1971       log_assert (strlist_length (strlist) == 3);
1972
1973       string_to_long (&messages, strlist->d, -1, __LINE__);
1974
1975       if (messages == 0 && *strlist->next->d == '\0')
1976         { /* min(NULL) => NULL => "".  */
1977           first_seen = 0;
1978           most_recent_seen = 0;
1979         }
1980       else
1981         {
1982           string_to_ulong (&first_seen, strlist->next->d, -1, __LINE__);
1983           if (first_seen > now)
1984             {
1985               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
1986                          first_seen, now);
1987               first_seen = now;
1988             }
1989           string_to_ulong (&most_recent_seen, strlist->next->next->d, -1,
1990                            __LINE__);
1991           if (most_recent_seen > now)
1992             {
1993               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
1994                          most_recent_seen, now);
1995               most_recent_seen = now;
1996             }
1997
1998         }
1999
2000       if (messages == -1 || !first_seen)
2001         {
2002           write_stats_status (NULL, 0, TOFU_POLICY_NONE, 0, 0);
2003           log_info (_("Failed to collect signature statistics for \"%s\"\n"
2004                       "(key %s)\n"),
2005                     user_id, fingerprint_pp);
2006         }
2007       else
2008         {
2009           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2010           estream_t fp;
2011           char *msg;
2012
2013           write_stats_status (NULL, messages, policy,
2014                               first_seen, most_recent_seen);
2015
2016           fp = es_fopenmem (0, "rw,samethread");
2017           if (! fp)
2018             log_fatal ("error creating memory stream: %s\n",
2019                        gpg_strerror (gpg_error_from_syserror()));
2020
2021           if (messages == 0)
2022             {
2023               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2024                           0L, user_id);
2025               es_fputc ('\n', fp);
2026             }
2027           else
2028             {
2029               char *first_seen_ago_str = time_ago_str (now - first_seen);
2030
2031               /* TRANSLATORS: The final %s is replaced by a string like
2032                  "7 months, 1 day, 5 minutes, 0 seconds". */
2033               es_fprintf (fp,
2034                           ngettext("Verified %ld message signed by \"%s\"\n"
2035                                    "in the past %s.",
2036                                    "Verified %ld messages signed by \"%s\"\n"
2037                                    "in the past %s.",
2038                                    messages),
2039                           messages, user_id, first_seen_ago_str);
2040
2041               if (messages > 1)
2042                 {
2043                   char *tmpstr = time_ago_str (now - most_recent_seen);
2044                   es_fputs ("  ", fp);
2045                   es_fprintf (fp, _("The most recent message was"
2046                                     " verified %s ago."), tmpstr);
2047                   xfree (tmpstr);
2048                 }
2049               xfree (first_seen_ago_str);
2050
2051               if (opt.verbose)
2052                 {
2053                   es_fputs ("  ", fp);
2054                   es_fputc ('(', fp);
2055                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2056                   es_fputs (")\n", fp);
2057                 }
2058               else
2059                 es_fputs ("\n", fp);
2060             }
2061
2062           {
2063             char *tmpmsg, *p;
2064             es_fputc (0, fp);
2065             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2066               log_fatal ("error snatching memory stream\n");
2067             msg = format_text (tmpmsg, 0, 72, 80);
2068             es_free (tmpmsg);
2069
2070             /* Print a status line but suppress the trailing LF.
2071              * Spaces are not percent escaped. */
2072             if (*msg)
2073               write_status_buffer (STATUS_TOFU_STATS_LONG,
2074                                    msg, strlen (msg)-1, -1);
2075
2076             /* Remove the non-breaking space markers.  */
2077             for (p=msg; *p; p++)
2078               if (*p == '~')
2079                 *p = ' ';
2080
2081           }
2082
2083           log_string (GPGRT_LOG_INFO, msg);
2084           xfree (msg);
2085
2086           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2087             {
2088               char *set_policy_command;
2089               char *text;
2090               char *tmpmsg;
2091
2092               if (messages == 0)
2093                 log_info (_("Warning: we've have yet to see"
2094                             " a message signed by this key!\n"));
2095               else if (messages == 1)
2096                 log_info (_("Warning: we've only seen a"
2097                             " single message signed by this key!\n"));
2098
2099               set_policy_command =
2100                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2101
2102               tmpmsg = xasprintf
2103                 (ngettext
2104                  ("Warning: if you think you've seen more than %ld message "
2105                   "signed by this key, then this key might be a forgery!  "
2106                   "Carefully examine the email address for small "
2107                   "variations.  If the key is suspect, then use\n"
2108                   "  %s\n"
2109                   "to mark it as being bad.\n",
2110                   "Warning: if you think you've seen more than %ld messages "
2111                   "signed by this key, then this key might be a forgery!  "
2112                       "Carefully examine the email address for small "
2113                   "variations.  If the key is suspect, then use\n"
2114                   "  %s\n"
2115                   "to mark it as being bad.\n",
2116                   messages),
2117                   messages, set_policy_command);
2118               text = format_text (tmpmsg, 0, 72, 80);
2119               xfree (tmpmsg);
2120               log_string (GPGRT_LOG_INFO, text);
2121               xfree (text);
2122
2123               es_free (set_policy_command);
2124             }
2125         }
2126     }
2127
2128  out:
2129   free_strlist (strlist);
2130   xfree (fingerprint_pp);
2131
2132   return;
2133 }
2134
2135 /* Extract the email address from a user id and normalize it.  If the
2136    user id doesn't contain an email address, then we use the whole
2137    user_id and normalize that.  The returned string must be freed.  */
2138 static char *
2139 email_from_user_id (const char *user_id)
2140 {
2141   char *email = mailbox_from_userid (user_id);
2142   if (! email)
2143     {
2144       /* Hmm, no email address was provided or we are out of core.  Just
2145          take the lower-case version of the whole user id.  It could be
2146          a hostname, for instance.  */
2147       email = ascii_strlwr (xstrdup (user_id));
2148     }
2149
2150   return email;
2151 }
2152
2153 /* Register the signature with the binding <fingerprint, USER_ID>.
2154    The fingerprint is taken from the primary key packet PK.
2155
2156    SIG_DIGEST_BIN is the binary representation of the message's
2157    digest.  SIG_DIGEST_BIN_LEN is its length.
2158
2159    SIG_TIME is the time that the signature was generated.
2160
2161    ORIGIN is a free-formed string describing the origin of the
2162    signature.  If this was from an email and the Claws MUA was used,
2163    then this should be something like: "email:claws".  If this is
2164    NULL, the default is simply "unknown".
2165
2166    If MAY_ASK is 1, then this function may interact with the user.
2167    This is necessary if there is a conflict or the binding's policy is
2168    TOFU_POLICY_ASK.
2169
2170    This function returns the binding's trust level on return.  If an
2171    error occurs, this function returns TRUST_UNKNOWN.  */
2172 int
2173 tofu_register (ctrl_t ctrl, PKT_public_key *pk, const char *user_id,
2174                const byte *sig_digest_bin, int sig_digest_bin_len,
2175                time_t sig_time, const char *origin, int may_ask)
2176 {
2177   tofu_dbs_t dbs;
2178   char *fingerprint = NULL;
2179   char *email = NULL;
2180   char *err = NULL;
2181   int rc;
2182   int trust_level = TRUST_UNKNOWN;
2183   char *sig_digest;
2184   unsigned long c;
2185   int already_verified = 0;
2186
2187   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2188
2189   dbs = opendbs (ctrl);
2190   if (! dbs)
2191     {
2192       log_error (_("error opening TOFU database: %s\n"),
2193                  gpg_strerror (GPG_ERR_GENERAL));
2194       goto die;
2195     }
2196
2197   fingerprint = hexfingerprint (pk, NULL, 0);
2198
2199   if (! *user_id)
2200     {
2201       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2202       goto die;
2203     }
2204
2205   email = email_from_user_id (user_id);
2206
2207   if (! origin)
2208     /* The default origin is simply "unknown".  */
2209     origin = "unknown";
2210
2211   /* It's necessary to get the trust so that we are certain that the
2212      binding has been registered.  */
2213   trust_level = get_trust (dbs, pk, fingerprint, email, user_id, may_ask);
2214   if (trust_level == _tofu_GET_TRUST_ERROR)
2215     /* An error.  */
2216     {
2217       trust_level = TRUST_UNKNOWN;
2218       goto die;
2219     }
2220
2221   /* We do a query and then an insert.  Make sure they are atomic
2222      by wrapping them in a transaction.  */
2223   rc = begin_transaction (ctrl, 0);
2224   if (rc)
2225     goto die;
2226
2227   /* If we've already seen this signature before, then don't add
2228      it again.  */
2229   rc = gpgsql_stepx
2230     (dbs->db, &dbs->s.register_already_seen,
2231      get_single_unsigned_long_cb2, &c, &err,
2232      "select count (*)\n"
2233      " from signatures left join bindings\n"
2234      "  on signatures.binding = bindings.oid\n"
2235      " where fingerprint = ? and email = ? and sig_time = ?\n"
2236      "  and sig_digest = ?",
2237      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2238      SQLITE_ARG_LONG_LONG, (long long) sig_time,
2239      SQLITE_ARG_STRING, sig_digest,
2240      SQLITE_ARG_END);
2241   if (rc)
2242     {
2243       log_error (_("error reading TOFU database: %s\n"), err);
2244       print_further_info ("checking existence");
2245       sqlite3_free (err);
2246     }
2247   else if (c > 1)
2248     /* Duplicates!  This should not happen.  In particular,
2249        because <fingerprint, email, sig_time, sig_digest> is the
2250        primary key!  */
2251     log_debug ("SIGNATURES DB contains duplicate records"
2252                " <%s, %s, 0x%lx, %s, %s>."
2253                "  Please report.\n",
2254                fingerprint, email, (unsigned long) sig_time,
2255                sig_digest, origin);
2256   else if (c == 1)
2257     {
2258       already_verified = 1;
2259       if (DBG_TRUST)
2260         log_debug ("Already observed the signature"
2261                    " <%s, %s, 0x%lx, %s, %s>\n",
2262                    fingerprint, email, (unsigned long) sig_time,
2263                    sig_digest, origin);
2264     }
2265   else if (opt.dry_run)
2266     {
2267       log_info ("TOFU database update skipped due to --dry-run\n");
2268     }
2269   else
2270     /* This is the first time that we've seen this signature.
2271        Record it.  */
2272     {
2273       if (DBG_TRUST)
2274         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2275                    fingerprint, email, sig_digest);
2276
2277       log_assert (c == 0);
2278
2279       rc = gpgsql_stepx
2280         (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2281          "insert into signatures\n"
2282          " (binding, sig_digest, origin, sig_time, time)\n"
2283          " values\n"
2284          " ((select oid from bindings\n"
2285          "    where fingerprint = ? and email = ?),\n"
2286          "  ?, ?, ?, strftime('%s', 'now'));",
2287          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2288          SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2289          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2290          SQLITE_ARG_END);
2291       if (rc)
2292         {
2293           log_error (_("error updating TOFU database: %s\n"), err);
2294           print_further_info ("insert signatures");
2295           sqlite3_free (err);
2296         }
2297     }
2298
2299   /* It only matters whether we abort or commit the transaction
2300      (so long as we do something) if we execute the insert.  */
2301   if (rc)
2302     rc = rollback_transaction (ctrl);
2303   else
2304     rc = end_transaction (ctrl, 0);
2305   if (rc)
2306     {
2307       sqlite3_free (err);
2308       goto die;
2309     }
2310
2311  die:
2312   if (may_ask && trust_level != TRUST_ULTIMATE)
2313     /* It's only appropriate to show the statistics in an interactive
2314        context.  */
2315     show_statistics (dbs, fingerprint, email, user_id,
2316                      already_verified ? NULL : sig_digest);
2317
2318   xfree (email);
2319   xfree (fingerprint);
2320   xfree (sig_digest);
2321
2322   return trust_level;
2323 }
2324
2325 /* Combine a trust level returned from the TOFU trust model with a
2326    trust level returned by the PGP trust model.  This is primarily of
2327    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2328
2329    This function ors together the upper bits (the values not covered
2330    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2331 int
2332 tofu_wot_trust_combine (int tofu_base, int wot_base)
2333 {
2334   int tofu = tofu_base & TRUST_MASK;
2335   int wot = wot_base & TRUST_MASK;
2336   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2337
2338   log_assert (tofu == TRUST_UNKNOWN
2339               || tofu == TRUST_EXPIRED
2340               || tofu == TRUST_UNDEFINED
2341               || tofu == TRUST_NEVER
2342               || tofu == TRUST_MARGINAL
2343               || tofu == TRUST_FULLY
2344               || tofu == TRUST_ULTIMATE);
2345   log_assert (wot == TRUST_UNKNOWN
2346               || wot == TRUST_EXPIRED
2347               || wot == TRUST_UNDEFINED
2348               || wot == TRUST_NEVER
2349               || wot == TRUST_MARGINAL
2350               || wot == TRUST_FULLY
2351               || wot == TRUST_ULTIMATE);
2352
2353   /* We first consider negative trust policys.  These trump positive
2354      trust policies.  */
2355   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2356     /* TRUST_NEVER trumps everything else.  */
2357     return upper | TRUST_NEVER;
2358   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2359     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2360     return upper | TRUST_EXPIRED;
2361
2362   /* Now we only have positive or neutral trust policies.  We take
2363      the max.  */
2364   if (tofu == TRUST_ULTIMATE)
2365     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2366   if (wot == TRUST_ULTIMATE)
2367     return upper | TRUST_ULTIMATE;
2368
2369   if (tofu == TRUST_FULLY)
2370     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2371   if (wot == TRUST_FULLY)
2372     return upper | TRUST_FULLY;
2373
2374   if (tofu == TRUST_MARGINAL)
2375     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2376   if (wot == TRUST_MARGINAL)
2377     return upper | TRUST_MARGINAL;
2378
2379   if (tofu == TRUST_UNDEFINED)
2380     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2381   if (wot == TRUST_UNDEFINED)
2382     return upper | TRUST_UNDEFINED;
2383
2384   return upper | TRUST_UNKNOWN;
2385 }
2386
2387
2388 /* Return the validity (TRUST_NEVER, etc.) of the binding
2389    <FINGERPRINT, USER_ID>.
2390
2391    PK is the primary key packet.
2392
2393    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2394    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2395    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2396
2397    Returns TRUST_UNDEFINED if an error occurs.  */
2398 int
2399 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, const char *user_id,
2400                    int may_ask)
2401 {
2402   tofu_dbs_t dbs;
2403   char *fingerprint = NULL;
2404   char *email = NULL;
2405   int trust_level = TRUST_UNDEFINED;
2406
2407   dbs = opendbs (ctrl);
2408   if (! dbs)
2409     {
2410       log_error (_("error opening TOFU database: %s\n"),
2411                  gpg_strerror (GPG_ERR_GENERAL));
2412       goto die;
2413     }
2414
2415   fingerprint = hexfingerprint (pk, NULL, 0);
2416
2417   if (! *user_id)
2418     {
2419       log_debug ("user id is empty."
2420                  "  Can't get TOFU validity for this binding.\n");
2421       goto die;
2422     }
2423
2424   email = email_from_user_id (user_id);
2425
2426   trust_level = get_trust (dbs, pk, fingerprint, email, user_id, may_ask);
2427   if (trust_level == _tofu_GET_TRUST_ERROR)
2428     /* An error.  */
2429     trust_level = TRUST_UNDEFINED;
2430
2431   if (may_ask && trust_level != TRUST_ULTIMATE)
2432     show_statistics (dbs, fingerprint, email, user_id, NULL);
2433
2434  die:
2435   xfree (email);
2436   xfree (fingerprint);
2437   return trust_level;
2438 }
2439
2440 /* Set the policy for all non-revoked user ids in the keyblock KB to
2441    POLICY.
2442
2443    If no key is available with the specified key id, then this
2444    function returns GPG_ERR_NO_PUBKEY.
2445
2446    Returns 0 on success and an error code otherwise.  */
2447 gpg_error_t
2448 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2449 {
2450   tofu_dbs_t dbs;
2451   PKT_public_key *pk;
2452   char *fingerprint = NULL;
2453
2454   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2455   pk = kb->pkt->pkt.public_key;
2456
2457   dbs = opendbs (ctrl);
2458   if (! dbs)
2459     {
2460       log_error (_("error opening TOFU database: %s\n"),
2461                  gpg_strerror (GPG_ERR_GENERAL));
2462       return gpg_error (GPG_ERR_GENERAL);
2463     }
2464
2465   if (DBG_TRUST)
2466     log_debug ("Setting TOFU policy for %s to %s\n",
2467                keystr (pk->keyid), tofu_policy_str (policy));
2468   if (! (pk->main_keyid[0] == pk->keyid[0]
2469          && pk->main_keyid[1] == pk->keyid[1]))
2470     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2471
2472   fingerprint = hexfingerprint (pk, NULL, 0);
2473
2474   for (; kb; kb = kb->next)
2475     {
2476       PKT_user_id *user_id;
2477       char *email;
2478
2479       if (kb->pkt->pkttype != PKT_USER_ID)
2480         continue;
2481
2482       user_id = kb->pkt->pkt.user_id;
2483       if (user_id->is_revoked)
2484         /* Skip revoked user ids.  (Don't skip expired user ids, the
2485            expiry can be changed.)  */
2486         continue;
2487
2488       email = email_from_user_id (user_id->name);
2489
2490       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2491
2492       xfree (email);
2493     }
2494
2495   xfree (fingerprint);
2496   return 0;
2497 }
2498
2499 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2500    the key id KEYID to POLICY.
2501
2502    If no key is available with the specified key id, then this
2503    function returns GPG_ERR_NO_PUBKEY.
2504
2505    Returns 0 on success and an error code otherwise.  */
2506 gpg_error_t
2507 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2508 {
2509   kbnode_t keyblock = get_pubkeyblock (keyid);
2510   if (! keyblock)
2511     return gpg_error (GPG_ERR_NO_PUBKEY);
2512
2513   return tofu_set_policy (ctrl, keyblock, policy);
2514 }
2515
2516 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2517    policy has been set for the binding, sets *POLICY to
2518    TOFU_POLICY_NONE.
2519
2520    PK is a primary public key and USER_ID is a user id.
2521
2522    Returns 0 on success and an error code otherwise.  */
2523 gpg_error_t
2524 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2525                  enum tofu_policy *policy)
2526 {
2527   tofu_dbs_t dbs;
2528   char *fingerprint;
2529   char *email;
2530
2531   /* Make sure PK is a primary key.  */
2532   log_assert (pk->main_keyid[0] == pk->keyid[0]
2533               && pk->main_keyid[1] == pk->keyid[1]);
2534
2535   dbs = opendbs (ctrl);
2536   if (! dbs)
2537     {
2538       log_error (_("error opening TOFU database: %s\n"),
2539                  gpg_strerror (GPG_ERR_GENERAL));
2540       return gpg_error (GPG_ERR_GENERAL);
2541     }
2542
2543   fingerprint = hexfingerprint (pk, NULL, 0);
2544
2545   email = email_from_user_id (user_id->name);
2546
2547   *policy = get_policy (dbs, fingerprint, email, NULL);
2548
2549   xfree (email);
2550   xfree (fingerprint);
2551   if (*policy == _tofu_GET_POLICY_ERROR)
2552     return gpg_error (GPG_ERR_GENERAL);
2553   return 0;
2554 }