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