SAVE: Obtain the public key after key generation.

[libpwmd.git] / src / crypto.c

/*
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015,
    2016
    Ben Kibbey <bjk@luxsci.net>

    This file is part of pwmd.

    Pwmd is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    Pwmd is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#ifdef WITH_LIBACL
#include <sys/acl.h>
#endif

#include "pwmd-error.h"
#include "util-misc.h"
#include "common.h"
#include "rcfile.h"
#include "crypto.h"
#include "cache.h"
#include "mem.h"
#include "util-string.h"
#include "rcfile.h"

static int keepalive;

#define BUFSIZE 4096

#define STATUS_TIMEOUT_INIT(crypto) \
  do { \
      crypto->status_timeout = time (NULL); \
      crypto->progress_rc = 0; \
  } while (0)

#define STATUS_TIMEOUT_TEST(crypto, rc, s, line) \
  do { \
      time_t now = time (NULL); \
      if (now - crypto->status_timeout >= keepalive && crypto->client_ctx) { \
        rc = send_status (crypto->client_ctx, s, line); \
        crypto->status_timeout = now; \
      } \
  } while (0)

#if 0
static gpgme_error_t
show_key_output (gpgme_key_t key)
{
  gpgme_subkey_t keyp; // first is primary

  for (keyp = key->subkeys; keyp; keyp = keyp->next)
    {
      fprintf(stderr, "keyid: %s, revoked: %i, expired: %i, disabled: %i, invalid: %i,"
              "encrypt: %i, sign: %i, cert: %i, auth: %i, secret: %i\n",
              keyp->keyid, keyp->revoked, keyp->expired, keyp->disabled,
              keyp->invalid, keyp->can_encrypt, keyp->can_sign,
              keyp->can_certify, keyp->can_authenticate, keyp->secret);
    }

  return 0;
}
#endif

static gpg_error_t
get_password (const char *keyfile, unsigned char **result, size_t *len)
{
  struct stat st;
  int fd;
  unsigned char *buf = NULL;
  gpg_error_t rc = 0;

  log_write (_ ("obtaining passphrase from passphrase file"));
  if (stat (keyfile, &st) == -1)
    return gpg_error_from_syserror ();

  fd = open (keyfile, O_RDONLY);
  if (fd == -1)
    return gpg_error_from_syserror ();

  buf = xmalloc (st.st_size+1);
  if (buf)
    {
      size_t rlen = read (fd, buf, st.st_size);

      if (rlen != st.st_size)
        rc = GPG_ERR_ASS_READ_ERROR;
      else
        {
          buf[rlen] = 0;
          if (rlen && strlen ((char *)buf) != rlen)
            rc = GPG_ERR_INV_PASSPHRASE;

          if (!rc)
            {
              *result = buf;
              *len = rlen;
            }
        }
    }
  else
    rc = GPG_ERR_ENOMEM;

  close (fd);
  if (rc)
    xfree (buf);

  return rc;
}

static gpgme_error_t
status_cb (void *data, const char *keyword, const char *args)
{
  struct crypto_s *crypto = data;

  // Cache pushing.
  if (!crypto->client_ctx)
    return 0;

  if (!strcmp (keyword, "INQUIRE_MAXLEN") &&
      (crypto->flags & CRYPTO_FLAG_KEYFILE))
    return 0;

  return assuan_write_status (crypto->client_ctx, keyword, args);
}

static gpgme_error_t
passphrase_cb (void *data, const char *hint, const char *info, int bad, int fd)
{
  struct crypto_s *crypto = data;
  unsigned char *result = NULL;
  size_t len;
  gpg_error_t rc = 0;

  if (crypto->flags & CRYPTO_FLAG_KEYFILE)
    rc = get_password (crypto->keyfile, &result, &len);
  else
    {
      if (hint)
        rc = assuan_write_status (crypto->client_ctx, "PASSPHRASE_HINT", hint);

      if (!rc && info)
        rc = assuan_write_status (crypto->client_ctx, "PASSPHRASE_INFO", info);

      if (!rc)
        {
          char *keyword = "PASSPHRASE";

          /* FIXME: how to handle multiple signers */
          if (!bad && crypto->flags & CRYPTO_FLAG_PASSWD_SIGN)
              keyword = "SIGN_PASSPHRASE";
          else if (!bad && crypto->flags & CRYPTO_FLAG_PASSWD_NEW)
            {
              crypto->flags |= CRYPTO_FLAG_PASSWD_SIGN;
              keyword = "NEW_PASSPHRASE";
            }
          else if (!bad && crypto->flags & CRYPTO_FLAG_PASSWD)
            crypto->flags |= CRYPTO_FLAG_PASSWD_NEW;
          else if (!bad && crypto->flags & CRYPTO_FLAG_NEWFILE)
            {
              keyword = "NEW_PASSPHRASE";
              if (crypto->save.sigkey)
                crypto->flags |= CRYPTO_FLAG_PASSWD_SIGN;
            }

          rc = assuan_inquire (crypto->client_ctx, keyword, &result, &len, 0);
        }
    }

  if (!rc)
    {
      pthread_cleanup_push ((void *)xfree, result);

      if (!len)
        gpgme_io_writen (fd, "\n", 1);
      else
        {
          int nl = result[len-1] == '\n';
          int ret;

          ret = gpgme_io_writen (fd, result, len);
          if (!ret && !nl)
            gpgme_io_writen (fd, "\n", 1);
          else if (ret)
            rc = GPG_ERR_CANCELED;
        }

      pthread_cleanup_pop (1);
    }

  return rc;
}

static void
progress_cb (void *data, const char *what, int type, int current, int total)
{
  struct crypto_s *crypto = data;
  
  crypto->progress_rc = send_status (crypto->client_ctx, STATUS_GPGME,
                                     "%s %i %i %i", what, type, current, total);
}

gpgme_error_t
crypto_data_to_buf (const gpgme_data_t data, unsigned char **result,
                    size_t *rlen)
{
  off_t ret = gpgme_data_seek (data, 0, SEEK_SET);
  gpgme_error_t rc;
  size_t total = 0, size = BUFSIZE;
  unsigned char *buf;

  if (ret == -1)
    return gpg_error_from_syserror ();

  buf = xmalloc (size);
  if (!buf)
    return GPG_ERR_ENOMEM;

  do
    {
      pthread_cleanup_push ((void *)xfree, buf);
      ret = gpgme_data_read (data, &buf[total], BUFSIZE);
      pthread_cleanup_pop (0);
      if (ret > 0)
        {
          unsigned char *p;

          total += ret;
          size += BUFSIZE;
          p = xrealloc (buf, size * sizeof(char));
          if (!p)
            {
              xfree (buf);
              return GPG_ERR_ENOMEM;
            }

          buf = p;
        }
    } while (ret > 0);

  if (ret == -1)
    {
      rc = gpgme_err_code_from_syserror ();
      xfree (buf);
      return rc;
    }

  *result = buf;
  *rlen = total;
  return 0;
}

static void
crypto_cancel_gpgme (void *data)
{
  struct crypto_s *crypto = data;
  struct client_s *client = assuan_get_pointer (crypto->client_ctx);
  gpgme_error_t rc = 0;

  if (client)
    update_client_state (client, CLIENT_STATE_DISCON);

  gpgme_cancel_async (crypto->ctx);
  while (!gpgme_wait (crypto->ctx, &rc, 0) && !rc)
    log_write1 (_ ("waiting for operation to finish"));
}

gpgme_error_t
crypto_list_keys (struct crypto_s *crypto, char *keys[], int secret,
                  gpgme_key_t **result)
{
  gpgme_error_t rc;
  gpgme_key_t key = NULL, *res = NULL;
  size_t total = 0;

  STATUS_TIMEOUT_INIT (crypto);
  rc = gpgme_op_keylist_ext_start (crypto->ctx, (const char **)keys, secret, 0);
  if (rc)
    return rc;

  pthread_cleanup_push ((void *)crypto_cancel_gpgme, crypto);

  do
    {
      gpgme_key_t *p;

      pthread_cleanup_push ((void *)crypto_free_key_list, res);
      rc = gpgme_op_keylist_next (crypto->ctx, &key);
      pthread_cleanup_pop (0);
      if (rc && gpgme_err_code(rc) != GPG_ERR_EOF)
        break;

      if (rc)
        {
          rc = 0;
          break;
        }

      p = xrealloc (res, (total+2) * sizeof (gpgme_key_t));
      if (!p)
        {
          rc = GPG_ERR_ENOMEM;
          break;
        }

      res = p;
      res[total++] = key;
      res[total] = NULL;
      pthread_cleanup_push ((void *)crypto_free_key_list, res);
      STATUS_TIMEOUT_TEST (crypto, rc, STATUS_KEEPALIVE, NULL);
      pthread_cleanup_pop (0);
    } while (!rc);

  pthread_cleanup_pop (0);

  if (!rc)
    {
      rc = gpgme_op_keylist_end (crypto->ctx);
      if (!rc)
        {
          *result = res;
          rc = total ? 0 : secret ? GPG_ERR_NO_SECKEY : GPG_ERR_NO_PUBKEY;
        }
    }
  else
    crypto_free_key_list (res);

  return rc;
}

void
crypto_free_save (struct save_s *save)
{
  if (!save)
    return;

  strv_free (save->pubkey);
  strv_free (save->sigkey);
  memset (save, 0, sizeof (struct save_s));
}

static gpg_error_t
crypto_kill_scd ()
{
  return cache_kill_scd ();
}

static void
free_gpgme_data_cb (void *data)
{
  gpgme_data_t d = data;
  char *t;
  size_t len;

  if (!data)
    return;

  t = gpgme_data_release_and_get_mem (d, &len);
  if (t)
    wipememory (t, 0, len);

  gpgme_free (t);
}

void
crypto_free_non_keys (struct crypto_s *crypto)
{
  if (!crypto)
    return;

  if (crypto->ctx)
    gpgme_release (crypto->ctx);

  crypto->ctx = NULL;
  xfree (crypto->plaintext);
  crypto->plaintext = NULL;
  crypto->plaintext_size = 0;

  if (crypto->cipher)
    free_gpgme_data_cb (crypto->cipher);

  crypto->cipher = NULL;
  crypto_free_save (&crypto->save);
  xfree (crypto->keyfile);
  crypto->keyfile = NULL;
  crypto->flags &= ~CRYPTO_FLAG_KEYFILE;
  (void)crypto_kill_scd ();
}

void
crypto_free (struct crypto_s *crypto)
{
  if (!crypto)
    return;

  crypto_free_non_keys (crypto);
  strv_free (crypto->pubkey);
  strv_free (crypto->sigkey);
  xfree (crypto->filename);
  xfree (crypto);
}

gpgme_error_t
crypto_init_ctx (struct crypto_s *crypto, int no_pinentry,
                 char *passphrase_file)
{
  gpgme_ctx_t ctx;
  gpgme_keylist_mode_t keylist_mode;
  gpgme_error_t rc;

  rc = gpgme_new (&ctx);
  if (rc)
    return rc;

  rc = gpgme_set_protocol (ctx, GPGME_PROTOCOL_OPENPGP);
  if (!rc)
    {
      keylist_mode = gpgme_get_keylist_mode (ctx);
      keylist_mode |= GPGME_KEYLIST_MODE_LOCAL|GPGME_KEYLIST_MODE_WITH_SECRET;
      rc = gpgme_set_keylist_mode (ctx, keylist_mode);
      if (!rc)
         {
           if (no_pinentry || passphrase_file)
             rc = gpgme_set_pinentry_mode (ctx, GPGME_PINENTRY_MODE_LOOPBACK);
           else
             rc = gpgme_set_pinentry_mode (ctx, GPGME_PINENTRY_MODE_DEFAULT);

           if (!rc)
             {
               gpgme_set_passphrase_cb (ctx, passphrase_cb, crypto);
               gpgme_set_progress_cb (ctx, progress_cb, crypto);
               gpgme_set_status_cb (ctx, status_cb, crypto);
               crypto->ctx = ctx;
               crypto->flags = 0;
             }

           if (passphrase_file)
             {
               crypto->keyfile = passphrase_file;
               crypto->flags |= CRYPTO_FLAG_KEYFILE;
             }
         }
    }

  if (rc)
    gpgme_release (ctx);

  return rc;
}

void
crypto_set_keepalive ()
{
  keepalive = config_get_integer ("global", "keepalive_interval");
}

gpg_error_t
crypto_init (struct crypto_s **crypto, void *ctx, const char *filename,
             int no_pinentry, char *passphrase_file)
{
  struct crypto_s *new = xcalloc (1, sizeof (struct crypto_s));
  gpgme_error_t rc;

  crypto_set_keepalive ();

  if (!new)
    return GPG_ERR_ENOMEM;

  rc = crypto_init_ctx (new, no_pinentry, passphrase_file);
  if (rc)
    goto fail;

  if (filename)
    {
      new->filename = str_dup (filename);
      if (!new->filename)
        {
          rc = GPG_ERR_ENOMEM;
          goto fail;
        }
    }

  new->client_ctx = ctx;
  *crypto = new;
  return 0;

fail:
  crypto_free (new);
  return rc;
}

/* Converts a 40 byte key id to the 16 byte form. Needed for comparison of
 * gpgme_subkey_t->fpr. */
void
crypto_keyid_to_16b (char **keys)
{
  char **p;

  for (p = keys; p && *p; p++)
    {
      char *t = *p;
      size_t len = strlen (t);

      memmove (&t[0], &t[len-16], 16);
      t[16] = 0;
    }
}

gpgme_error_t
crypto_decrypt (struct client_s *client, struct crypto_s *crypto)
{
  gpgme_data_t plain;
  gpgme_error_t rc;
  gpgme_data_t cipher;
  int fd;
  char **new_recipients = NULL;
  char **new_signers = NULL;
  char **pp;
  gpgme_decrypt_result_t result;

  rc = gpgme_data_new (&plain);
  if (rc)
    return rc;

  pthread_cleanup_push ((void *)free_gpgme_data_cb, plain);
  fd = open (crypto->filename, O_RDONLY);
  if (fd != -1)
    {
      pthread_cleanup_push ((void *)cleanup_fd_cb, &fd);
      rc = gpgme_data_new_from_fd (&cipher, fd);
      if (!rc)
        {
          pthread_cleanup_push ((void *)free_gpgme_data_cb, cipher);
          STATUS_TIMEOUT_INIT(crypto);
          rc = send_status (client ? client->ctx : NULL, STATUS_DECRYPT, NULL);
          if (!rc)
            rc = gpgme_op_decrypt_verify_start (crypto->ctx, cipher, plain);

          if (!rc)
            {
              pthread_cleanup_push ((void *)crypto_cancel_gpgme, crypto);

              do
                {
                  if (!rc && crypto->progress_rc)
                    rc = crypto->progress_rc;

                  if (!rc)
                    STATUS_TIMEOUT_TEST (crypto, rc, STATUS_DECRYPT, NULL);

                  if (rc)
                    break;
                } while (!gpgme_wait (crypto->ctx, &rc, 0) && !rc);

              pthread_cleanup_pop (0); // cancellation
            }

          pthread_cleanup_pop (1); // free_gpgme_data_cb (cipher)
        }

      pthread_cleanup_pop (1); // close (fd)
    }
  else
    rc = gpgme_err_code_from_syserror ();

  pthread_cleanup_pop (0); // free_gpgme_data_cb (plain)

  if (rc)
    {
      free_gpgme_data_cb (plain);
      return rc;
    }

  pthread_cleanup_push ((void *)free_gpgme_data_cb, plain);
  result = gpgme_op_decrypt_result (crypto->ctx);
  if (!result->unsupported_algorithm && !result->wrong_key_usage)
    {
      gpgme_recipient_t r;

      for (r = result->recipients; r; r = r->next)
        {
          pthread_cleanup_push ((void *)strv_free, new_recipients);
          log_write1 (_ ("%s: recipient: %s, status=%u"),
                      crypto->filename, r->keyid, r->status);
          pthread_cleanup_pop (0);
          pp = strv_cat(new_recipients, str_dup (r->keyid));
          if (!pp)
            {
              rc = GPG_ERR_ENOMEM;
              break;
            }

          new_recipients = pp;
        }
    }
  else if (result->wrong_key_usage)
    rc = GPG_ERR_WRONG_KEY_USAGE;
  else if (result->unsupported_algorithm)
    rc = GPG_ERR_UNSUPPORTED_ALGORITHM;

  if (!rc)
    {
      gpgme_verify_result_t result;
      gpgme_signature_t s;

      result = gpgme_op_verify_result (crypto->ctx);

      for (s = result->signatures; s; s = s->next)
        {
          pthread_cleanup_push ((void *)strv_free, new_signers);
          log_write1 (_ ("%s: signer: %s, status=%u"),
                      crypto->filename, s->fpr, s->status);
          pthread_cleanup_pop (0);
          if (s->status || s->wrong_key_usage
              || !(s->summary & GPGME_SIGSUM_VALID))
            continue;

          pp = strv_cat (new_signers, str_dup (s->fpr));
          if (!pp)
            {
              rc = GPG_ERR_ENOMEM;
              break;
            }

          new_signers = pp;
        }

      if (result->signatures && !new_signers)
        rc = GPG_ERR_BAD_SIGNATURE;

      if (!rc)
        {
          xfree (crypto->plaintext);
          crypto->plaintext = NULL;
          crypto->plaintext_size = 0;
          pthread_cleanup_push ((void *)strv_free, new_recipients);
          pthread_cleanup_push ((void *)strv_free, new_signers);
          rc = crypto_data_to_buf (plain, &crypto->plaintext,
                                   &crypto->plaintext_size);
          pthread_cleanup_pop (0);
          pthread_cleanup_pop (0);
          if (!rc)
            {
              strv_free (crypto->pubkey);
              crypto->pubkey = new_recipients;
              crypto_keyid_to_16b (crypto->pubkey);
              strv_free (crypto->sigkey);
              crypto->sigkey = new_signers;
              crypto_keyid_to_16b (crypto->sigkey);
            }
        }
    }

  if (rc)
    {
      strv_free (new_recipients);
      strv_free (new_signers);
    }

  pthread_cleanup_pop (1); // free_gpgme_data_cb (plain)
  return rc;
}

void
crypto_free_key_list (gpgme_key_t *keys)
{
  int i;

  for (i = 0; keys && keys[i]; i++)
    gpgme_key_unref (keys[i]);

  xfree (keys);
}

/* Removes strings in 'prune' from 'a'. */
static char **
prune_keys (char **a, char **prune)
{
  char **p;

  for (p = prune; p && *p; p++)
    {
      char **ap;

      for (ap = a; ap && *ap; ap++)
        {
          if (!strcmp (*ap, *p))
            {
              while (*ap)
                {
                  *ap = *(ap+1);
                  ap++;
                }
            }
        }
    }

  return a;
}

static void
remove_duplicates (char **a)
{
  char **p;

  for (p = a; p && *p; p++)
    {
      char **t;

      for (t = p+1; t && *t; t++)
        {
          if (!strcmp (*p, *t))
            {
              char *tmp = *t;

              while (*(t+1))
                {
                  *t = *(t+1);
                  t++;
                }

              *t = NULL;
              xfree (tmp);
              remove_duplicates (a);
              return;
            }
        }
    }
}

gpgme_error_t
crypto_encrypt (struct client_s *client, struct crypto_s *crypto)
{
  gpgme_error_t rc;
  gpgme_data_t cipher = NULL;
  gpgme_key_t *keys = NULL;
  gpgme_key_t *sigkeys = NULL;

  STATUS_TIMEOUT_INIT (crypto);
  if (!(crypto->flags & CRYPTO_FLAG_SYMMETRIC))
    {
      crypto_keyid_to_16b (crypto->save.pubkey);
      remove_duplicates (crypto->save.pubkey);
      rc = crypto_list_keys (crypto, crypto->save.pubkey, 0, &keys);
      if (rc)
        return rc;
    }

  pthread_cleanup_push ((void *)crypto_free_key_list, keys);
  rc = gpgme_data_new (&cipher);
  pthread_cleanup_push ((void *)free_gpgme_data_cb, cipher);
  if (!rc)
    rc = gpgme_data_set_file_name (cipher, crypto->filename);

  if (!rc && (crypto->save.sigkey
              || !(crypto->flags & CRYPTO_FLAG_SYMMETRIC)))
    {
      crypto_keyid_to_16b (crypto->save.sigkey);
      remove_duplicates (crypto->save.sigkey);
      rc = crypto_list_keys (crypto, crypto->save.sigkey, 1, &sigkeys);
      if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
        rc = 0;
    }

  if (!rc)
    {
      gpgme_data_t plain = NULL;

      pthread_cleanup_push ((void *)crypto_free_key_list, sigkeys);
      rc = gpgme_data_new_from_mem (&plain, (char *)crypto->plaintext,
                                    crypto->plaintext_size, 0);
      pthread_cleanup_push ((void *)free_gpgme_data_cb, plain);
      if (!rc)
        {
          int i;

          gpgme_signers_clear (crypto->ctx);

          for (i = 0; sigkeys && sigkeys[i]; i++)
            gpgme_signers_add (crypto->ctx, sigkeys[i]);

          if (!i && !(crypto->flags & CRYPTO_FLAG_SYMMETRIC))
            rc = GPG_ERR_NO_SIGNATURE_SCHEME;
        }

      if (!rc)
        {
          gpgme_data_set_encoding (cipher, GPGME_DATA_ENCODING_ARMOR);

          rc = send_status (client ? client->ctx : NULL, STATUS_ENCRYPT, NULL);
          if (!rc)
            {
              unsigned flags = 0;
              int f = config_get_boolean ("global", "encrypt_to");

              if (!f)
                flags |= GPGME_ENCRYPT_NO_ENCRYPT_TO;

              f = config_get_boolean ("global", "always_trust");
              if (f)
                flags |= GPGME_ENCRYPT_ALWAYS_TRUST;

              if (!(crypto->flags & CRYPTO_FLAG_SYMMETRIC)
                  || (crypto->flags & CRYPTO_FLAG_SYMMETRIC && sigkeys))
                rc = gpgme_op_encrypt_sign_start (crypto->ctx,
                                                  (crypto->flags & CRYPTO_FLAG_SYMMETRIC) ? NULL : keys,
                                                  flags, plain, cipher);
              else
                rc = gpgme_op_encrypt_start (crypto->ctx, NULL, flags,
                                             plain, cipher);
            }
        }

      if (!rc)
        {
          pthread_cleanup_push ((void *)crypto_cancel_gpgme, crypto);

          do
            {
              if (!rc && crypto->progress_rc)
                rc = crypto->progress_rc;

              if (!rc)
                STATUS_TIMEOUT_TEST (crypto, rc, STATUS_ENCRYPT, NULL);

              if (rc)
                break;
            } while (!gpgme_wait (crypto->ctx, &rc, 0) && !rc);

          pthread_cleanup_pop (0);

          if (!rc)
            {
              gpgme_encrypt_result_t result;
              gpgme_sign_result_t sresult;
              gpgme_invalid_key_t inv;
              gpgme_new_signature_t sigs;
              char **prune = NULL;
              char **p = NULL;

              result = gpgme_op_encrypt_result (crypto->ctx);
              inv = result->invalid_recipients;
              while (inv)
                {
                  pthread_cleanup_push ((void *)strv_free, prune);
                  log_write1 (_ ("%s: invalid recipient: %s, rc=%u"),
                              crypto->filename, inv->fpr, inv->reason);
                  pthread_cleanup_pop (0);
                  p = strv_cat (prune, str_dup(inv->fpr));
                  if (!p)
                    {
                      rc = GPG_ERR_ENOMEM;
                      strv_free (prune);
                      break;
                    }

                  prune = p;
                  inv = inv->next;
                }
              
              if (prune)
                {
                  p = prune_keys (crypto->save.pubkey, prune);
                  crypto->save.pubkey = p;
                }

              crypto_keyid_to_16b (crypto->save.pubkey);
              sresult = gpgme_op_sign_result (crypto->ctx);
              inv = sresult ? sresult->invalid_signers : NULL;
              while (!rc && inv)
                {
                  log_write1 (_ ("%s: invalid signer: %s, rc=%u"),
                              crypto->filename, inv->fpr, inv->reason);
                  inv = inv->next;
                }

              sigs = sresult ? sresult->signatures : NULL;
              if (!rc && sigs)
                {
                  p = NULL;

                  while (sigs)
                    {
                      char **pp;

                      pthread_cleanup_push ((void *)strv_free, p);
                      log_write1 (_ ("%s: signer: %s"), crypto->filename,
                                  sigs->fpr);
                      pthread_cleanup_pop (0);

                      pp = strv_cat (p, str_dup (sigs->fpr));
                      if (!pp)
                        {
                          rc = GPG_ERR_ENOMEM;
                          strv_free (p);
                          break;
                        }

                      p = pp;
                      sigs = sigs->next;
                    }

                  if (!rc)
                    {
                      strv_free (crypto->save.sigkey);
                      crypto->save.sigkey = p;
                      crypto_keyid_to_16b (crypto->save.sigkey);
                      crypto->cipher = cipher;
                    }
                }
              else if (!rc && crypto->flags & CRYPTO_FLAG_SYMMETRIC)
                {
                  crypto->cipher = cipher;
                }
              else if (!rc)
                {
                 if (!(crypto->flags & CRYPTO_FLAG_SYMMETRIC)
                     || (crypto->flags & CRYPTO_FLAG_SYMMETRIC && sigkeys))
                   rc = GPG_ERR_NO_SIGNATURE_SCHEME;
                }
            }
        }

      pthread_cleanup_pop (1); // free_gpgme_data_cb (plain)
      pthread_cleanup_pop (1); // crypto_free_key_list (sigkeys)
    }

  pthread_cleanup_pop (0); // free_gpgme_data_cb (cipher)
  pthread_cleanup_pop (1); // crypto_free_key_list (keys)

  if (rc)
    free_gpgme_data_cb (cipher);

  return rc;
}

gpgme_error_t
crypto_passwd (struct client_s *client, struct crypto_s *crypto)
{
  gpgme_error_t rc;
  gpgme_key_t *keys = NULL;

  /* Use SAVE instead for symmetric files. */
  rc = crypto_is_symmetric (client->filename);
  if (!rc || rc != GPG_ERR_BAD_DATA)
    return !rc ? GPG_ERR_NOT_SUPPORTED : rc;

  rc = crypto_list_keys (crypto, crypto->pubkey, 1, &keys);
  if (rc)
    return rc;

  crypto->flags |= CRYPTO_FLAG_PASSWD;
  pthread_cleanup_push ((void *)crypto_free_key_list, keys);
  STATUS_TIMEOUT_INIT (crypto);
  rc = send_status (client->ctx, STATUS_KEEPALIVE, NULL);
  if (!rc)
    rc = gpgme_op_passwd_start (crypto->ctx, keys[0], 0);

  if (!rc)
    {
      pthread_cleanup_push ((void *)crypto_cancel_gpgme, crypto);

      do
        {
          if (!rc && crypto->progress_rc)
            rc = crypto->progress_rc;

          if (!rc)
            STATUS_TIMEOUT_TEST (crypto, rc, STATUS_KEEPALIVE, NULL);

          if (rc)
            break;
        } while (!gpgme_wait (crypto->ctx, &rc, 0) && !rc);

      pthread_cleanup_pop (0);
    }

  pthread_cleanup_pop (1);
  return rc;
}

/* Generate a new key pair. The resulting keyid's are stored in crypto->save.
 */
gpgme_error_t
crypto_genkey (struct client_s *client, struct crypto_s *crypto,
               const unsigned char *params)
{
  gpgme_genkey_result_t result;
  gpgme_error_t rc;

  if (strstr ((char *) params, "%pubring")
      || strstr ((char *) params, "%secring"))
    return GPG_ERR_INV_VALUE;

  STATUS_TIMEOUT_INIT (crypto);
  rc = send_status (client ? client->ctx : NULL, STATUS_GENKEY, NULL);
  if (!rc)
    rc = gpgme_op_genkey_start (crypto->ctx, (const char *)params, NULL, NULL);

  if (rc)
    return rc;

  pthread_cleanup_push ((void *)crypto_cancel_gpgme, crypto);

  do
    {
      if (!rc && crypto->progress_rc)
        rc = crypto->progress_rc;

      if (!rc)
        STATUS_TIMEOUT_TEST (crypto, rc, STATUS_GENKEY, NULL);

      if (rc)
        break;
    } while (!gpgme_wait (crypto->ctx, &rc, 0) && !rc);

  pthread_cleanup_pop (0);

  if (!rc)
    {
      gpgme_key_t *keys = NULL;

      result = gpgme_op_genkey_result (crypto->ctx);
      crypto->save.sigkey = strv_cat (crypto->save.sigkey,
                                      str_dup (result->fpr));
      crypto_keyid_to_16b (crypto->save.sigkey);

      rc = crypto_list_keys (crypto, crypto->save.sigkey, 1, &keys);
      if (!rc)
        {
          gpgme_subkey_t key = keys[0]->subkeys;

          for (; key; key = key->next)
            {
              if (key->can_encrypt)
                break;
            }

          pthread_cleanup_push ((void *)crypto_free_key_list, keys);
          rc = send_status (client ? client->ctx : NULL, STATUS_GENKEY, "%s %s",
                            crypto->save.sigkey[0], key ? key->fpr : "");
          if (!rc)
            {
              crypto->save.pubkey = strv_cat (crypto->save.pubkey,
                                              str_dup (key->fpr));
              crypto_keyid_to_16b (crypto->save.pubkey);
            }

          pthread_cleanup_pop (1);
        }
    }

  return rc;
}

char *
crypto_default_key_params ()
{
  char *user = get_username (getuid());
  char *params = str_asprintf(
                              "<GnupgKeyParms format=\"internal\">\n"
                              "  Key-Type: default\n"
                              "  Subkey-Type: default\n"
                              "  Name-Real: %s\n"
                              "  Name-Email: %s\n"
                              "  Expire-Date: 0\n"
                              "</GnupgKeyParms>",
                              getenv ("REALNAME") ? getenv ("REALNAME") : user,
                              getenv ("EMAIL") ? getenv ("EMAIL") : user);

  xfree (user);
  return params;
}

#ifdef WITH_LIBACL
static void
cleanup_acl (void *arg)
{
  acl_t acl = arg ? (acl_t) arg : NULL;

  if (acl)
    acl_free (acl);
}
#endif

/* The advisory lock should be obtained before calling this function. */
gpg_error_t
crypto_write_file (struct crypto_s *crypto)
{
  unsigned char *buf;
  size_t size, len;
  int fd;
  gpg_error_t rc;
  char tmp[PATH_MAX];
  struct stat st;
  mode_t mode = 0600;
#ifdef WITH_LIBACL
  acl_t acl = NULL;
#endif

  if (crypto->filename)
    {
      if (lstat (crypto->filename, &st) == 0)
        {
          mode = st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);

          if (!(mode & S_IWUSR))
            return GPG_ERR_EACCES;
        }
      else if (errno != ENOENT)
        return gpg_error_from_errno (errno);

      snprintf (tmp, sizeof (tmp), "%s.XXXXXX", crypto->filename);
      mode_t tmode = umask (0600);
      fd = mkstemp (tmp);
      if (fd == -1)
        {
          rc = gpg_error_from_errno (errno);
          umask (tmode);
          log_write ("%s: %s", tmp, pwmd_strerror (rc));
          return rc;
        }

      umask (tmode);
    }
  else
    fd = STDOUT_FILENO;

  rc = crypto_data_to_buf (crypto->cipher, &buf, &size);
  if (rc)
    {
      if (crypto->filename)
        close (fd);
      return rc;
    }

  pthread_cleanup_push ((void *)cleanup_fd_cb, &fd);
  pthread_cleanup_push ((void *)xfree, buf);
  len = write (fd, buf, size);
  pthread_cleanup_pop (1);
  if (len != size)
    rc = gpg_error_from_errno (errno);

  if (!rc)
    {
      if (fsync (fd) != -1)
        {
          if (crypto->filename && close (fd) != -1)
            {
#ifdef WITH_LIBACL
              acl = acl_get_file (crypto->filename, ACL_TYPE_ACCESS);
              if (!acl && errno == ENOENT)
                acl = acl_get_file (".", ACL_TYPE_DEFAULT);
              if (!acl)
                log_write ("ACL: %s: %s", crypto->filename,
                           pwmd_strerror (gpg_error_from_errno (errno)));
              pthread_cleanup_push ((void *)cleanup_acl, acl);
#endif

              fd = -1;
              if (config_get_boolean (crypto->filename, "backup"))
                {
                  char tmp2[PATH_MAX];

                  snprintf (tmp2, sizeof (tmp2), "%s.backup", crypto->filename);
                  if (rename (crypto->filename, tmp2) == -1)
                    if (errno != ENOENT)
                      rc = gpg_error_from_errno (errno);
                }

              if (!rc && rename (tmp, crypto->filename) == -1)
                rc = gpg_error_from_errno (errno);

              if (!rc)
                chmod (crypto->filename, mode);
#ifdef WITH_LIBACL
              if (!rc && acl && acl_set_file (crypto->filename,
                                              ACL_TYPE_ACCESS, acl))
                log_write ("ACL: %s: %s", crypto->filename,
                           pwmd_strerror (gpg_error_from_errno (errno)));
              pthread_cleanup_pop (1);
#endif
            }
          else if (crypto->filename)
            rc = gpg_error_from_errno (errno);

          if (!rc && fd != -1)
            {
              char *tmp = str_asprintf ("%s/data", homedir);

              if (tmp)
                {
                  int dfd = open (tmp, O_RDONLY);

                  if (dfd != -1)
                    {
                      if (fsync (dfd) == -1)
                        log_write ("%s %d: %s", __FILE__, __LINE__,
                                   pwmd_strerror (errno));

                      close (dfd);
                    }
                  else
                    log_write ("%s %d: %s", __FILE__, __LINE__,
                               pwmd_strerror (errno));

                  xfree (tmp);
                }
            }
        }
      else
        rc = gpg_error_from_errno (errno);
    }

  pthread_cleanup_pop (0); // close (fd)
  if (fd != -1)
    close (fd);
  return rc;
}

char *
crypto_key_info (const gpgme_key_t key)
{
  struct string_s *string = string_new (NULL), *s;
  char *line = NULL;
  unsigned n, u;
  gpgme_subkey_t subkey;
  gpgme_user_id_t uid;

  if (!string)
    return NULL;

  for (u = 0, uid = key->uids; uid; uid = uid->next)
    u++;

  for (n = 0, subkey = key->subkeys; subkey; subkey = subkey->next)
    n++;

  s = string_append_printf (string, "%u:%u:%u:%u:%u:%u:%u:%u:%u:%u:%i:%s:%s:%s:%i:%u:%u",
                            key->revoked, key->expired, key->disabled,
                            key->invalid, key->can_encrypt, key->can_sign,
                            key->can_certify, key->secret,
                            key->can_authenticate, key->is_qualified,
                            key->protocol,
                            key->issuer_serial ? key->issuer_serial : "",
                            key->issuer_name ? key->issuer_name : "",
                            key->chain_id ? key->chain_id : "",
                            key->owner_trust, u, n);
  if (!s)
    {
      string_free (string, 1);
      return NULL;
    }

  string = s;
  for (subkey = key->subkeys; subkey; subkey = subkey->next)
    {
      char *tmp;

      s = string_append_printf (string, ":%u:%u:%u:%u:%u:%u:%u:%u:%u:%u:%u:%i:%u",
                                subkey->revoked, subkey->expired,
                                subkey->disabled, subkey->invalid,
                                subkey->can_encrypt, subkey->can_sign,
                                subkey->can_certify, subkey->secret,
                                subkey->can_authenticate, subkey->is_qualified,
                                subkey->is_cardkey, subkey->pubkey_algo,
                                subkey->length);
      if (!s)
        {
          string_free (string, 1);
          return NULL;
        }

      string = s;
      s = string_append_printf (string, ":%s:%s:%s:%li:%li:%s",
                                subkey->keyid, subkey->fpr,
                                subkey->keygrip ? subkey->keygrip : "",
                                subkey->timestamp, subkey->expires,
                                subkey->card_number ? subkey->card_number : "0");
      if (!s)
        {
          string_free (string, 1);
          return NULL;
        }

      string = s;
      tmp = gnupg_escape (subkey->curve);
      s = string_append_printf (string, ":%s", tmp ? tmp : "");
      xfree (tmp);
      if (!s)
        {
          string_free (string, 1);
          return NULL;
        }

      string = s;
    }

  for (uid = key->uids; uid; uid = uid->next)
    {
      char *userid, *name, *email, *comment;

      userid = gnupg_escape (uid->uid);
      name = gnupg_escape (uid->name);
      email = gnupg_escape (uid->email);
      comment = gnupg_escape (uid->comment);
      s = string_append_printf (string, ":%u:%u:%u:%s:%s:%s:%s",
                                uid->revoked, uid->invalid, uid->validity,
                                userid ? userid : "",
                                name ? name : "",
                                email ? email : "",
                                comment ? comment : "");
      xfree (userid);
      xfree (name);
      xfree (email);
      xfree (comment);
      if (!s)
        {
          string_free (string, 1);
          return NULL;
        }

      string = s;
    }

  line = string->str;
  string_free (string, 0);
  return line;
}

gpg_error_t
crypto_try_decrypt (struct client_s *client, int no_pinentry)
{
  struct crypto_s *crypto;
  gpg_error_t rc;
  char *keyfile = config_get_string (client->filename, "passphrase_file");

  rc = crypto_init (&crypto, client->ctx, client->filename, no_pinentry,
                    keyfile);
  if (!rc)
    {
      pthread_cleanup_push ((void *)crypto_free, crypto);
      rc = crypto_decrypt (client, crypto);
      pthread_cleanup_pop (1);
    }
  else
    xfree (keyfile);

  return rc;
}

/* The advisory lock should be obtained before calling this function. */
gpg_error_t
crypto_is_symmetric (const char *filename)
{
  int fd;
  uint8_t magic[2];
  ssize_t len;

  fd = open (filename, O_RDONLY);
  if (fd == -1)
    return gpg_error_from_errno (errno);

  len = read (fd, &magic, sizeof(magic));
  close (fd);
  if (len != sizeof (magic))
    return GPG_ERR_INV_VALUE;

  // Always read as big endian.
  if (magic[0] != 0x8c || magic[1] != 0x0d)
    return GPG_ERR_BAD_DATA;

  return 0;
}