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