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