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