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