g10: If a key has no valid user ids, change TOFU to return TRUST_NEVER.
[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 asurprising 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 <%s, %s>): %s\n",
781                      fingerprint, email, err);
782           sqlite3_free (err);
783         }
784     }
785
786   if (DBG_TRUST)
787     {
788       if (policy_old != TOFU_POLICY_NONE)
789         log_debug ("Changing TOFU trust policy for binding <%s, %s>"
790                    " from %s to %s.\n",
791                    fingerprint, email,
792                    tofu_policy_str (policy_old),
793                    tofu_policy_str (policy));
794       else
795         log_debug ("Set TOFU trust policy for binding <%s, %s> to %s.\n",
796                    fingerprint, email,
797                    tofu_policy_str (policy));
798     }
799
800   if (policy_old == policy)
801     {
802       rc = 0;
803       goto leave; /* Nothing to do.  */
804     }
805
806   if (opt.dry_run)
807     {
808       log_info ("TOFU database update skipped due to --dry-run\n");
809       rc = 0;
810       goto leave;
811     }
812
813   rc = gpgsql_stepx
814     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
815      "insert or replace into bindings\n"
816      " (oid, fingerprint, email, user_id, time, policy)\n"
817      " values (\n"
818      /* If we don't explicitly reuse the OID, then SQLite will
819         reallocate a new one.  We just need to search for the OID
820         based on the fingerprint and email since they are unique.  */
821      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
822      "  ?, ?, ?, strftime('%s','now'), ?);",
823      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
824      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
825      SQLITE_ARG_STRING, user_id, SQLITE_ARG_INT, (int) policy,
826      SQLITE_ARG_END);
827   if (rc)
828     {
829       log_error (_("error updating TOFU database: %s\n"), err);
830       print_further_info (" insert bindings <%s, %s> = %s",
831                           fingerprint, email, tofu_policy_str (policy));
832       sqlite3_free (err);
833       goto leave;
834     }
835
836  leave:
837   xfree (fingerprint_pp);
838   return rc;
839 }
840
841
842 /* Collect the strings returned by a query in a simply string list.
843    Any NULL values are converted to the empty string.
844
845    If a result has 3 rows and each row contains two columns, then the
846    results are added to the list as follows (the value is parentheses
847    is the 1-based index in the final list):
848
849      row 1, col 2 (6)
850      row 1, col 1 (5)
851      row 2, col 2 (4)
852      row 2, col 1 (3)
853      row 3, col 2 (2)
854      row 3, col 1 (1)
855
856    This is because add_to_strlist pushes the results onto the front of
857    the list.  The end result is that the rows are backwards, but the
858    columns are in the expected order.  */
859 static int
860 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
861 {
862   int i;
863   strlist_t *strlist = cookie;
864
865   (void) azColName;
866
867   for (i = argc - 1; i >= 0; i --)
868     add_to_strlist (strlist, argv[i] ? argv[i] : "");
869
870   return 0;
871 }
872
873 static int
874 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
875                      sqlite3_stmt *stmt)
876 {
877   (void) stmt;
878   return strings_collect_cb (cookie, argc, argv, azColName);
879
880 }
881
882 /* Auxiliary data structure to collect statistics about
883    signatures.  */
884 struct signature_stats
885 {
886   struct signature_stats *next;
887
888   /* The user-assigned policy for this binding.  */
889   enum tofu_policy policy;
890
891   /* How long ago the signature was created (rounded to a multiple of
892      TIME_AGO_UNIT_SMALL, etc.).  */
893   long time_ago;
894   /* Number of signatures during this time.  */
895   unsigned long count;
896
897   /* The key that generated this signature.  */
898   char fingerprint[1];
899 };
900
901 static void
902 signature_stats_free (struct signature_stats *stats)
903 {
904   while (stats)
905     {
906       struct signature_stats *next = stats->next;
907       xfree (stats);
908       stats = next;
909     }
910 }
911
912 static void
913 signature_stats_prepend (struct signature_stats **statsp,
914                          const char *fingerprint,
915                          enum tofu_policy policy,
916                          long time_ago,
917                          unsigned long count)
918 {
919   struct signature_stats *stats =
920     xmalloc (sizeof (*stats) + strlen (fingerprint));
921
922   stats->next = *statsp;
923   *statsp = stats;
924
925   strcpy (stats->fingerprint, fingerprint);
926   stats->policy = policy;
927   stats->time_ago = time_ago;
928   stats->count = count;
929 }
930
931
932 /* Process rows that contain the four columns:
933
934      <fingerprint, policy, time ago, count>.  */
935 static int
936 signature_stats_collect_cb (void *cookie, int argc, char **argv,
937                             char **azColName, sqlite3_stmt *stmt)
938 {
939   struct signature_stats **statsp = cookie;
940   int i = 0;
941   enum tofu_policy policy;
942   long time_ago;
943   unsigned long count;
944   long along;
945
946   (void) azColName;
947   (void) stmt;
948
949   i ++;
950
951   if (string_to_long (&along, argv[i], 0, __LINE__))
952     return 1;  /* Abort */
953   policy = along;
954   i ++;
955
956   if (! argv[i])
957     time_ago = 0;
958   else
959     {
960       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
961         return 1; /* Abort.  */
962     }
963   i ++;
964
965   /* If time_ago is NULL, then we had no messages, but we still have a
966      single row, which count(*) turns into 1.  */
967   if (! argv[i - 1])
968     count = 0;
969   else
970     {
971       if (string_to_ulong (&count, argv[i], 0, __LINE__))
972         return 1; /* Abort */
973     }
974   i ++;
975
976   log_assert (argc == i);
977
978   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
979
980   return 0;
981 }
982
983 /* Convert from seconds to time units.
984
985    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
986    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
987 signed long
988 time_ago_scale (signed long t)
989 {
990   if (t < TIME_AGO_UNIT_MEDIUM)
991     return t / TIME_AGO_UNIT_SMALL;
992   if (t < TIME_AGO_UNIT_LARGE)
993     return t / TIME_AGO_UNIT_MEDIUM;
994   return t / TIME_AGO_UNIT_LARGE;
995 }
996
997
998 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
999    already been normalized) and any conflict information in *CONFLICT
1000    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1001    occurs.  */
1002 static enum tofu_policy
1003 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1004             char **conflict)
1005 {
1006   int rc;
1007   char *err = NULL;
1008   strlist_t strlist = NULL;
1009   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1010   long along;
1011
1012   /* Check if the <FINGERPRINT, EMAIL> binding is known
1013      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1014      still TOFU_POLICY_NONE after executing the query, then the
1015      result set was empty.)  */
1016   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1017                       strings_collect_cb2, &strlist, &err,
1018                       "select policy, conflict from bindings\n"
1019                       " where fingerprint = ? and email = ?",
1020                       SQLITE_ARG_STRING, fingerprint,
1021                       SQLITE_ARG_STRING, email,
1022                       SQLITE_ARG_END);
1023   if (rc)
1024     {
1025       log_error (_("error reading TOFU database: %s\n"), err);
1026       print_further_info ("checking for existing bad bindings");
1027       sqlite3_free (err);
1028       goto out;
1029     }
1030
1031   if (strlist_length (strlist) == 0)
1032     /* No results.  */
1033     {
1034       policy = TOFU_POLICY_NONE;
1035       goto out;
1036     }
1037   else if (strlist_length (strlist) != 2)
1038     /* The result has the wrong form.  */
1039     {
1040       log_error (_("error reading TOFU database: %s\n"),
1041                  gpg_strerror (GPG_ERR_BAD_DATA));
1042       print_further_info ("checking for existing bad bindings:"
1043                           " expected 2 results, got %d\n",
1044                           strlist_length (strlist));
1045       goto out;
1046     }
1047
1048   /* The result has the right form.  */
1049
1050   if (string_to_long (&along, strlist->d, 0, __LINE__))
1051     {
1052       log_error (_("error reading TOFU database: %s\n"),
1053                  gpg_strerror (GPG_ERR_BAD_DATA));
1054       print_further_info ("bad value for policy: %s", strlist->d);
1055       goto out;
1056     }
1057   policy = along;
1058
1059   if (! (policy == TOFU_POLICY_AUTO
1060          || policy == TOFU_POLICY_GOOD
1061          || policy == TOFU_POLICY_UNKNOWN
1062          || policy == TOFU_POLICY_BAD
1063          || policy == TOFU_POLICY_ASK))
1064     {
1065       log_error (_("error reading TOFU database: %s\n"),
1066                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1067       print_further_info ("invalid value for policy (%d)", policy);
1068       policy = _tofu_GET_POLICY_ERROR;
1069       goto out;
1070     }
1071
1072
1073   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1074      just in case, we do the check again here and ignore the conflict
1075      is POLICY is not TOFU_POLICY_ASK.  */
1076   if (conflict)
1077     {
1078       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1079         *conflict = xstrdup (strlist->next->d);
1080       else
1081         *conflict = NULL;
1082     }
1083
1084  out:
1085   log_assert (policy == _tofu_GET_POLICY_ERROR
1086               || policy == TOFU_POLICY_NONE
1087               || policy == TOFU_POLICY_AUTO
1088               || policy == TOFU_POLICY_GOOD
1089               || policy == TOFU_POLICY_UNKNOWN
1090               || policy == TOFU_POLICY_BAD
1091               || policy == TOFU_POLICY_ASK);
1092
1093   free_strlist (strlist);
1094
1095   return policy;
1096 }
1097
1098
1099 /* Format the first part of a conflict message and return that as a
1100  * malloced string.  */
1101 static char *
1102 format_conflict_msg_part1 (int policy, const char *conflict,
1103                            const char *fingerprint, const char *email)
1104 {
1105   estream_t fp;
1106   char *binding;
1107   int binding_shown = 0;
1108   char *tmpstr, *text;
1109
1110   binding = xasprintf ("<%s, %s>", fingerprint, email);
1111
1112   fp = es_fopenmem (0, "rw,samethread");
1113   if (!fp)
1114     log_fatal ("error creating memory stream: %s\n",
1115                gpg_strerror (gpg_error_from_syserror()));
1116
1117   if (policy == TOFU_POLICY_NONE)
1118     {
1119       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1120       es_fputs ("  ", fp);
1121       binding_shown = 1;
1122     }
1123   else if (policy == TOFU_POLICY_ASK
1124            /* If there the conflict is with itself, then don't
1125             * display this message.  */
1126            && conflict && strcmp (conflict, fingerprint))
1127     {
1128       es_fprintf (fp,
1129                   _("The key with fingerprint %s raised a conflict "
1130                     "with the binding %s."
1131                     "  Since this binding's policy was 'auto', it was "
1132                     "changed to 'ask'."),
1133                   conflict, binding);
1134       es_fputs ("  ", fp);
1135       binding_shown = 1;
1136     }
1137
1138   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1139      blank or by two empty strings.  */
1140   es_fprintf (fp,
1141               _("Please indicate whether you believe the binding %s%s"
1142                 "is legitimate (the key belongs to the stated owner) "
1143                 "or a forgery (bad)."),
1144               binding_shown ? "" : binding,
1145               binding_shown ? "" : " ");
1146   es_fputc ('\n', fp);
1147
1148   xfree (binding);
1149
1150   es_fputc (0, fp);
1151   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1152     log_fatal ("error snatching memory stream\n");
1153   text = format_text (tmpstr, 0, 72, 80);
1154   es_free (tmpstr);
1155
1156   return text;
1157 }
1158
1159
1160 /* Ask the user about the binding.  There are three ways we could end
1161  * up here:
1162  *
1163  *   - This is a new binding and there is a conflict
1164  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1165  *
1166  *   - This is a new binding and opt.tofu_default_policy is set to
1167  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1168  *     TOFU_POLICY_ASK), or,
1169  *
1170  *   - The policy is ask (the user deferred last time) (policy ==
1171  *     TOFU_POLICY_ASK).
1172  */
1173 static void
1174 ask_about_binding (tofu_dbs_t dbs,
1175                    enum tofu_policy *policy,
1176                    int *trust_level,
1177                    int bindings_with_this_email_count,
1178                    strlist_t bindings_with_this_email,
1179                    char *conflict,
1180                    const char *fingerprint,
1181                    const char *email,
1182                    const char *user_id)
1183 {
1184   char *sqerr = NULL;
1185   int rc;
1186   estream_t fp;
1187   strlist_t other_user_ids = NULL;
1188   struct signature_stats *stats = NULL;
1189   struct signature_stats *stats_iter = NULL;
1190   char *prompt;
1191   char *choices;
1192
1193   fp = es_fopenmem (0, "rw,samethread");
1194   if (!fp)
1195     log_fatal ("error creating memory stream: %s\n",
1196                gpg_strerror (gpg_error_from_syserror()));
1197
1198   {
1199     char *text = format_conflict_msg_part1 (*policy, conflict,
1200                                             fingerprint, email);
1201     es_fputs (text, fp);
1202     es_fputc ('\n', fp);
1203     xfree (text);
1204   }
1205
1206   /* Find other user ids associated with this key and whether the
1207    * bindings are marked as good or bad.  */
1208   rc = gpgsql_stepx
1209     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1210      strings_collect_cb2, &other_user_ids, &sqerr,
1211      "select user_id, policy from bindings where fingerprint = ?;",
1212      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_END);
1213   if (rc)
1214     {
1215       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1216       sqlite3_free (sqerr);
1217       sqerr = NULL;
1218     }
1219
1220   if (other_user_ids)
1221     {
1222       strlist_t strlist_iter;
1223
1224       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1225       for (strlist_iter = other_user_ids;
1226            strlist_iter;
1227            strlist_iter = strlist_iter->next)
1228         {
1229           char *other_user_id = strlist_iter->d;
1230           char *other_thing;
1231           enum tofu_policy other_policy;
1232
1233           log_assert (strlist_iter->next);
1234           strlist_iter = strlist_iter->next;
1235           other_thing = strlist_iter->d;
1236
1237           other_policy = atoi (other_thing);
1238
1239           es_fprintf (fp, "  %s (", other_user_id);
1240           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1241           es_fprintf (fp, ")\n");
1242         }
1243       es_fprintf (fp, "\n");
1244
1245       free_strlist (other_user_ids);
1246     }
1247
1248   /* Find other keys associated with this email address.  */
1249   /* FIXME: When generating the statistics, do we want the time
1250      embedded in the signature (column 'sig_time') or the time that
1251      we first verified the signature (column 'time').  */
1252   rc = gpgsql_stepx
1253     (dbs->db, &dbs->s.get_trust_gather_other_keys,
1254      signature_stats_collect_cb, &stats, &sqerr,
1255      "select fingerprint, policy, time_ago, count(*)\n"
1256      " from (select bindings.*,\n"
1257      "        case\n"
1258      /* From the future (but if its just a couple of hours in the
1259       * future don't turn it into a warning)?  Or should we use
1260       * small, medium or large units?  (Note: whatever we do, we
1261       * keep the value in seconds.  Then when we group, everything
1262       * that rounds to the same number of seconds is grouped.)  */
1263      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1264      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1265      "          then max(0,\n"
1266      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1267      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1268      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1269      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1270      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1271      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1272      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1273      "        end time_ago,\n"
1274      "        delta time_ago_raw\n"
1275      "       from bindings\n"
1276      "       left join\n"
1277      "         (select *,\n"
1278      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1279      "           from signatures) ss\n"
1280      "        on ss.binding = bindings.oid)\n"
1281      " where email = ?\n"
1282      " group by fingerprint, time_ago\n"
1283      /* Make sure the current key is first.  */
1284      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1285      SQLITE_ARG_STRING, email, SQLITE_ARG_STRING, fingerprint,
1286      SQLITE_ARG_END);
1287   if (rc)
1288     {
1289       strlist_t strlist_iter;
1290
1291       log_error (_("error gathering signature stats: %s\n"), sqerr);
1292       sqlite3_free (sqerr);
1293       sqerr = NULL;
1294
1295       es_fprintf (fp, ngettext("The email address \"%s\" is"
1296                                " associated with %d key:\n",
1297                                "The email address \"%s\" is"
1298                                " associated with %d keys:\n",
1299                                bindings_with_this_email_count),
1300                   email, bindings_with_this_email_count);
1301       for (strlist_iter = bindings_with_this_email;
1302            strlist_iter;
1303            strlist_iter = strlist_iter->next)
1304         es_fprintf (fp, "  %s\n", strlist_iter->d);
1305     }
1306   else
1307     {
1308       char *key = NULL;
1309
1310       if (! stats || strcmp (stats->fingerprint, fingerprint))
1311         {
1312           /* If we have already added this key to the DB, then it will
1313            * be first (see the above select).  Since the first key on
1314            * the list is not this key, we must not yet have verified any
1315            * messages signed by this key.  Add a dummy entry.  */
1316           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1317         }
1318
1319       es_fprintf (fp, _("Statistics for keys with the email address \"%s\":\n"),
1320                   email);
1321       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1322         {
1323           if (! key || strcmp (key, stats_iter->fingerprint))
1324             {
1325               int this_key;
1326               char *key_pp;
1327
1328               key = stats_iter->fingerprint;
1329               this_key = strcmp (key, fingerprint) == 0;
1330               key_pp = format_hexfingerprint (key, NULL, 0);
1331               es_fprintf (fp, "  %s (", key_pp);
1332               if (this_key)
1333                 es_fprintf (fp, _("this key"));
1334               else
1335                 es_fprintf (fp, _("policy: %s"),
1336                             tofu_policy_str (stats_iter->policy));
1337               es_fputs ("):\n", fp);
1338               xfree (key_pp);
1339             }
1340
1341           es_fputs ("    ", fp);
1342           if (stats_iter->time_ago == -1)
1343             es_fprintf (fp, ngettext("%ld message signed in the future.",
1344                                      "%ld messages signed in the future.",
1345                                      stats_iter->count), stats_iter->count);
1346           else
1347             {
1348               long t_scaled = time_ago_scale (stats_iter->time_ago);
1349
1350               /* TANSLATORS: This string is concatenated with one of
1351                * the day/week/month strings to form one sentence.  */
1352               es_fprintf (fp, ngettext("%ld message signed",
1353                                        "%ld messages signed",
1354                                        stats_iter->count), stats_iter->count);
1355               if (!stats_iter->count)
1356                 es_fputs (".", fp);
1357               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1358                 es_fprintf (fp, ngettext(" over the past %ld day.",
1359                                          " over the past %ld days.",
1360                                          t_scaled), t_scaled);
1361               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1362                 es_fprintf (fp, ngettext(" over the past %ld week.",
1363                                          " over the past %ld weeks.",
1364                                          t_scaled), t_scaled);
1365               else
1366                 es_fprintf (fp, ngettext(" over the past %ld month.",
1367                                          " over the past %ld months.",
1368                                          t_scaled), t_scaled);
1369             }
1370           es_fputs ("\n", fp);
1371         }
1372     }
1373
1374
1375   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1376       || (*policy == TOFU_POLICY_ASK
1377           && (conflict || bindings_with_this_email_count > 0)))
1378     {
1379       /* This is a conflict.  */
1380
1381       /* TRANSLATORS: Please translate the text found in the source
1382        * file below.  We don't directly internationalize that text so
1383        * that we can tweak it without breaking translations.  */
1384       char *text = _("TOFU detected a binding conflict");
1385       char *textbuf;
1386       if (!strcmp (text, "TOFU detected a binding conflict"))
1387         {
1388           /* No translation.  Use the English text.  */
1389           text =
1390             "Normally, there is only a single key associated with an email "
1391             "address.  However, people sometimes generate a new key if "
1392             "their key is too old or they think it might be compromised.  "
1393             "Alternatively, a new key may indicate a man-in-the-middle "
1394             "attack!  Before accepting this key, you should talk to or "
1395             "call the person to make sure this new key is legitimate.";
1396         }
1397       textbuf = format_text (text, 0, 72, 80);
1398       es_fprintf (fp, "\n%s\n", textbuf);
1399       xfree (textbuf);
1400     }
1401
1402   es_fputc ('\n', fp);
1403
1404   /* Add a NUL terminator.  */
1405   es_fputc (0, fp);
1406   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1407     log_fatal ("error snatching memory stream\n");
1408
1409   /* I think showing the large message once is sufficient.  If we
1410    * would move it right before the cpr_get many lines will scroll
1411    * away and the user might not realize that he merely entered a
1412    * wrong choise (because he does not see that either).  As a small
1413    * benefit we allow C-L to redisplay everything.  */
1414   tty_printf ("%s", prompt);
1415   while (1)
1416     {
1417       char *response;
1418
1419       /* TRANSLATORS: Two letters (normally the lower and upper case
1420        * version of the hotkey) for each of the five choices.  If
1421        * there is only one choice in your language, repeat it.  */
1422       choices = _("gG" "aA" "uU" "rR" "bB");
1423       if (strlen (choices) != 10)
1424         log_bug ("Bad TOFU conflict translation!  Please report.");
1425
1426       response = cpr_get
1427         ("tofu.conflict",
1428          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1429       trim_spaces (response);
1430       cpr_kill_prompt ();
1431       if (*response == CONTROL_L)
1432         tty_printf ("%s", prompt);
1433       else if (strlen (response) == 1)
1434         {
1435           char *choice = strchr (choices, *response);
1436           if (choice)
1437             {
1438               int c = ((size_t) choice - (size_t) choices) / 2;
1439
1440               switch (c)
1441                 {
1442                 case 0: /* Good.  */
1443                   *policy = TOFU_POLICY_GOOD;
1444                   *trust_level = tofu_policy_to_trust_level (*policy);
1445                   break;
1446                 case 1: /* Accept once.  */
1447                   *policy = TOFU_POLICY_ASK;
1448                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1449                   break;
1450                 case 2: /* Unknown.  */
1451                   *policy = TOFU_POLICY_UNKNOWN;
1452                   *trust_level = tofu_policy_to_trust_level (*policy);
1453                   break;
1454                 case 3: /* Reject once.  */
1455                   *policy = TOFU_POLICY_ASK;
1456                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1457                   break;
1458                 case 4: /* Bad.  */
1459                   *policy = TOFU_POLICY_BAD;
1460                   *trust_level = tofu_policy_to_trust_level (*policy);
1461                   break;
1462                 default:
1463                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1464                 }
1465
1466               if (record_binding (dbs, fingerprint, email, user_id,
1467                                   *policy, 0))
1468                 {
1469                   /* If there's an error registering the
1470                    * binding, don't save the signature.  */
1471                   *trust_level = _tofu_GET_TRUST_ERROR;
1472                 }
1473               break;
1474             }
1475         }
1476       xfree (response);
1477     }
1478
1479   xfree (prompt);
1480
1481   signature_stats_free (stats);
1482 }
1483
1484
1485 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1486  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1487  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1488  * returns _tofu_GET_TRUST_ERROR.
1489  *
1490  * PK is the public key object for FINGERPRINT.
1491  *
1492  * USER_ID is the unadulterated user id.
1493  *
1494  * If MAY_ASK is set, then we may interact with the user.  This is
1495  * necessary if there is a conflict or the binding's policy is
1496  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1497  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1498  * we return TRUST_UNDEFINED.  */
1499 static enum tofu_policy
1500 get_trust (tofu_dbs_t dbs, PKT_public_key *pk,
1501            const char *fingerprint, const char *email,
1502            const char *user_id, int may_ask)
1503 {
1504   enum tofu_policy policy;
1505   char *conflict = NULL;
1506   int rc;
1507   char *sqerr = NULL;
1508   strlist_t bindings_with_this_email = NULL;
1509   int bindings_with_this_email_count;
1510   int change_conflicting_to_ask = 0;
1511   int trust_level = TRUST_UNKNOWN;
1512
1513   if (opt.batch)
1514     may_ask = 0;
1515
1516   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1517      levels.  */
1518   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1519               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1520               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1521               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1522               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1523               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1524               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1525
1526   policy = get_policy (dbs, fingerprint, email, &conflict);
1527   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
1528     { /* See if the key is ultimately trusted.  If so, we're done.  */
1529       u32 kid[2];
1530
1531       keyid_from_pk (pk, kid);
1532
1533       if (tdb_keyid_is_utk (kid))
1534         {
1535           if (policy == TOFU_POLICY_NONE)
1536             {
1537               if (record_binding (dbs, fingerprint, email, user_id,
1538                                   TOFU_POLICY_AUTO, 0) != 0)
1539                 {
1540                   log_error (_("error setting TOFU binding's trust level"
1541                                " to %s\n"), "auto");
1542                   trust_level = _tofu_GET_TRUST_ERROR;
1543                   goto out;
1544                 }
1545             }
1546
1547           trust_level = TRUST_ULTIMATE;
1548           goto out;
1549         }
1550     }
1551
1552   if (policy == TOFU_POLICY_AUTO)
1553     {
1554       policy = opt.tofu_default_policy;
1555       if (DBG_TRUST)
1556         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
1557                    fingerprint, email,
1558                    tofu_policy_str (opt.tofu_default_policy));
1559     }
1560   switch (policy)
1561     {
1562     case TOFU_POLICY_AUTO:
1563     case TOFU_POLICY_GOOD:
1564     case TOFU_POLICY_UNKNOWN:
1565     case TOFU_POLICY_BAD:
1566       /* The saved judgement is auto -> auto, good, unknown or bad.
1567        * We don't need to ask the user anything.  */
1568       if (DBG_TRUST)
1569         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
1570                    fingerprint, email, tofu_policy_str (policy));
1571       trust_level = tofu_policy_to_trust_level (policy);
1572       goto out;
1573
1574     case TOFU_POLICY_ASK:
1575       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1576       if (! may_ask)
1577         {
1578           trust_level = TRUST_UNDEFINED;
1579           goto out;
1580         }
1581
1582       break;
1583
1584     case TOFU_POLICY_NONE:
1585       /* The binding is new, we need to check for conflicts.  Case #3
1586        * below.  */
1587       break;
1588
1589     case _tofu_GET_POLICY_ERROR:
1590       trust_level = _tofu_GET_TRUST_ERROR;
1591       goto out;
1592
1593     default:
1594       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1595     }
1596
1597
1598   /* We get here if:
1599    *
1600    *   1. The saved policy is auto and the default policy is ask
1601    *      (get_policy() == TOFU_POLICY_AUTO
1602    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
1603    *
1604    *   2. The saved policy is ask (either last time the user selected
1605    *      accept once or reject once or there was a conflict and this
1606    *      binding's policy was changed from auto to ask)
1607    *      (policy == TOFU_POLICY_ASK), or,
1608    *
1609    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1610    *      (need to check for a conflict).
1611    */
1612
1613   /* Look for conflicts.  This is needed in all 3 cases.
1614    *
1615    * Get the fingerprints of any bindings that share the email
1616    * address.  Note: if the binding in question is in the DB, it will
1617    * also be returned.  Thus, if the result set is empty, then this is
1618    * a new binding.  */
1619   rc = gpgsql_stepx
1620     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1621      strings_collect_cb2, &bindings_with_this_email, &sqerr,
1622      "select distinct fingerprint from bindings where email = ?;",
1623      SQLITE_ARG_STRING, email, SQLITE_ARG_END);
1624   if (rc)
1625     {
1626       log_error (_("error reading TOFU database: %s\n"), sqerr);
1627       print_further_info ("listing fingerprints");
1628       sqlite3_free (sqerr);
1629       goto out;
1630     }
1631
1632   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1633   if (bindings_with_this_email_count == 0
1634       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1635     {
1636       /* New binding with no conflict and a concrete default policy.
1637        *
1638        * We've never observed a binding with this email address
1639        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
1640        * return the current binding if it were in the DB) and we have
1641        * a default policy, which is not to ask the user.
1642        */
1643
1644       /* If we've seen this binding, then we've seen this email and
1645          policy couldn't possibly be TOFU_POLICY_NONE.  */
1646       log_assert (policy == TOFU_POLICY_NONE);
1647
1648       if (DBG_TRUST)
1649         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
1650                    email, fingerprint);
1651
1652       if (record_binding (dbs, fingerprint, email, user_id,
1653                           TOFU_POLICY_AUTO, 0) != 0)
1654         {
1655           log_error (_("error setting TOFU binding's trust level to %s\n"),
1656                        "auto");
1657           trust_level = _tofu_GET_TRUST_ERROR;
1658           goto out;
1659         }
1660
1661       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1662       goto out;
1663     }
1664
1665   if (policy == TOFU_POLICY_NONE)
1666     {
1667       /* This is a new binding and we have a conflict.  Mark any
1668        * conflicting bindings that have an automatic policy as now
1669        * requiring confirmation.  Note: we delay this until after we
1670        * ask for confirmation so that when the current policy is
1671        * printed, it is correct.  */
1672       change_conflicting_to_ask = 1;
1673     }
1674
1675   if (! may_ask)
1676     {
1677       /* We can only get here in the third case (no saved policy) and
1678        * if there is a conflict.  (If the policy was ask (cases #1 and
1679        * #2) and we weren't allowed to ask, we'd have already exited).  */
1680       log_assert (policy == TOFU_POLICY_NONE);
1681
1682       if (record_binding (dbs, fingerprint, email, user_id,
1683                           TOFU_POLICY_ASK, 0) != 0)
1684         log_error (_("error setting TOFU binding's trust level to %s\n"),
1685                    "ask");
1686
1687       trust_level = TRUST_UNDEFINED;
1688       goto out;
1689     }
1690
1691   /* If we get here, we need to ask the user about the binding.  */
1692   ask_about_binding (dbs,
1693                      &policy,
1694                      &trust_level,
1695                      bindings_with_this_email_count,
1696                      bindings_with_this_email,
1697                      conflict,
1698                      fingerprint,
1699                      email,
1700                      user_id);
1701
1702  out:
1703   if (change_conflicting_to_ask)
1704     {
1705       if (! may_ask)
1706         {
1707           /* If we weren't allowed to ask, also update this key as
1708              conflicting with itself.  */
1709           rc = gpgsql_exec_printf
1710             (dbs->db, NULL, NULL, &sqerr,
1711              "update bindings set policy = %d, conflict = %Q"
1712              " where email = %Q"
1713              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
1714              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
1715              TOFU_POLICY_ASK, fingerprint);
1716         }
1717       else
1718         {
1719           rc = gpgsql_exec_printf
1720             (dbs->db, NULL, NULL, &sqerr,
1721              "update bindings set policy = %d, conflict = %Q"
1722              " where email = %Q and fingerprint != %Q and policy = %d;",
1723              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
1724              TOFU_POLICY_AUTO);
1725         }
1726
1727       if (rc)
1728         {
1729           log_error (_("error changing TOFU policy: %s\n"), sqerr);
1730           sqlite3_free (sqerr);
1731           sqerr = NULL;
1732         }
1733     }
1734
1735   xfree (conflict);
1736   free_strlist (bindings_with_this_email);
1737
1738   return trust_level;
1739 }
1740
1741
1742 /* Return a malloced string of the form
1743  *    "7 months, 1 day, 5 minutes, 0 seconds"
1744  * The caller should replace all '~' in the returned string by a space
1745  * and also free the returned string.
1746  *
1747  * This is actually a bad hack which may not work correctly with all
1748  * languages.
1749  */
1750 static char *
1751 time_ago_str (long long int t)
1752 {
1753   estream_t fp;
1754   int years = 0;
1755   int months = 0;
1756   int days = 0;
1757   int hours = 0;
1758   int minutes = 0;
1759   int seconds = 0;
1760
1761   /* The number of units that we've printed so far.  */
1762   int count = 0;
1763   /* The first unit that we printed (year = 0, month = 1,
1764      etc.).  */
1765   int first = -1;
1766   /* The current unit.  */
1767   int i = 0;
1768
1769   char *str;
1770
1771   /* It would be nice to use a macro to do this, but gettext
1772      works on the unpreprocessed code.  */
1773 #define MIN_SECS (60)
1774 #define HOUR_SECS (60 * MIN_SECS)
1775 #define DAY_SECS (24 * HOUR_SECS)
1776 #define MONTH_SECS (30 * DAY_SECS)
1777 #define YEAR_SECS (365 * DAY_SECS)
1778
1779   if (t > YEAR_SECS)
1780     {
1781       years = t / YEAR_SECS;
1782       t -= years * YEAR_SECS;
1783     }
1784   if (t > MONTH_SECS)
1785     {
1786       months = t / MONTH_SECS;
1787       t -= months * MONTH_SECS;
1788     }
1789   if (t > DAY_SECS)
1790     {
1791       days = t / DAY_SECS;
1792       t -= days * DAY_SECS;
1793     }
1794   if (t > HOUR_SECS)
1795     {
1796       hours = t / HOUR_SECS;
1797       t -= hours * HOUR_SECS;
1798     }
1799   if (t > MIN_SECS)
1800     {
1801       minutes = t / MIN_SECS;
1802       t -= minutes * MIN_SECS;
1803     }
1804   seconds = t;
1805
1806 #undef MIN_SECS
1807 #undef HOUR_SECS
1808 #undef DAY_SECS
1809 #undef MONTH_SECS
1810 #undef YEAR_SECS
1811
1812   fp = es_fopenmem (0, "rw,samethread");
1813   if (! fp)
1814     log_fatal ("error creating memory stream: %s\n",
1815                gpg_strerror (gpg_error_from_syserror()));
1816
1817   if (years)
1818     {
1819       /* TRANSLATORS: The tilde ('~') is used here to indicate a
1820        * non-breakable space  */
1821       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
1822       count ++;
1823       first = i;
1824     }
1825   i ++;
1826   if ((first == -1 || i - first <= 3) && months)
1827     {
1828       if (count)
1829         es_fprintf (fp, ", ");
1830       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
1831       count ++;
1832       first = i;
1833     }
1834   i ++;
1835   if ((first == -1 || i - first <= 3) && count < 2 && days)
1836     {
1837       if (count)
1838         es_fprintf (fp, ", ");
1839       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
1840       count ++;
1841       first = i;
1842     }
1843   i ++;
1844   if ((first == -1 || i - first <= 3) && count < 2 && hours)
1845     {
1846       if (count)
1847         es_fprintf (fp, ", ");
1848       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
1849       count ++;
1850       first = i;
1851     }
1852   i ++;
1853   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1854     {
1855       if (count)
1856         es_fprintf (fp, ", ");
1857       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
1858       count ++;
1859       first = i;
1860     }
1861   i ++;
1862   if ((first == -1 || i - first <= 3) && count < 2)
1863     {
1864       if (count)
1865         es_fprintf (fp, ", ");
1866       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
1867     }
1868
1869   es_fputc (0, fp);
1870   if (es_fclose_snatch (fp, (void **) &str, NULL))
1871     log_fatal ("error snatching memory stream\n");
1872
1873   return str;
1874 }
1875
1876
1877 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
1878  * write a "tfs" record to that stream. */
1879 static void
1880 write_stats_status (estream_t fp, long messages, enum tofu_policy policy,
1881                     unsigned long first_seen,
1882                     unsigned long most_recent_seen)
1883 {
1884   const char *validity;
1885
1886   if (messages < 1)
1887     validity = "1"; /* Key without history.  */
1888   else if (messages < BASIC_TRUST_THRESHOLD)
1889     validity = "2"; /* Key with too little history.  */
1890   else if (messages < FULL_TRUST_THRESHOLD)
1891     validity = "3"; /* Key with enough history for basic trust.  */
1892   else
1893     validity = "4"; /* Key with a lot of history.  */
1894
1895   if (fp)
1896     {
1897       es_fprintf (fp, "tfs:1:%s:%ld:0:%s:%lu:%lu:\n",
1898                   validity, messages,
1899                   tofu_policy_str (policy),
1900                   first_seen, most_recent_seen);
1901     }
1902   else
1903     {
1904       char numbuf1[35];
1905       char numbuf2[35];
1906       char numbuf3[35];
1907
1908       snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
1909       *numbuf2 = *numbuf3 = 0;
1910       if (first_seen && most_recent_seen)
1911         {
1912           snprintf (numbuf2, sizeof numbuf2, " %lu", first_seen);
1913           snprintf (numbuf3, sizeof numbuf3, " %lu", most_recent_seen);
1914         }
1915
1916       write_status_strings (STATUS_TOFU_STATS,
1917                             validity, numbuf1, " 0",
1918                             " ", tofu_policy_str (policy),
1919                             numbuf2, numbuf3,
1920                             NULL);
1921     }
1922 }
1923
1924
1925 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
1926  * to OUTFP.  In this case USER_ID is not required.  */
1927 static void
1928 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
1929                  const char *email, const char *user_id,
1930                  const char *sig_exclude, estream_t outfp)
1931 {
1932   char *fingerprint_pp;
1933   int rc;
1934   strlist_t strlist = NULL;
1935   char *err = NULL;
1936
1937   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1938
1939   rc = gpgsql_exec_printf
1940     (dbs->db, strings_collect_cb, &strlist, &err,
1941      "select count (*), min (signatures.time), max (signatures.time)\n"
1942      " from signatures\n"
1943      " left join bindings on signatures.binding = bindings.oid\n"
1944      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
1945      fingerprint, email,
1946      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
1947         not NULL.  */
1948      sig_exclude ? "!= '" : "is not NULL",
1949      sig_exclude ? sig_exclude : "",
1950      sig_exclude ? "'" : "");
1951   if (rc)
1952     {
1953       log_error (_("error reading TOFU database: %s\n"), err);
1954       print_further_info ("getting statistics");
1955       sqlite3_free (err);
1956       goto out;
1957     }
1958
1959   if (!outfp)
1960     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
1961                                   email, strlen (email), 0);
1962
1963   if (! strlist)
1964     {
1965       if (!outfp)
1966         log_info (_("Have never verified a message signed by key %s!\n"),
1967                   fingerprint_pp);
1968       write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
1969     }
1970   else
1971     {
1972       unsigned long now = gnupg_get_time ();
1973       signed long messages;
1974       unsigned long first_seen;
1975       unsigned long most_recent_seen;
1976
1977       log_assert (strlist_length (strlist) == 3);
1978
1979       string_to_long (&messages, strlist->d, -1, __LINE__);
1980
1981       if (messages == 0 && *strlist->next->d == '\0')
1982         { /* min(NULL) => NULL => "".  */
1983           first_seen = 0;
1984           most_recent_seen = 0;
1985         }
1986       else
1987         {
1988           string_to_ulong (&first_seen, strlist->next->d, -1, __LINE__);
1989           if (first_seen > now)
1990             {
1991               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
1992                          first_seen, now);
1993               first_seen = now;
1994             }
1995           string_to_ulong (&most_recent_seen, strlist->next->next->d, -1,
1996                            __LINE__);
1997           if (most_recent_seen > now)
1998             {
1999               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2000                          most_recent_seen, now);
2001               most_recent_seen = now;
2002             }
2003
2004         }
2005
2006       if (messages == -1 || !first_seen)
2007         {
2008           write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2009           if (!outfp)
2010             log_info (_("Failed to collect signature statistics for \"%s\"\n"
2011                         "(key %s)\n"),
2012                       user_id, fingerprint_pp);
2013         }
2014       else if (outfp)
2015         {
2016           write_stats_status (outfp, messages,
2017                               get_policy (dbs, fingerprint, email, NULL),
2018                               first_seen, most_recent_seen);
2019         }
2020       else
2021         {
2022           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2023           estream_t fp;
2024           char *msg;
2025
2026           write_stats_status (NULL, messages,
2027                               policy,
2028                               first_seen, most_recent_seen);
2029
2030           fp = es_fopenmem (0, "rw,samethread");
2031           if (! fp)
2032             log_fatal ("error creating memory stream: %s\n",
2033                        gpg_strerror (gpg_error_from_syserror()));
2034
2035           if (messages == 0)
2036             {
2037               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2038                           0L, user_id);
2039               es_fputc ('\n', fp);
2040             }
2041           else
2042             {
2043               char *first_seen_ago_str = time_ago_str (now - first_seen);
2044
2045               /* TRANSLATORS: The final %s is replaced by a string like
2046                  "7 months, 1 day, 5 minutes, 0 seconds". */
2047               es_fprintf (fp,
2048                           ngettext("Verified %ld message signed by \"%s\"\n"
2049                                    "in the past %s.",
2050                                    "Verified %ld messages signed by \"%s\"\n"
2051                                    "in the past %s.",
2052                                    messages),
2053                           messages, user_id, first_seen_ago_str);
2054
2055               if (messages > 1)
2056                 {
2057                   char *tmpstr = time_ago_str (now - most_recent_seen);
2058                   es_fputs ("  ", fp);
2059                   es_fprintf (fp, _("The most recent message was"
2060                                     " verified %s ago."), tmpstr);
2061                   xfree (tmpstr);
2062                 }
2063               xfree (first_seen_ago_str);
2064
2065               if (opt.verbose)
2066                 {
2067                   es_fputs ("  ", fp);
2068                   es_fputc ('(', fp);
2069                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2070                   es_fputs (")\n", fp);
2071                 }
2072               else
2073                 es_fputs ("\n", fp);
2074             }
2075
2076           {
2077             char *tmpmsg, *p;
2078             es_fputc (0, fp);
2079             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2080               log_fatal ("error snatching memory stream\n");
2081             msg = format_text (tmpmsg, 0, 72, 80);
2082             es_free (tmpmsg);
2083
2084             /* Print a status line but suppress the trailing LF.
2085              * Spaces are not percent escaped. */
2086             if (*msg)
2087               write_status_buffer (STATUS_TOFU_STATS_LONG,
2088                                    msg, strlen (msg)-1, -1);
2089
2090             /* Remove the non-breaking space markers.  */
2091             for (p=msg; *p; p++)
2092               if (*p == '~')
2093                 *p = ' ';
2094
2095           }
2096
2097           log_string (GPGRT_LOG_INFO, msg);
2098           xfree (msg);
2099
2100           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2101             {
2102               char *set_policy_command;
2103               char *text;
2104               char *tmpmsg;
2105
2106               if (messages == 0)
2107                 log_info (_("Warning: we've have yet to see"
2108                             " a message signed by this key!\n"));
2109               else if (messages == 1)
2110                 log_info (_("Warning: we've only seen a"
2111                             " single message signed by this key!\n"));
2112
2113               set_policy_command =
2114                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2115
2116               tmpmsg = xasprintf
2117                 (ngettext
2118                  ("Warning: if you think you've seen more than %ld message "
2119                   "signed by this key, then this key might be a forgery!  "
2120                   "Carefully examine the email address for small "
2121                   "variations.  If the key is suspect, then use\n"
2122                   "  %s\n"
2123                   "to mark it as being bad.\n",
2124                   "Warning: if you think you've seen more than %ld messages "
2125                   "signed by this key, then this key might be a forgery!  "
2126                       "Carefully examine the email address for small "
2127                   "variations.  If the key is suspect, then use\n"
2128                   "  %s\n"
2129                   "to mark it as being bad.\n",
2130                   messages),
2131                   messages, set_policy_command);
2132               text = format_text (tmpmsg, 0, 72, 80);
2133               xfree (tmpmsg);
2134               log_string (GPGRT_LOG_INFO, text);
2135               xfree (text);
2136
2137               es_free (set_policy_command);
2138             }
2139         }
2140     }
2141
2142  out:
2143   free_strlist (strlist);
2144   xfree (fingerprint_pp);
2145
2146   return;
2147 }
2148
2149 /* Extract the email address from a user id and normalize it.  If the
2150    user id doesn't contain an email address, then we use the whole
2151    user_id and normalize that.  The returned string must be freed.  */
2152 static char *
2153 email_from_user_id (const char *user_id)
2154 {
2155   char *email = mailbox_from_userid (user_id);
2156   if (! email)
2157     {
2158       /* Hmm, no email address was provided or we are out of core.  Just
2159          take the lower-case version of the whole user id.  It could be
2160          a hostname, for instance.  */
2161       email = ascii_strlwr (xstrdup (user_id));
2162     }
2163
2164   return email;
2165 }
2166
2167 /* Register the signature with the bindings <fingerprint, USER_ID>,
2168    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2169    the primary key packet PK.
2170
2171    SIG_DIGEST_BIN is the binary representation of the message's
2172    digest.  SIG_DIGEST_BIN_LEN is its length.
2173
2174    SIG_TIME is the time that the signature was generated.
2175
2176    ORIGIN is a free-formed string describing the origin of the
2177    signature.  If this was from an email and the Claws MUA was used,
2178    then this should be something like: "email:claws".  If this is
2179    NULL, the default is simply "unknown".
2180
2181    If MAY_ASK is 1, then this function may interact with the user.
2182    This is necessary if there is a conflict or the binding's policy is
2183    TOFU_POLICY_ASK.
2184
2185    This function returns 0 on success and an error code if an error
2186    occured.  */
2187 gpg_error_t
2188 tofu_register (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2189                const byte *sig_digest_bin, int sig_digest_bin_len,
2190                time_t sig_time, const char *origin)
2191 {
2192   gpg_error_t rc;
2193   tofu_dbs_t dbs;
2194   char *fingerprint = NULL;
2195   strlist_t user_id;
2196   char *email = NULL;
2197   char *err = NULL;
2198   char *sig_digest;
2199   unsigned long c;
2200
2201   dbs = opendbs (ctrl);
2202   if (! dbs)
2203     {
2204       rc = gpg_error (GPG_ERR_GENERAL);
2205       log_error (_("error opening TOFU database: %s\n"),
2206                  gpg_strerror (rc));
2207       return rc;
2208     }
2209
2210   /* We do a query and then an insert.  Make sure they are atomic
2211      by wrapping them in a transaction.  */
2212   rc = begin_transaction (ctrl, 0);
2213   if (rc)
2214     return rc;
2215
2216   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2217   fingerprint = hexfingerprint (pk, NULL, 0);
2218
2219   if (! origin)
2220     /* The default origin is simply "unknown".  */
2221     origin = "unknown";
2222
2223   for (user_id = user_id_list; user_id; user_id = user_id->next)
2224     {
2225       email = email_from_user_id (user_id->d);
2226
2227       if (DBG_TRUST)
2228         log_debug ("TOFU: Registering signature %s with binding"
2229                    " <key: %s, user id: %s>\n",
2230                    sig_digest, fingerprint, email);
2231
2232       /* Make sure the binding exists and record any TOFU
2233          conflicts.  */
2234       if (get_trust (dbs, pk, fingerprint, email, user_id->d, 0)
2235           == _tofu_GET_TRUST_ERROR)
2236         {
2237           rc = gpg_error (GPG_ERR_GENERAL);
2238           xfree (email);
2239           break;
2240         }
2241
2242       /* If we've already seen this signature before, then don't add
2243          it again.  */
2244       rc = gpgsql_stepx
2245         (dbs->db, &dbs->s.register_already_seen,
2246          get_single_unsigned_long_cb2, &c, &err,
2247          "select count (*)\n"
2248          " from signatures left join bindings\n"
2249          "  on signatures.binding = bindings.oid\n"
2250          " where fingerprint = ? and email = ? and sig_time = ?\n"
2251          "  and sig_digest = ?",
2252          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2253          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2254          SQLITE_ARG_STRING, sig_digest,
2255          SQLITE_ARG_END);
2256       if (rc)
2257         {
2258           log_error (_("error reading TOFU database: %s\n"), err);
2259           print_further_info ("checking existence");
2260           sqlite3_free (err);
2261         }
2262       else if (c > 1)
2263         /* Duplicates!  This should not happen.  In particular,
2264            because <fingerprint, email, sig_time, sig_digest> is the
2265            primary key!  */
2266         log_debug ("SIGNATURES DB contains duplicate records"
2267                    " <key: %s, fingerprint: %s, time: 0x%lx, sig: %s,"
2268                    " origin: %s>."
2269                    "  Please report.\n",
2270                    fingerprint, email, (unsigned long) sig_time,
2271                    sig_digest, origin);
2272       else if (c == 1)
2273         {
2274           if (DBG_TRUST)
2275             log_debug ("Already observed the signature and binding"
2276                        " <key: %s, user id: %s, time: 0x%lx, sig: %s,"
2277                        " origin: %s>\n",
2278                        fingerprint, email, (unsigned long) sig_time,
2279                        sig_digest, origin);
2280         }
2281       else if (opt.dry_run)
2282         {
2283           log_info ("TOFU database update skipped due to --dry-run\n");
2284         }
2285       else
2286         /* This is the first time that we've seen this signature and
2287            binding.  Record it.  */
2288         {
2289           if (DBG_TRUST)
2290             log_debug ("TOFU: Saving signature"
2291                        " <key: %s, user id: %s, sig: %s>\n",
2292                        fingerprint, email, sig_digest);
2293
2294           log_assert (c == 0);
2295
2296           rc = gpgsql_stepx
2297             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2298              "insert into signatures\n"
2299              " (binding, sig_digest, origin, sig_time, time)\n"
2300              " values\n"
2301              " ((select oid from bindings\n"
2302              "    where fingerprint = ? and email = ?),\n"
2303              "  ?, ?, ?, strftime('%s', 'now'));",
2304              SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2305              SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2306              SQLITE_ARG_LONG_LONG, (long long) sig_time,
2307              SQLITE_ARG_END);
2308           if (rc)
2309             {
2310               log_error (_("error updating TOFU database: %s\n"), err);
2311               print_further_info ("insert signatures");
2312               sqlite3_free (err);
2313             }
2314         }
2315
2316       xfree (email);
2317
2318       if (rc)
2319         break;
2320     }
2321
2322   if (rc)
2323     rollback_transaction (ctrl);
2324   else
2325     rc = end_transaction (ctrl, 0);
2326
2327   xfree (fingerprint);
2328   xfree (sig_digest);
2329
2330   return rc;
2331 }
2332
2333 /* Combine a trust level returned from the TOFU trust model with a
2334    trust level returned by the PGP trust model.  This is primarily of
2335    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2336
2337    This function ors together the upper bits (the values not covered
2338    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2339 int
2340 tofu_wot_trust_combine (int tofu_base, int wot_base)
2341 {
2342   int tofu = tofu_base & TRUST_MASK;
2343   int wot = wot_base & TRUST_MASK;
2344   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2345
2346   log_assert (tofu == TRUST_UNKNOWN
2347               || tofu == TRUST_EXPIRED
2348               || tofu == TRUST_UNDEFINED
2349               || tofu == TRUST_NEVER
2350               || tofu == TRUST_MARGINAL
2351               || tofu == TRUST_FULLY
2352               || tofu == TRUST_ULTIMATE);
2353   log_assert (wot == TRUST_UNKNOWN
2354               || wot == TRUST_EXPIRED
2355               || wot == TRUST_UNDEFINED
2356               || wot == TRUST_NEVER
2357               || wot == TRUST_MARGINAL
2358               || wot == TRUST_FULLY
2359               || wot == TRUST_ULTIMATE);
2360
2361   /* We first consider negative trust policys.  These trump positive
2362      trust policies.  */
2363   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2364     /* TRUST_NEVER trumps everything else.  */
2365     return upper | TRUST_NEVER;
2366   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2367     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2368     return upper | TRUST_EXPIRED;
2369
2370   /* Now we only have positive or neutral trust policies.  We take
2371      the max.  */
2372   if (tofu == TRUST_ULTIMATE)
2373     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2374   if (wot == TRUST_ULTIMATE)
2375     return upper | TRUST_ULTIMATE;
2376
2377   if (tofu == TRUST_FULLY)
2378     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2379   if (wot == TRUST_FULLY)
2380     return upper | TRUST_FULLY;
2381
2382   if (tofu == TRUST_MARGINAL)
2383     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2384   if (wot == TRUST_MARGINAL)
2385     return upper | TRUST_MARGINAL;
2386
2387   if (tofu == TRUST_UNDEFINED)
2388     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2389   if (wot == TRUST_UNDEFINED)
2390     return upper | TRUST_UNDEFINED;
2391
2392   return upper | TRUST_UNKNOWN;
2393 }
2394
2395
2396 /* Write a "tfs" record for a --with-colons listing.  */
2397 gpg_error_t
2398 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
2399                        PKT_public_key *pk, const char *user_id)
2400 {
2401   gpg_error_t err;
2402   tofu_dbs_t dbs;
2403   char *fingerprint;
2404   char *email;
2405
2406   if (!*user_id)
2407     return 0;  /* No TOFU stats possible for an empty ID.  */
2408
2409   dbs = opendbs (ctrl);
2410   if (!dbs)
2411     {
2412       err = gpg_error (GPG_ERR_GENERAL);
2413       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
2414       return err;
2415     }
2416
2417   fingerprint = hexfingerprint (pk, NULL, 0);
2418   email = email_from_user_id (user_id);
2419
2420   show_statistics (dbs, fingerprint, email, user_id, NULL, fp);
2421
2422   xfree (email);
2423   xfree (fingerprint);
2424   return 0;
2425 }
2426
2427
2428 /* Return the validity (TRUST_NEVER, etc.) of the bindings
2429    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
2430    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
2431
2432    PK is the primary key packet.
2433
2434    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2435    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2436    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2437
2438    Returns TRUST_UNDEFINED if an error occurs.  */
2439 int
2440 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2441                    int may_ask)
2442 {
2443   tofu_dbs_t dbs;
2444   char *fingerprint = NULL;
2445   strlist_t user_id;
2446   int trust_level = TRUST_UNKNOWN;
2447   int bindings = 0;
2448   int bindings_valid = 0;
2449
2450   dbs = opendbs (ctrl);
2451   if (! dbs)
2452     {
2453       log_error (_("error opening TOFU database: %s\n"),
2454                  gpg_strerror (GPG_ERR_GENERAL));
2455       return TRUST_UNDEFINED;
2456     }
2457
2458   fingerprint = hexfingerprint (pk, NULL, 0);
2459
2460   begin_transaction (ctrl, 0);
2461
2462   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
2463     {
2464       char *email = email_from_user_id (user_id->d);
2465
2466       /* Always call get_trust to make sure the binding is
2467          registered.  */
2468       int tl = get_trust (dbs, pk, fingerprint, email, user_id->d, may_ask);
2469       if (tl == _tofu_GET_TRUST_ERROR)
2470         {
2471           /* An error.  */
2472           trust_level = TRUST_UNDEFINED;
2473           xfree (email);
2474           goto die;
2475         }
2476
2477       if (DBG_TRUST)
2478         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
2479                    fingerprint, email,
2480                    trust_value_to_string (tl),
2481                    user_id->flags ? " (but expired)" : "");
2482
2483       if (user_id->flags)
2484         tl = TRUST_EXPIRED;
2485
2486       if (tl != TRUST_EXPIRED)
2487         bindings_valid ++;
2488
2489       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
2490         show_statistics (dbs, fingerprint, email, user_id->d, NULL, NULL);
2491
2492       if (tl == TRUST_NEVER)
2493         trust_level = TRUST_NEVER;
2494       else if (tl == TRUST_EXPIRED)
2495         /* Ignore expired bindings in the trust calculation.  */
2496         ;
2497       else if (tl > trust_level)
2498         {
2499           /* The expected values: */
2500           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
2501                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
2502                       || tl == TRUST_ULTIMATE);
2503
2504           /* We assume the following ordering:  */
2505           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
2506           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
2507           log_assert (TRUST_MARGINAL < TRUST_FULLY);
2508           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
2509
2510           trust_level = tl;
2511         }
2512
2513       xfree (email);
2514     }
2515
2516  die:
2517   end_transaction (ctrl, 0);
2518
2519   xfree (fingerprint);
2520
2521   if (bindings_valid == 0)
2522     {
2523       if (DBG_TRUST)
2524         log_debug ("no (of %d) valid bindings."
2525                    "  Can't get TOFU validity for this set of user ids.\n",
2526                    bindings);
2527       return TRUST_NEVER;
2528     }
2529
2530   return trust_level;
2531 }
2532
2533 /* Set the policy for all non-revoked user ids in the keyblock KB to
2534    POLICY.
2535
2536    If no key is available with the specified key id, then this
2537    function returns GPG_ERR_NO_PUBKEY.
2538
2539    Returns 0 on success and an error code otherwise.  */
2540 gpg_error_t
2541 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2542 {
2543   tofu_dbs_t dbs;
2544   PKT_public_key *pk;
2545   char *fingerprint = NULL;
2546
2547   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2548   pk = kb->pkt->pkt.public_key;
2549
2550   dbs = opendbs (ctrl);
2551   if (! dbs)
2552     {
2553       log_error (_("error opening TOFU database: %s\n"),
2554                  gpg_strerror (GPG_ERR_GENERAL));
2555       return gpg_error (GPG_ERR_GENERAL);
2556     }
2557
2558   if (DBG_TRUST)
2559     log_debug ("Setting TOFU policy for %s to %s\n",
2560                keystr (pk->keyid), tofu_policy_str (policy));
2561   if (! (pk->main_keyid[0] == pk->keyid[0]
2562          && pk->main_keyid[1] == pk->keyid[1]))
2563     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2564
2565   fingerprint = hexfingerprint (pk, NULL, 0);
2566
2567   for (; kb; kb = kb->next)
2568     {
2569       PKT_user_id *user_id;
2570       char *email;
2571
2572       if (kb->pkt->pkttype != PKT_USER_ID)
2573         continue;
2574
2575       user_id = kb->pkt->pkt.user_id;
2576       if (user_id->is_revoked)
2577         /* Skip revoked user ids.  (Don't skip expired user ids, the
2578            expiry can be changed.)  */
2579         continue;
2580
2581       email = email_from_user_id (user_id->name);
2582
2583       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2584
2585       xfree (email);
2586     }
2587
2588   xfree (fingerprint);
2589   return 0;
2590 }
2591
2592 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2593    the key id KEYID to POLICY.
2594
2595    If no key is available with the specified key id, then this
2596    function returns GPG_ERR_NO_PUBKEY.
2597
2598    Returns 0 on success and an error code otherwise.  */
2599 gpg_error_t
2600 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2601 {
2602   kbnode_t keyblock = get_pubkeyblock (keyid);
2603   if (! keyblock)
2604     return gpg_error (GPG_ERR_NO_PUBKEY);
2605
2606   return tofu_set_policy (ctrl, keyblock, policy);
2607 }
2608
2609 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2610    policy has been set for the binding, sets *POLICY to
2611    TOFU_POLICY_NONE.
2612
2613    PK is a primary public key and USER_ID is a user id.
2614
2615    Returns 0 on success and an error code otherwise.  */
2616 gpg_error_t
2617 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2618                  enum tofu_policy *policy)
2619 {
2620   tofu_dbs_t dbs;
2621   char *fingerprint;
2622   char *email;
2623
2624   /* Make sure PK is a primary key.  */
2625   log_assert (pk->main_keyid[0] == pk->keyid[0]
2626               && pk->main_keyid[1] == pk->keyid[1]);
2627
2628   dbs = opendbs (ctrl);
2629   if (! dbs)
2630     {
2631       log_error (_("error opening TOFU database: %s\n"),
2632                  gpg_strerror (GPG_ERR_GENERAL));
2633       return gpg_error (GPG_ERR_GENERAL);
2634     }
2635
2636   fingerprint = hexfingerprint (pk, NULL, 0);
2637
2638   email = email_from_user_id (user_id->name);
2639
2640   *policy = get_policy (dbs, fingerprint, email, NULL);
2641
2642   xfree (email);
2643   xfree (fingerprint);
2644   if (*policy == _tofu_GET_POLICY_ERROR)
2645     return gpg_error (GPG_ERR_GENERAL);
2646   return 0;
2647 }