gpg: Avoid endless loop in a tofu error case.
[gnupg.git] / g10 / trustdb.c
index 1be98b5..527a23d 100644 (file)
@@ -22,7 +22,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 
 #ifndef DISABLE_REGEX
 #include <sys/types.h>
@@ -71,7 +70,7 @@ static struct key_item *utk_list;      /* all ultimately trusted keys */
 
 static int pending_check_trustdb;
 
-static int validate_keys (int interactive);
+static int validate_keys (ctrl_t ctrl, int interactive);
 
 \f
 /**********************************************
@@ -379,16 +378,16 @@ do_sync(void)
       }
 }
 
-static const char *
-trust_model_string(void)
+const char *
+trust_model_string (int model)
 {
-  switch(opt.trust_model)
+  switch (model)
     {
     case TM_CLASSIC:  return "classic";
-    case TM_PGP:      return "PGP";
+    case TM_PGP:      return "pgp";
     case TM_EXTERNAL: return "external";
-    case TM_TOFU:     return "TOFU";
-    case TM_TOFU_PGP: return "TOFU+PGP";
+    case TM_TOFU:     return "tofu";
+    case TM_TOFU_PGP: return "tofu+pgp";
     case TM_ALWAYS:   return "always";
     case TM_DIRECT:   return "direct";
     default:          return "unknown";
@@ -421,13 +420,13 @@ how_to_fix_the_trustdb ()
 
   log_info (_("You may try to re-create the trustdb using the commands:\n"));
   log_info ("  cd %s\n", default_homedir ());
-  log_info ("  gpg2 --export-ownertrust > otrust.tmp\n");
+  log_info ("  %s --export-ownertrust > otrust.tmp\n", GPG_NAME);
 #ifdef HAVE_W32_SYSTEM
   log_info ("  del %s\n", name);
 #else
   log_info ("  rm %s\n", name);
 #endif
-  log_info ("  gpg2 --import-ownertrust < otrust.tmp\n");
+  log_info ("  %s --import-ownertrust < otrust.tmp\n", GPG_NAME);
   log_info (_("If that does not work, please consult the manual\n"));
 }
 
@@ -459,20 +458,24 @@ init_trustdb ()
       opt.trust_model=tdbio_read_model();
 
       /* Sanity check this ;) */
-      if(opt.trust_model!=TM_CLASSIC
-        && opt.trust_model!=TM_PGP
-        && opt.trust_model!=TM_EXTERNAL)
+      if(opt.trust_model != TM_CLASSIC
+        && opt.trust_model != TM_PGP
+        && opt.trust_model != TM_TOFU_PGP
+        && opt.trust_model != TM_TOFU
+        && opt.trust_model != TM_EXTERNAL)
        {
          log_info(_("unable to use unknown trust model (%d) - "
-                    "assuming %s trust model\n"),opt.trust_model,"PGP");
-         opt.trust_model=TM_PGP;
+                    "assuming %s trust model\n"),opt.trust_model,"pgp");
+         opt.trust_model = TM_PGP;
        }
 
       if(opt.verbose)
-       log_info(_("using %s trust model\n"),trust_model_string());
+       log_info(_("using %s trust model\n"),
+                 trust_model_string (opt.trust_model));
     }
 
-  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+  if (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC
+      || opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
       /* Verify the list of ultimately trusted keys and move the
         --trusted-keys list there as well. */
@@ -491,10 +494,11 @@ init_trustdb ()
  * when a check is due.  This can be used to run the check from a crontab
  */
 void
-check_trustdb ()
+check_trustdb (ctrl_t ctrl)
 {
   init_trustdb();
-  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+  if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
     {
       if (opt.batch && !opt.answer_yes)
        {
@@ -515,11 +519,11 @@ check_trustdb ()
            }
        }
 
-      validate_keys (0);
+      validate_keys (ctrl, 0);
     }
   else
     log_info (_("no need for a trustdb check with '%s' trust model\n"),
-             trust_model_string());
+             trust_model_string(opt.trust_model));
 }
 
 
@@ -527,14 +531,15 @@ check_trustdb ()
  * Recreate the WoT.
  */
 void
-update_trustdb()
+update_trustdb (ctrl_t ctrl)
 {
-  init_trustdb();
-  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
-    validate_keys (1);
+  init_trustdb ();
+  if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
+    validate_keys (ctrl, 1);
   else
     log_info (_("no need for a trustdb update with '%s' trust model\n"),
-             trust_model_string());
+             trust_model_string(opt.trust_model));
 }
 
 void
@@ -560,14 +565,14 @@ trustdb_pending_check(void)
 /* If the trustdb is dirty, and we're interactive, update it.
    Otherwise, check it unless no-auto-check-trustdb is set. */
 void
-tdb_check_or_update (void)
+tdb_check_or_update (ctrl_t ctrl)
 {
-  if(trustdb_pending_check())
+  if (trustdb_pending_check ())
     {
-      if(opt.interactive)
-       update_trustdb();
-      else if(!opt.no_auto_check_trustdb)
-       check_trustdb();
+      if (opt.interactive)
+       update_trustdb (ctrl);
+      else if (!opt.no_auto_check_trustdb)
+       check_trustdb (ctrl);
     }
 }
 
@@ -719,7 +724,6 @@ tdb_update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
       write_record (&rec);
       tdb_revalidation_mark ();
       do_sync ();
-      err = 0;
     }
   else
     {
@@ -777,7 +781,6 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
       write_record (&rec);
       tdb_revalidation_mark ();
       do_sync ();
-      err = 0;
     }
   else
     {
@@ -853,7 +856,6 @@ update_validity (PKT_public_key *pk, PKT_user_id *uid,
       /* No record yet - create a new one. */
       size_t dummy;
 
-      err = 0;
       memset (&trec, 0, sizeof trec);
       trec.recnum = tdbio_new_recnum ();
       trec.rectype = RECTYPE_TRUST;
@@ -936,7 +938,7 @@ tdb_cache_disabled_value (PKT_public_key *pk)
 
 
 void
-tdb_check_trustdb_stale (void)
+tdb_check_trustdb_stale (ctrl_t ctrl)
 {
   static int did_nextcheck=0;
 
@@ -946,7 +948,8 @@ tdb_check_trustdb_stale (void)
     return;  /* No trustdb => can't be stale.  */
 
   if (!did_nextcheck
-      && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
+      && (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+          || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU))
     {
       ulong scheduled;
 
@@ -965,7 +968,7 @@ tdb_check_trustdb_stale (void)
             {
               if (!opt.quiet)
                 log_info (_("checking the trustdb\n"));
-              validate_keys (0);
+              validate_keys (ctrl, 0);
             }
         }
     }
@@ -978,7 +981,8 @@ tdb_check_trustdb_stale (void)
  * by the TOFU code to record statistics.
  */
 unsigned int
-tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
+tdb_get_validity_core (ctrl_t ctrl,
+                       PKT_public_key *pk, PKT_user_id *uid,
                        PKT_public_key *main_pk,
                       PKT_signature *sig,
                       int may_ask)
@@ -986,9 +990,16 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
   TRUSTREC trec, vrec;
   gpg_error_t err;
   ulong recno;
+#ifdef USE_TOFU
   unsigned int tofu_validity = TRUST_UNKNOWN;
+#endif
   unsigned int validity = TRUST_UNKNOWN;
 
+#ifndef USE_TOFU
+  (void)sig;
+  (void)may_ask;
+#endif
+
   init_trustdb ();
 
   /* If we have no trustdb (which also means it has not been created)
@@ -998,7 +1009,7 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return TRUST_UNKNOWN;
 
-  check_trustdb_stale();
+  check_trustdb_stale (ctrl);
 
   if(opt.trust_model==TM_DIRECT)
     {
@@ -1015,12 +1026,6 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
       int user_ids = 0;
       int user_ids_expired = 0;
 
-      char fingerprint[MAX_FINGERPRINT_LEN];
-      size_t fingerprint_len = sizeof (fingerprint);
-
-      fingerprint_from_pk (main_pk, fingerprint, &fingerprint_len);
-      assert (fingerprint_len == sizeof (fingerprint));
-
       /* If the caller didn't supply a user id then iterate over all
         uids.  */
       if (! uid)
@@ -1037,18 +1042,22 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
          else
            user_id = user_id_node->pkt->pkt.user_id;
 
+          /* If the user id is revoked or expired, then skip it.  */
          if (user_id->is_revoked || user_id->is_expired)
-           /* If the user id is revoked or expired, then skip it.  */
            {
-             char *s;
-             if (user_id->is_revoked && user_id->is_expired)
-               s = "revoked and expired";
-             else if (user_id->is_revoked)
-               s = "revoked";
-             else
-               s = "expire";
-
-             log_info ("TOFU: Ignoring %s user id (%s)\n", s, user_id->name);
+              if (DBG_TRUST)
+                {
+                  char *s;
+                  if (user_id->is_revoked && user_id->is_expired)
+                    s = "revoked and expired";
+                  else if (user_id->is_revoked)
+                    s = "revoked";
+                  else
+                    s = "expire";
+
+                  log_debug ("TOFU: Ignoring %s user id (%s)\n",
+                             s, user_id->name);
+                }
 
              continue;
            }
@@ -1056,12 +1065,12 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
          user_ids ++;
 
          if (sig)
-           tl = tofu_register (fingerprint, user_id->name,
+           tl = tofu_register (ctrl, main_pk, user_id->name,
                                sig->digest, sig->digest_len,
                                sig->timestamp, "unknown",
                                may_ask);
          else
-           tl = tofu_get_validity (fingerprint, user_id->name, may_ask);
+           tl = tofu_get_validity (ctrl, main_pk, user_id->name, may_ask);
 
          if (tl == TRUST_EXPIRED)
            user_ids_expired ++;
@@ -1071,9 +1080,9 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
            tofu_validity = TRUST_NEVER;
          else
            {
-             assert (tl == TRUST_MARGINAL
-                     || tl == TRUST_FULLY
-                     || tl == TRUST_ULTIMATE);
+             log_assert (tl == TRUST_MARGINAL
+                          || tl == TRUST_FULLY
+                          || tl == TRUST_ULTIMATE);
 
              if (tl > tofu_validity)
                /* XXX: We we really want the max?  */
@@ -1259,7 +1268,7 @@ enum_cert_paths_print (void **context, FILE *fp,
  ****************************************/
 
 static int
-ask_ownertrust (u32 *kid,int minimum)
+ask_ownertrust (ctrl_t ctrl, u32 *kid, int minimum)
 {
   PKT_public_key *pk;
   int rc;
@@ -1283,7 +1292,7 @@ ask_ownertrust (u32 *kid,int minimum)
     }
   else
     {
-      ot=edit_ownertrust(pk,0);
+      ot=edit_ownertrust (ctrl, pk, 0);
       if(ot>0)
        ot = tdb_get_ownertrust (pk);
       else if(ot==0)
@@ -1573,7 +1582,8 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
              since we don't accept a regexp on the sig unless it's a
              trust sig. */
           if (kr && (!kr->trust_regexp
-                     || opt.trust_model != TM_PGP
+                     || !(opt.trust_model == TM_PGP
+                          || opt.trust_model == TM_TOFU_PGP)
                      || (uidnode
                          && check_regexp(kr->trust_regexp,
                                          uidnode->pkt->pkt.user_id->name))))
@@ -1583,7 +1593,8 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
                  lesser trust sig or value.  I could make a decent
                  argument for any of these cases, but this seems to be
                  what PGP does, and I'd like to be compatible. -dms */
-              if (opt.trust_model == TM_PGP
+              if ((opt.trust_model == TM_PGP
+                   || opt.trust_model == TM_TOFU_PGP)
                   && sig->trust_depth
                   && pk->trust_timestamp <= sig->timestamp)
                {
@@ -1721,9 +1732,8 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
     }
   if (rc)
     {
-      log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
-      xfree (keys);
-      return NULL;
+      log_error ("keydb_search(first) failed: %s\n", gpg_strerror (rc));
+      goto die;
     }
 
   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
@@ -1731,15 +1741,11 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
     {
       PKT_public_key *pk;
 
-      if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
-        continue;
-
       rc = keydb_get_keyblock (hd, &keyblock);
       if (rc)
         {
           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
-          xfree (keys);
-          return NULL;
+         goto die;
         }
 
       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
@@ -1790,18 +1796,21 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
       release_kbnode (keyblock);
       keyblock = NULL;
     }
-  while (!(rc = keydb_search (hd, &desc, 1, NULL))
-         || gpg_err_code (rc) == GPG_ERR_LEGACY_KEY);
+  while (!(rc = keydb_search (hd, &desc, 1, NULL)));
 
   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
     {
       log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
-      xfree (keys);
-      return NULL;
+      goto die;
     }
 
   keys[nkeys].keyblock = NULL;
   return keys;
+
+ die:
+  keys[nkeys].keyblock = NULL;
+  release_key_array (keys);
+  return NULL;
 }
 
 /* Caller must sync */
@@ -1838,8 +1847,14 @@ reset_trust_records(void)
     }
 
   if (opt.verbose)
-    log_info (_("%d keys processed (%d validity counts cleared)\n"),
-             count, nreset);
+    {
+      log_info (ngettext("%d key processed",
+                         "%d keys processed",
+                         count), count);
+      log_printf (ngettext(" (%d validity count cleared)\n",
+                           " (%d validity counts cleared)\n",
+                           nreset), nreset);
+    }
 }
 
 /*
@@ -1867,7 +1882,7 @@ reset_trust_records(void)
  *
  */
 static int
-validate_keys (int interactive)
+validate_keys (ctrl_t ctrl, int interactive)
 {
   int rc = 0;
   int quit=0;
@@ -1883,19 +1898,22 @@ validate_keys (int interactive)
   u32 start_time, next_expire;
 
   /* Make sure we have all sigs cached.  TODO: This is going to
-     require some architectual re-thinking, as it is agonizingly slow.
+     require some architectural re-thinking, as it is agonizingly slow.
      Perhaps combine this with reset_trust_records(), or only check
      the caches on keys that are actually involved in the web of
      trust. */
   keydb_rebuild_caches(0);
 
+  kdb = keydb_new ();
+  if (!kdb)
+    return gpg_error_from_syserror ();
+
   start_time = make_timestamp ();
   next_expire = 0xffffffff; /* set next expire to the year 2106 */
   stored = new_key_hash_table ();
   used = new_key_hash_table ();
   full_trust = new_key_hash_table ();
 
-  kdb = keydb_new ();
   reset_trust_records();
 
   /* Fixme: Instead of always building a UTK list, we could just build it
@@ -1938,10 +1956,17 @@ validate_keys (int interactive)
       do_sync ();
     }
 
+  if (opt.trust_model == TM_TOFU)
+    /* In the TOFU trust model, we only need to save the ultimately
+       trusted keys.  */
+    goto leave;
+
   klist = utk_list;
 
-  log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
-          opt.marginals_needed,opt.completes_needed,trust_model_string());
+  if (!opt.quiet)
+    log_info ("marginals needed: %d  completes needed: %d  trust model: %s\n",
+              opt.marginals_needed, opt.completes_needed,
+              trust_model_string (opt.trust_model));
 
   for (depth=0; depth < opt.max_cert_depth; depth++)
     {
@@ -1965,7 +1990,7 @@ validate_keys (int interactive)
 
           if (interactive && k->ownertrust == TRUST_UNKNOWN)
            {
-             k->ownertrust = ask_ownertrust (k->kid,min);
+             k->ownertrust = ask_ownertrust (ctrl, k->kid,min);
 
              if (k->ownertrust == (unsigned int)(-1))
                {
@@ -2026,10 +2051,11 @@ validate_keys (int interactive)
       for (kar=keys; kar->keyblock; kar++)
           store_validation_status (depth, kar->keyblock, stored);
 
-      log_info (_("depth: %d  valid: %3d  signed: %3d"
-                  "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
-                depth, valids, key_count, ot_unknown, ot_undefined,
-                ot_never, ot_marginal, ot_full, ot_ultimate );
+      if (!opt.quiet)
+        log_info (_("depth: %d  valid: %3d  signed: %3d"
+                    "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
+                  depth, valids, key_count, ot_unknown, ot_undefined,
+                  ot_never, ot_marginal, ot_full, ot_ultimate );
 
       /* Build a new kdlist from all fully valid keys in KEYS */
       if (klist != utk_list)
@@ -2084,26 +2110,31 @@ validate_keys (int interactive)
  leave:
   keydb_release (kdb);
   release_key_array (keys);
-  release_key_items (klist);
+  if (klist != utk_list)
+    release_key_items (klist);
   release_key_hash_table (full_trust);
   release_key_hash_table (used);
   release_key_hash_table (stored);
   if (!rc && !quit) /* mark trustDB as checked */
     {
+      int rc2;
+
       if (next_expire == 0xffffffff || next_expire < start_time )
         tdbio_write_nextcheck (0);
       else
         {
           tdbio_write_nextcheck (next_expire);
-          log_info (_("next trustdb check due at %s\n"),
-                    strtimestamp (next_expire));
+          if (!opt.quiet)
+            log_info (_("next trustdb check due at %s\n"),
+                      strtimestamp (next_expire));
         }
 
-      if(tdbio_update_version_record()!=0)
+      rc2 = tdbio_update_version_record ();
+      if (rc2)
        {
-         log_error(_("unable to update trustdb version record: "
-                     "write failed: %s\n"), gpg_strerror (rc));
-         tdbio_invalid();
+         log_error (_("unable to update trustdb version record: "
+                       "write failed: %s\n"), gpg_strerror (rc2));
+         tdbio_invalid ();
        }
 
       do_sync ();