pgpkey.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "private.h"
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "pgpkey.h"
#include "lib.h"
#include "editor/lib.h"
#include "history/lib.h"
#include "send/lib.h"
#include "crypt.h"
#include "globals.h"
#include "gnupgparse.h"
#include "module_data.h"
#include "mutt_logging.h"
#include "pgpinvoke.h"
#ifdef CRYPT_BACKEND_CLASSIC_PGP
#include "pgp.h"
#include "pgplib.h"
#endif

struct PgpCache
{
  char *what;            
  char *dflt;            
  struct PgpCache *next; 
};

enum PgpKeyValidFlag
{
  // clang-format off
  PGP_KV_NONE     =       0,  
  PGP_KV_VALID    = 1U << 0,  
  PGP_KV_ADDR     = 1U << 1,  
  PGP_KV_STRING   = 1U << 2,  
  PGP_KV_STRONGID = 1U << 3,  
  // clang-format on
};
typedef uint8_t PgpKeyValidFlags;
 
#define PGP_KV_MATCH (PGP_KV_ADDR | PGP_KV_STRING)

struct PgpKeyInfo *pgp_principal_key(struct PgpKeyInfo *key)
{
  if (key->flags & KEYFLAG_SUBKEY && key->parent)
    return key->parent;
  return key;
}

bool pgp_key_is_valid(struct PgpKeyInfo *k)
{
  struct PgpKeyInfo *pk = pgp_principal_key(k);
  if (k->flags & KEYFLAG_CANTUSE)
    return false;
  if (pk->flags & KEYFLAG_CANTUSE)
    return false;
 
  return true;
}

bool pgp_keys_are_valid(struct PgpKeyInfo *keys)
{
  for (struct PgpKeyInfo *k = keys; k != NULL; k = k->next)
  {
    if (!pgp_key_is_valid(k))
      return false;
  }
 
  return true;
}

bool pgp_id_is_strong(struct PgpUid *uid)
{
  if ((uid->trust & 3) < 3)
    return false;
  /* else */
  return true;
}

bool pgp_id_is_valid(struct PgpUid *uid)
{
  if (!pgp_key_is_valid(uid->parent))
    return false;
  if (uid->flags & KEYFLAG_CANTUSE)
    return false;
  /* else */
  return true;
}

static PgpKeyValidFlags pgp_id_matches_addr(struct Address *addr,
                                            struct Address *u_addr, struct PgpUid *uid)
{
  PgpKeyValidFlags flags = PGP_KV_NONE;
 
  if (pgp_id_is_valid(uid))
    flags |= PGP_KV_VALID;
 
  if (pgp_id_is_strong(uid))
    flags |= PGP_KV_STRONGID;
 
  if (addr->mailbox && u_addr->mailbox && buf_istr_equal(addr->mailbox, u_addr->mailbox))
  {
    flags |= PGP_KV_ADDR;
  }
 
  if (addr->personal && u_addr->personal &&
      buf_istr_equal(addr->personal, u_addr->personal))
  {
    flags |= PGP_KV_STRING;
  }
 
  return flags;
}

struct PgpKeyInfo *pgp_ask_for_key(char *tag, const char *whatfor,
                                   KeyFlags abilities, enum PgpRing keyring)
{
  struct NcryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NCRYPT);
  struct PgpKeyInfo *key = NULL;
  struct PgpCache *l = NULL;
  struct Buffer *resp = buf_pool_get();
 
  mutt_clear_error();
 
  if (whatfor)
  {
    for (l = (struct PgpCache *) mod_data->pgp_id_defaults; l; l = l->next)
    {
      if (mutt_istr_equal(whatfor, l->what))
      {
        buf_strcpy(resp, l->dflt);
        break;
      }
    }
  }
 
  while (true)
  {
    buf_reset(resp);
    if (mw_get_field(tag, resp, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0)
    {
      goto done;
    }
 
    if (whatfor)
    {
      if (l)
      {
        mutt_str_replace(&l->dflt, buf_string(resp));
      }
      else
      {
        l = MUTT_MEM_MALLOC(1, struct PgpCache);
        l->next = (struct PgpCache *) mod_data->pgp_id_defaults;
        mod_data->pgp_id_defaults = l;
        l->what = mutt_str_dup(whatfor);
        l->dflt = buf_strdup(resp);
      }
    }
 
    key = pgp_getkeybystr(buf_string(resp), abilities, keyring);
    if (key)
      goto done;
 
    mutt_error(_("No matching keys found for \"%s\""), buf_string(resp));
  }
 
done:
  buf_pool_release(&resp);
  return key;
}

struct Body *pgp_class_make_key_attachment(void)
{
  struct Body *att = NULL;
  char buf[1024] = { 0 };
  char tmp[256] = { 0 };
  struct stat st = { 0 };
  pid_t pid;
  OptPgpCheckTrust = false;
 
  struct PgpKeyInfo *key = pgp_ask_for_key(_("Please enter the key ID: "), NULL,
                                           KEYFLAG_NONE, PGP_PUBRING);
 
  if (!key)
    return NULL;
 
  snprintf(tmp, sizeof(tmp), "0x%s", pgp_fpr_or_lkeyid(pgp_principal_key(key)));
  pgp_key_free(&key);
 
  struct Buffer *tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  FILE *fp_tmp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_tmp)
  {
    mutt_perror(_("Can't create temporary file"));
    goto cleanup;
  }
 
  FILE *fp_null = mutt_file_fopen("/dev/null", "w");
  if (!fp_null)
  {
    mutt_perror(_("Can't open /dev/null"));
    mutt_file_fclose(&fp_tmp);
    unlink(buf_string(tempfile));
    goto cleanup;
  }
 
  mutt_message(_("Invoking PGP..."));
 
  pid = pgp_invoke_export(NULL, NULL, NULL, -1, fileno(fp_tmp), fileno(fp_null), tmp);
  if (pid == -1)
  {
    mutt_perror(_("Can't create filter"));
    unlink(buf_string(tempfile));
    mutt_file_fclose(&fp_tmp);
    mutt_file_fclose(&fp_null);
    goto cleanup;
  }
 
  filter_wait(pid);
 
  mutt_file_fclose(&fp_tmp);
  mutt_file_fclose(&fp_null);
 
  att = mutt_body_new();
  att->filename = buf_strdup(tempfile);
  att->unlink = true;
  att->use_disp = false;
  att->type = TYPE_APPLICATION;
  att->subtype = mutt_str_dup("pgp-keys");
  snprintf(buf, sizeof(buf), _("PGP Key %s"), tmp);
  att->description = mutt_str_dup(buf);
  mutt_update_encoding(att, NeoMutt->sub);
 
  stat(buf_string(tempfile), &st);
  att->length = st.st_size;
 
cleanup:
  buf_pool_release(&tempfile);
  return att;
}

static void pgp_add_string_to_hints(const char *str, struct ListHead *hints)
{
  char *scratch = mutt_str_dup(str);
  if (!scratch)
    return;
 
  for (char *t = strtok(scratch, " ,.:\"()<>\n"); t; t = strtok(NULL, " ,.:\"()<>\n"))
  {
    if (strlen(t) > 3)
      mutt_list_insert_tail(hints, mutt_str_dup(t));
  }
 
  FREE(&scratch);
}

static struct PgpKeyInfo **pgp_get_lastp(struct PgpKeyInfo *p)
{
  for (; p; p = p->next)
    if (!p->next)
      return &p->next;
 
  return NULL;
}

struct PgpKeyInfo *pgp_getkeybyaddr(struct Address *a, KeyFlags abilities,
                                    enum PgpRing keyring, bool oppenc_mode)
{
  if (!a)
    return NULL;
 
  struct ListHead hints = STAILQ_HEAD_INITIALIZER(hints);
 
  bool multi = false;
 
  struct PgpKeyInfo *keys = NULL, *k = NULL, *kn = NULL;
  struct PgpKeyInfo *the_strong_valid_key = NULL;
  struct PgpKeyInfo *a_valid_addrmatch_key = NULL;
  struct PgpKeyInfo *matches = NULL;
  struct PgpKeyInfo **last = &matches;
  struct PgpUid *q = NULL;
 
  if (a->mailbox)
    mutt_list_insert_tail(&hints, buf_strdup(a->mailbox));
  if (a->personal)
    pgp_add_string_to_hints(buf_string(a->personal), &hints);
 
  if (!oppenc_mode)
    mutt_message(_("Looking for keys matching \"%s\"..."), buf_string(a->mailbox));
  keys = pgp_get_candidates(keyring, &hints);
 
  mutt_list_free(&hints);
 
  if (!keys)
    return NULL;
 
  mutt_debug(LL_DEBUG5, "looking for %s <%s>\n", buf_string(a->personal),
             buf_string(a->mailbox));
 
  for (k = keys; k; k = kn)
  {
    kn = k->next;
 
    mutt_debug(LL_DEBUG5, "  looking at key: %s\n", pgp_keyid(k));
 
    if (abilities && !(k->flags & abilities))
    {
      mutt_debug(LL_DEBUG3, "  insufficient abilities: Has %x, want %x\n", k->flags, abilities);
      continue;
    }
 
    bool match = false; /* any match */
 
    for (q = k->address; q; q = q->next)
    {
      struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
      mutt_addrlist_parse(&al, NONULL(q->addr));
      struct Address *qa = NULL;
      TAILQ_FOREACH(qa, &al, entries)
      {
        PgpKeyValidFlags validity = pgp_id_matches_addr(a, qa, q);
 
        if (validity & PGP_KV_MATCH) /* something matches */
          match = true;
 
        if ((validity & PGP_KV_VALID) && (validity & PGP_KV_ADDR))
        {
          if (validity & PGP_KV_STRONGID)
          {
            if (the_strong_valid_key && (the_strong_valid_key != k))
              multi = true;
            the_strong_valid_key = k;
          }
          else
          {
            a_valid_addrmatch_key = k;
          }
        }
      }
 
      mutt_addrlist_clear(&al);
    }
 
    if (match)
    {
      *last = pgp_principal_key(k);
      kn = pgp_remove_key(&keys, *last);
      last = pgp_get_lastp(k);
    }
  }
 
  pgp_key_free(&keys);
 
  if (matches)
  {
    if (oppenc_mode || !isatty(STDIN_FILENO))
    {
      const bool c_crypt_opportunistic_encrypt_strong_keys =
          cs_subset_bool(NeoMutt->sub, "crypt_opportunistic_encrypt_strong_keys");
      if (the_strong_valid_key)
      {
        pgp_remove_key(&matches, the_strong_valid_key);
        k = the_strong_valid_key;
      }
      else if (a_valid_addrmatch_key && !c_crypt_opportunistic_encrypt_strong_keys)
      {
        pgp_remove_key(&matches, a_valid_addrmatch_key);
        k = a_valid_addrmatch_key;
      }
      else
      {
        k = NULL;
      }
    }
    else if (the_strong_valid_key && !multi)
    {
      /* There was precisely one strong match on a valid ID.
       * Proceed without asking the user.  */
      pgp_remove_key(&matches, the_strong_valid_key);
      k = the_strong_valid_key;
    }
    else
    {
      /* Else: Ask the user.  */
      k = dlg_pgp(matches, a, NULL);
      if (k)
        pgp_remove_key(&matches, k);
    }
 
    pgp_key_free(&matches);
 
    return k;
  }
 
  return NULL;
}

struct PgpKeyInfo *pgp_getkeybystr(const char *cp, KeyFlags abilities, enum PgpRing keyring)
{
  struct ListHead hints = STAILQ_HEAD_INITIALIZER(hints);
  struct PgpKeyInfo *keys = NULL;
  struct PgpKeyInfo *matches = NULL;
  struct PgpKeyInfo **last = &matches;
  struct PgpKeyInfo *k = NULL, *kn = NULL;
  struct PgpUid *a = NULL;
  size_t l;
  const char *ps = NULL, *pl = NULL, *pfcopy = NULL, *phint = NULL;
 
  char *p = strdup(cp); // mutt_str_dup converts "" into NULL, see #1809
  l = mutt_str_len(p);
  if ((l > 0) && (p[l - 1] == '!'))
    p[l - 1] = 0;
 
  mutt_message(_("Looking for keys matching \"%s\"..."), p);
 
  pfcopy = crypt_get_fingerprint_or_id(p, &phint, &pl, &ps);
  pgp_add_string_to_hints(phint, &hints);
  keys = pgp_get_candidates(keyring, &hints);
  mutt_list_free(&hints);
 
  for (k = keys; k; k = kn)
  {
    kn = k->next;
    if (abilities && !(k->flags & abilities))
      continue;
 
    /* This shouldn't happen, but keys without any addresses aren't selectable
     * in dlg_pgp().  */
    if (!k->address)
      continue;
 
    bool match = false;
 
    mutt_debug(LL_DEBUG5, "matching \"%s\" against key %s:\n", p, pgp_long_keyid(k));
 
    if ((*p == '\0') || (pfcopy && mutt_istr_equal(pfcopy, k->fingerprint)) ||
        (pl && mutt_istr_equal(pl, pgp_long_keyid(k))) ||
        (ps && mutt_istr_equal(ps, pgp_short_keyid(k))))
    {
      mutt_debug(LL_DEBUG5, "        match #1\n");
      match = true;
    }
    else
    {
      for (a = k->address; a; a = a->next)
      {
        mutt_debug(LL_DEBUG5, "matching \"%s\" against key %s, \"%s\":\n", p,
                   pgp_long_keyid(k), NONULL(a->addr));
        if (mutt_istr_find(a->addr, p))
        {
          mutt_debug(LL_DEBUG5, "        match #2\n");
          match = true;
          break;
        }
      }
    }
 
    if (match)
    {
      *last = pgp_principal_key(k);
      kn = pgp_remove_key(&keys, *last);
      last = pgp_get_lastp(k);
    }
  }
 
  pgp_key_free(&keys);
 
  k = NULL;
  if (matches)
  {
    if (isatty(STDIN_FILENO))
    {
      k = dlg_pgp(matches, NULL, p);
      if (k)
        pgp_remove_key(&matches, k);
      pgp_key_free(&matches);
    }
    else if (pgp_keys_are_valid(matches))
    {
      k = matches;
    }
    else
    {
      mutt_error(_("A key can't be used: expired/disabled/revoked"));
    }
  }
 
  FREE(&pfcopy);
  FREE(&p);
  return k;
}

void pgp_id_defaults_cleanup(struct PgpCache **pgp_id_defaults)
{
  struct PgpCache *l = *pgp_id_defaults;
  while (l)
  {
    struct PgpCache *next = l->next;
    FREE(&l->what);
    FREE(&l->dflt);
    FREE(&l);
    l = next;
  }
  *pgp_id_defaults = NULL;
}