smime.h File Reference

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "lib.h"

Include dependency graph for smime.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	SmimeKey
	An SIME key. More...

Functions
void	smime_init (void)
	Initialise smime globals. More...
void	smime_cleanup (void)
	Clean up smime globals. More...
int	smime_class_application_handler (struct Body *m, struct State *s)
	Implements CryptModuleSpecs::application_handler() More...
struct Body *	smime_class_build_smime_entity (struct Body *a, char *certlist)
	Implements CryptModuleSpecs::smime_build_smime_entity() More...
int	smime_class_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
	Implements CryptModuleSpecs::decrypt_mime() More...
char *	smime_class_find_keys (struct AddressList *addrlist, bool oppenc_mode)
	Implements CryptModuleSpecs::find_keys() More...
void	smime_class_getkeys (struct Envelope *env)
	Implements CryptModuleSpecs::smime_getkeys() More...
void	smime_class_invoke_import (const char *infile, const char *mailbox)
	Implements CryptModuleSpecs::smime_invoke_import() More...
SecurityFlags	smime_class_send_menu (struct Email *e)
	Implements CryptModuleSpecs::send_menu() More...
struct Body *	smime_class_sign_message (struct Body *a, const struct AddressList *from)
	Implements CryptModuleSpecs::sign_message() More...
bool	smime_class_valid_passphrase (void)
	Implements CryptModuleSpecs::valid_passphrase() More...
int	smime_class_verify_one (struct Body *sigbdy, struct State *s, const char *tempfile)
	Implements CryptModuleSpecs::verify_one() More...
int	smime_class_verify_sender (struct Mailbox *m, struct Email *e)
	Implements CryptModuleSpecs::smime_verify_sender() More...
void	smime_class_void_passphrase (void)
	Implements CryptModuleSpecs::void_passphrase() More...

Detailed Description

SMIME helper routines

Authors

• Oliver Ehli
• g10 Code GmbH
• Pietro Cerutti

Copyright

This program 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.

This program 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 this program. If not, see http://www.gnu.org/licenses/.

Definition in file smime.h.

Function Documentation

smime_init()

void smime_init

(

void

)

Initialise smime globals.

Definition at line 87 of file smime.c.

{
  mutt_buffer_alloc(&SmimeKeyToUse, 256);
  mutt_buffer_alloc(&SmimeCertToUse, 256);
  mutt_buffer_alloc(&SmimeIntermediateToUse, 256);
}

Here is the call graph for this function:

Here is the caller graph for this function:

smime_cleanup()

void smime_cleanup

(

void

)

Clean up smime globals.

Definition at line 97 of file smime.c.

{
  mutt_buffer_dealloc(&SmimeKeyToUse);
  mutt_buffer_dealloc(&SmimeCertToUse);
  mutt_buffer_dealloc(&SmimeIntermediateToUse);
}

Here is the call graph for this function:

Here is the caller graph for this function:

smime_class_application_handler()

int smime_class_application_handler	(	struct Body *	m,
		struct State *	s
	)

Implements CryptModuleSpecs::application_handler()

Definition at line 2089 of file smime.c.

{
  int rc = -1;
 
  /* clear out any mime headers before the handler, so they can't be spoofed. */
  mutt_env_free(&m->mime_headers);
 
  struct Body *tattach = smime_handle_entity(m, s, NULL);
  if (tattach)
  {
    rc = 0;
    mutt_body_free(&tattach);
  }
  return rc;
}

Here is the call graph for this function:

smime_class_build_smime_entity()

struct Body* smime_class_build_smime_entity	(	struct Body *	a,
		char *	certlist
	)

Implements CryptModuleSpecs::smime_build_smime_entity()

Definition at line 1317 of file smime.c.

{
  char buf[1024], certfile[PATH_MAX];
  char *cert_end = NULL;
  FILE *fp_smime_in = NULL, *fp_smime_err = NULL, *fp_out = NULL, *fp_tmp = NULL;
  struct Body *t = NULL;
  int err = 0, empty, off;
  pid_t pid;
 
  struct Buffer *tempfile = mutt_buffer_pool_get();
  struct Buffer *smime_infile = mutt_buffer_pool_get();
 
  mutt_buffer_mktemp(tempfile);
  fp_out = mutt_file_fopen(mutt_buffer_string(tempfile), "w+");
  if (!fp_out)
  {
    mutt_perror(mutt_buffer_string(tempfile));
    goto cleanup;
  }
 
  fp_smime_err = mutt_file_mkstemp();
  if (!fp_smime_err)
  {
    mutt_perror(_("Can't create temporary file"));
    goto cleanup;
  }
 
  mutt_buffer_mktemp(smime_infile);
  fp_tmp = mutt_file_fopen(mutt_buffer_string(smime_infile), "w+");
  if (!fp_tmp)
  {
    mutt_perror(mutt_buffer_string(smime_infile));
    goto cleanup;
  }
 
  *certfile = '\0';
  for (char *cert_start = certlist; cert_start; cert_start = cert_end)
  {
    cert_end = strchr(cert_start, ' ');
    if (cert_end)
      *cert_end = '\0';
    if (*cert_start)
    {
      off = mutt_str_len(certfile);
      snprintf(certfile + off, sizeof(certfile) - off, "%s%s/%s",
               (off != 0) ? " " : "", NONULL(C_SmimeCertificates), cert_start);
    }
    if (cert_end)
      *cert_end++ = ' ';
  }
 
  /* write a MIME entity */
  mutt_write_mime_header(a, fp_tmp, NeoMutt->sub);
  fputc('\n', fp_tmp);
  mutt_write_mime_body(a, fp_tmp, NeoMutt->sub);
  mutt_file_fclose(&fp_tmp);
 
  pid = smime_invoke_encrypt(&fp_smime_in, NULL, NULL, -1, fileno(fp_out),
                             fileno(fp_smime_err),
                             mutt_buffer_string(smime_infile), certfile);
  if (pid == -1)
  {
    mutt_file_unlink(mutt_buffer_string(smime_infile));
    goto cleanup;
  }
 
  mutt_file_fclose(&fp_smime_in);
 
  filter_wait(pid);
  mutt_file_unlink(mutt_buffer_string(smime_infile));
 
  fflush(fp_out);
  rewind(fp_out);
  empty = (fgetc(fp_out) == EOF);
  mutt_file_fclose(&fp_out);
 
  fflush(fp_smime_err);
  rewind(fp_smime_err);
  while (fgets(buf, sizeof(buf) - 1, fp_smime_err))
  {
    err = 1;
    fputs(buf, stdout);
  }
  mutt_file_fclose(&fp_smime_err);
 
  /* pause if there is any error output from SMIME */
  if (err)
    mutt_any_key_to_continue(NULL);
 
  if (empty)
  {
    /* fatal error while trying to encrypt message */
    if (err == 0)
      mutt_any_key_to_continue(_("No output from OpenSSL..."));
    mutt_file_unlink(mutt_buffer_string(tempfile));
    goto cleanup;
  }
 
  t = mutt_body_new();
  t->type = TYPE_APPLICATION;
  t->subtype = mutt_str_dup("x-pkcs7-mime");
  mutt_param_set(&t->parameter, "name", "smime.p7m");
  mutt_param_set(&t->parameter, "smime-type", "enveloped-data");
  t->encoding = ENC_BASE64; /* The output of OpenSSL SHOULD be binary */
  t->use_disp = true;
  t->disposition = DISP_ATTACH;
  t->d_filename = mutt_str_dup("smime.p7m");
  t->filename = mutt_buffer_strdup(tempfile);
  t->unlink = true; /* delete after sending the message */
  t->parts = NULL;
  t->next = NULL;
 
cleanup:
  if (fp_out)
  {
    mutt_file_fclose(&fp_out);
    mutt_file_unlink(mutt_buffer_string(tempfile));
  }
  mutt_file_fclose(&fp_smime_err);
  if (fp_tmp)
  {
    mutt_file_fclose(&fp_tmp);
    mutt_file_unlink(mutt_buffer_string(smime_infile));
  }
  mutt_buffer_pool_release(&tempfile);
  mutt_buffer_pool_release(&smime_infile);
 
  return t;
}

Here is the call graph for this function:

smime_class_decrypt_mime()

int smime_class_decrypt_mime	(	FILE *	fp_in,
		FILE **	fp_out,
		struct Body *	b,
		struct Body **	cur
	)

Implements CryptModuleSpecs::decrypt_mime()

Definition at line 2027 of file smime.c.

{
  struct State s = { 0 };
  LOFF_T tmpoffset = b->offset;
  size_t tmplength = b->length;
  int orig_type = b->type;
  int rc = -1;
 
  if (!mutt_is_application_smime(b))
    return -1;
 
  if (b->parts)
    return -1;
 
  s.fp_in = fp_in;
  fseeko(s.fp_in, b->offset, SEEK_SET);
 
  FILE *fp_tmp = mutt_file_mkstemp();
  if (!fp_tmp)
  {
    mutt_perror(_("Can't create temporary file"));
    return -1;
  }
 
  s.fp_out = fp_tmp;
  mutt_decode_attachment(b, &s);
  fflush(fp_tmp);
  b->length = ftello(s.fp_out);
  b->offset = 0;
  rewind(fp_tmp);
  s.fp_in = fp_tmp;
  s.fp_out = 0;
 
  *fp_out = mutt_file_mkstemp();
  if (!*fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    goto bail;
  }
 
  *cur = smime_handle_entity(b, &s, *fp_out);
  if (!*cur)
    goto bail;
 
  (*cur)->goodsig = b->goodsig;
  (*cur)->badsig = b->badsig;
  rc = 0;
 
bail:
  b->type = orig_type;
  b->length = tmplength;
  b->offset = tmpoffset;
  mutt_file_fclose(&fp_tmp);
  if (*fp_out)
    rewind(*fp_out);
 
  return rc;
}

Here is the call graph for this function:

smime_class_find_keys()

char* smime_class_find_keys	(	struct AddressList *	addrlist,
		bool	oppenc_mode
	)

Implements CryptModuleSpecs::find_keys()

Definition at line 803 of file smime.c.

{
  struct SmimeKey *key = NULL;
  char *keyid = NULL, *keylist = NULL;
  size_t keylist_size = 0;
  size_t keylist_used = 0;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    key = smime_get_key_by_addr(a->mailbox, KEYFLAG_CANENCRYPT, true, oppenc_mode);
    if (!key && !oppenc_mode)
    {
      char buf[1024];
      snprintf(buf, sizeof(buf), _("Enter keyID for %s: "), a->mailbox);
      key = smime_ask_for_key(buf, KEYFLAG_CANENCRYPT, true);
    }
    if (!key)
    {
      if (!oppenc_mode)
        mutt_message(_("No (valid) certificate found for %s"), a->mailbox);
      FREE(&keylist);
      return NULL;
    }
 
    keyid = key->hash;
    keylist_size += mutt_str_len(keyid) + 2;
    mutt_mem_realloc(&keylist, keylist_size);
    sprintf(keylist + keylist_used, "%s%s", keylist_used ? " " : "", keyid);
    keylist_used = mutt_str_len(keylist);
 
    smime_key_free(&key);
  }
  return keylist;
}

Here is the call graph for this function:

smime_class_getkeys()

void smime_class_getkeys

(

struct Envelope *

env

)

Implements CryptModuleSpecs::smime_getkeys()

Definition at line 767 of file smime.c.

{
  if (C_SmimeDecryptUseDefaultKey && C_SmimeDefaultKey)
  {
    mutt_buffer_printf(&SmimeKeyToUse, "%s/%s", NONULL(C_SmimeKeys), C_SmimeDefaultKey);
    mutt_buffer_printf(&SmimeCertToUse, "%s/%s", NONULL(C_SmimeCertificates), C_SmimeDefaultKey);
    return;
  }
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, &env->to, entries)
  {
    if (mutt_addr_is_user(a))
    {
      getkeys(a->mailbox);
      return;
    }
  }
 
  TAILQ_FOREACH(a, &env->cc, entries)
  {
    if (mutt_addr_is_user(a))
    {
      getkeys(a->mailbox);
      return;
    }
  }
 
  struct Address *f = mutt_default_from(NeoMutt->sub);
  getkeys(f->mailbox);
  mutt_addr_free(&f);
}

Here is the call graph for this function:

smime_class_invoke_import()

void smime_class_invoke_import	(	const char *	infile,
		const char *	mailbox
	)

Implements CryptModuleSpecs::smime_invoke_import()

Definition at line 1124 of file smime.c.

{
  char *certfile = NULL;
  char buf[256];
  FILE *fp_smime_in = NULL;
 
  FILE *fp_err = mutt_file_mkstemp();
  if (!fp_err)
  {
    mutt_perror(_("Can't create temporary file"));
    return;
  }
 
  FILE *fp_out = mutt_file_mkstemp();
  if (!fp_out)
  {
    mutt_file_fclose(&fp_err);
    mutt_perror(_("Can't create temporary file"));
    return;
  }
 
  buf[0] = '\0';
  if (C_SmimeAskCertLabel)
  {
    if ((mutt_get_field(_("Label for certificate: "), buf, sizeof(buf),
                        MUTT_COMP_NO_FLAGS, false, NULL, NULL) != 0) ||
        (buf[0] == '\0'))
    {
      mutt_file_fclose(&fp_out);
      mutt_file_fclose(&fp_err);
      return;
    }
  }
 
  mutt_endwin();
  certfile = smime_extract_certificate(infile);
  if (certfile)
  {
    mutt_endwin();
 
    pid_t pid = smime_invoke(&fp_smime_in, NULL, NULL, -1, fileno(fp_out),
                             fileno(fp_err), certfile, NULL, NULL, NULL, NULL,
                             NULL, NULL, C_SmimeImportCertCommand);
    if (pid == -1)
    {
      mutt_message(_("Error: unable to create OpenSSL subprocess"));
      return;
    }
    fputs(buf, fp_smime_in);
    fputc('\n', fp_smime_in);
    mutt_file_fclose(&fp_smime_in);
 
    filter_wait(pid);
 
    mutt_file_unlink(certfile);
    FREE(&certfile);
  }
 
  fflush(fp_out);
  rewind(fp_out);
  fflush(fp_err);
  rewind(fp_err);
 
  mutt_file_copy_stream(fp_out, stdout);
  mutt_file_copy_stream(fp_err, stdout);
 
  mutt_file_fclose(&fp_out);
  mutt_file_fclose(&fp_err);
}

Here is the call graph for this function:

smime_class_send_menu()

SecurityFlags smime_class_send_menu

(

struct Email *

e

)

Implements CryptModuleSpecs::send_menu()

Definition at line 2108 of file smime.c.

{
  struct SmimeKey *key = NULL;
  const char *prompt = NULL;
  const char *letters = NULL;
  const char *choices = NULL;
  int choice;
 
  if (!(WithCrypto & APPLICATION_SMIME))
    return e->security;
 
  e->security |= APPLICATION_SMIME;
 
  /* Opportunistic encrypt is controlling encryption.
   * NOTE: "Signing" and "Clearing" only adjust the sign bit, so we have different
   *       letter choices for those.  */
  if (C_CryptOpportunisticEncrypt && (e->security & SEC_OPPENCRYPT))
  {
    /* L10N: S/MIME options (opportunistic encryption is on) */
    prompt = _("S/MIME (s)ign, encrypt (w)ith, sign (a)s, (c)lear, or (o)ppenc "
               "mode off?");
    /* L10N: S/MIME options (opportunistic encryption is on) */
    letters = _("swaco");
    choices = "SwaCo";
  }
  /* Opportunistic encryption option is set, but is toggled off
   * for this message.  */
  else if (C_CryptOpportunisticEncrypt)
  {
    /* L10N: S/MIME options (opportunistic encryption is off) */
    prompt = _("S/MIME (e)ncrypt, (s)ign, encrypt (w)ith, sign (a)s, (b)oth, "
               "(c)lear, or (o)ppenc mode?");
    /* L10N: S/MIME options (opportunistic encryption is off) */
    letters = _("eswabco");
    choices = "eswabcO";
  }
  /* Opportunistic encryption is unset */
  else
  {
    /* L10N: S/MIME options */
    prompt = _("S/MIME (e)ncrypt, (s)ign, encrypt (w)ith, sign (a)s, (b)oth, "
               "or (c)lear?");
    /* L10N: S/MIME options */
    letters = _("eswabc");
    choices = "eswabc";
  }
 
  choice = mutt_multi_choice(prompt, letters);
  if (choice > 0)
  {
    switch (choices[choice - 1])
    {
      case 'a': /* sign (a)s */
        key = smime_ask_for_key(_("Sign as: "), KEYFLAG_CANSIGN, false);
        if (key)
        {
          mutt_str_replace(&C_SmimeSignAs, key->hash);
          smime_key_free(&key);
 
          e->security |= SEC_SIGN;
 
          /* probably need a different passphrase */
          crypt_smime_void_passphrase();
        }
 
        break;
 
      case 'b': /* (b)oth */
        e->security |= (SEC_ENCRYPT | SEC_SIGN);
        break;
 
      case 'c': /* (c)lear */
        e->security &= ~(SEC_ENCRYPT | SEC_SIGN);
        break;
 
      case 'C':
        e->security &= ~SEC_SIGN;
        break;
 
      case 'e': /* (e)ncrypt */
        e->security |= SEC_ENCRYPT;
        e->security &= ~SEC_SIGN;
        break;
 
      case 'O': /* oppenc mode on */
        e->security |= SEC_OPPENCRYPT;
        crypt_opportunistic_encrypt(e);
        break;
 
      case 'o': /* oppenc mode off */
        e->security &= ~SEC_OPPENCRYPT;
        break;
 
      case 'S': /* (s)ign in oppenc mode */
        e->security |= SEC_SIGN;
        break;
 
      case 's': /* (s)ign */
        e->security &= ~SEC_ENCRYPT;
        e->security |= SEC_SIGN;
        break;
 
      case 'w': /* encrypt (w)ith */
      {
        e->security |= SEC_ENCRYPT;
        do
        {
          struct Buffer errmsg = mutt_buffer_make(0);
          int rc = CSR_SUCCESS;
          switch (mutt_multi_choice(_("Choose algorithm family: (1) DES, (2) "
                                      "RC2, (3) AES, or (c)lear?"),
                                    // L10N: Options for: Choose algorithm family: (1) DES, (2) RC2, (3) AES, or (c)lear?
                                    _("123c")))
          {
            case 1:
              switch (choice = mutt_multi_choice(_("(1) DES, (2) Triple-DES?"),
                                                 // L10N: Options for: (1) DES, (2) Triple-DES
                                                 _("12")))
              {
                case 1:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "des", &errmsg);
                  break;
                case 2:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "des3", &errmsg);
                  break;
              }
              break;
 
            case 2:
              switch (choice = mutt_multi_choice(
                          _("(1) RC2-40, (2) RC2-64, (3) RC2-128?"),
                          // L10N: Options for: (1) RC2-40, (2) RC2-64, (3) RC2-128
                          _("123")))
              {
                case 1:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "rc2-40", &errmsg);
                  break;
                case 2:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "rc2-64", &errmsg);
                  break;
                case 3:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "rc2-128", &errmsg);
                  break;
              }
              break;
 
            case 3:
              switch (choice = mutt_multi_choice(
                          _("(1) AES128, (2) AES192, (3) AES256?"),
                          // L10N: Options for: (1) AES128, (2) AES192, (3) AES256
                          _("123")))
              {
                case 1:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "aes128", &errmsg);
                  break;
                case 2:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "aes192", &errmsg);
                  break;
                case 3:
                  rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                                "aes256", &errmsg);
                  break;
              }
              break;
 
            case 4:
              rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
                                            NULL, &errmsg);
            /* (c)lear */
            /* fallthrough */
            case -1: /* Ctrl-G or Enter */
              choice = 0;
              break;
          }
 
          if ((CSR_RESULT(rc) != CSR_SUCCESS) && !mutt_buffer_is_empty(&errmsg))
            mutt_error("%s", mutt_buffer_string(&errmsg));
 
          mutt_buffer_dealloc(&errmsg);
        } while (choice == -1);
        break;
      }
    }
  }
 
  return e->security;
}

Here is the call graph for this function:

smime_class_sign_message()

struct Body* smime_class_sign_message	(	struct Body *	a,
		const struct AddressList *	from
	)

Implements CryptModuleSpecs::sign_message()

Definition at line 1482 of file smime.c.

{
  struct Body *t = NULL;
  struct Body *retval = NULL;
  char buf[1024];
  struct Buffer *filetosign = NULL, *signedfile = NULL;
  FILE *fp_smime_in = NULL, *fp_smime_out = NULL, *fp_smime_err = NULL, *fp_sign = NULL;
  int err = 0;
  int empty = 0;
  pid_t pid;
  char *intermediates = NULL;
 
  char *signas = C_SmimeSignAs ? C_SmimeSignAs : C_SmimeDefaultKey;
  if (!signas || (*signas == '\0'))
  {
    mutt_error(_("Can't sign: No key specified. Use Sign As."));
    return NULL;
  }
 
  crypt_convert_to_7bit(a); /* Signed data _must_ be in 7-bit format. */
 
  filetosign = mutt_buffer_pool_get();
  signedfile = mutt_buffer_pool_get();
 
  mutt_buffer_mktemp(filetosign);
  fp_sign = mutt_file_fopen(mutt_buffer_string(filetosign), "w+");
  if (!fp_sign)
  {
    mutt_perror(mutt_buffer_string(filetosign));
    goto cleanup;
  }
 
  mutt_buffer_mktemp(signedfile);
  fp_smime_out = mutt_file_fopen(mutt_buffer_string(signedfile), "w+");
  if (!fp_smime_out)
  {
    mutt_perror(mutt_buffer_string(signedfile));
    goto cleanup;
  }
 
  mutt_write_mime_header(a, fp_sign, NeoMutt->sub);
  fputc('\n', fp_sign);
  mutt_write_mime_body(a, fp_sign, NeoMutt->sub);
  mutt_file_fclose(&fp_sign);
 
  mutt_buffer_printf(&SmimeKeyToUse, "%s/%s", NONULL(C_SmimeKeys), signas);
  mutt_buffer_printf(&SmimeCertToUse, "%s/%s", NONULL(C_SmimeCertificates), signas);
 
  struct SmimeKey *signas_key = smime_get_key_by_hash(signas, 1);
  if (!signas_key || mutt_str_equal("?", signas_key->issuer))
    intermediates = signas; /* so openssl won't complain in any case */
  else
    intermediates = signas_key->issuer;
 
  mutt_buffer_printf(&SmimeIntermediateToUse, "%s/%s",
                     NONULL(C_SmimeCertificates), intermediates);
 
  smime_key_free(&signas_key);
 
  pid = smime_invoke_sign(&fp_smime_in, NULL, &fp_smime_err, -1,
                          fileno(fp_smime_out), -1, mutt_buffer_string(filetosign));
  if (pid == -1)
  {
    mutt_perror(_("Can't open OpenSSL subprocess"));
    mutt_file_unlink(mutt_buffer_string(filetosign));
    goto cleanup;
  }
  fputs(SmimePass, fp_smime_in);
  fputc('\n', fp_smime_in);
  mutt_file_fclose(&fp_smime_in);
 
  filter_wait(pid);
 
  /* check for errors from OpenSSL */
  err = 0;
  fflush(fp_smime_err);
  rewind(fp_smime_err);
  while (fgets(buf, sizeof(buf) - 1, fp_smime_err))
  {
    err = 1;
    fputs(buf, stdout);
  }
  mutt_file_fclose(&fp_smime_err);
 
  fflush(fp_smime_out);
  rewind(fp_smime_out);
  empty = (fgetc(fp_smime_out) == EOF);
  mutt_file_fclose(&fp_smime_out);
 
  mutt_file_unlink(mutt_buffer_string(filetosign));
 
  if (err)
    mutt_any_key_to_continue(NULL);
 
  if (empty)
  {
    mutt_any_key_to_continue(_("No output from OpenSSL..."));
    mutt_file_unlink(mutt_buffer_string(signedfile));
    goto cleanup; /* fatal error while signing */
  }
 
  t = mutt_body_new();
  t->type = TYPE_MULTIPART;
  t->subtype = mutt_str_dup("signed");
  t->encoding = ENC_7BIT;
  t->use_disp = false;
  t->disposition = DISP_INLINE;
 
  mutt_generate_boundary(&t->parameter);
 
  char *micalg = openssl_md_to_smime_micalg(C_SmimeSignDigestAlg);
  mutt_param_set(&t->parameter, "micalg", micalg);
  FREE(&micalg);
 
  mutt_param_set(&t->parameter, "protocol", "application/x-pkcs7-signature");
 
  t->parts = a;
  retval = t;
 
  t->parts->next = mutt_body_new();
  t = t->parts->next;
  t->type = TYPE_APPLICATION;
  t->subtype = mutt_str_dup("x-pkcs7-signature");
  t->filename = mutt_buffer_strdup(signedfile);
  t->d_filename = mutt_str_dup("smime.p7s");
  t->use_disp = true;
  t->disposition = DISP_ATTACH;
  t->encoding = ENC_BASE64;
  t->unlink = true; /* ok to remove this file after sending. */
 
cleanup:
  if (fp_sign)
  {
    mutt_file_fclose(&fp_sign);
    mutt_file_unlink(mutt_buffer_string(filetosign));
  }
  if (fp_smime_out)
  {
    mutt_file_fclose(&fp_smime_out);
    mutt_file_unlink(mutt_buffer_string(signedfile));
  }
  mutt_buffer_pool_release(&filetosign);
  mutt_buffer_pool_release(&signedfile);
  return retval;
}

Here is the call graph for this function:

smime_class_valid_passphrase()

bool smime_class_valid_passphrase

(

void

)

Implements CryptModuleSpecs::valid_passphrase()

Definition at line 167 of file smime.c.

{
  const time_t now = mutt_date_epoch();
  if (now < SmimeExpTime)
  {
    /* Use cached copy.  */
    return true;
  }
 
  smime_class_void_passphrase();
 
  if (mutt_get_field_unbuffered(_("Enter S/MIME passphrase:"), SmimePass,
                                sizeof(SmimePass), MUTT_PASS) == 0)
  {
    SmimeExpTime = mutt_date_add_timeout(now, C_SmimeTimeout);
    return true;
  }
  else
    SmimeExpTime = 0;
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smime_class_verify_one()

int smime_class_verify_one	(	struct Body *	sigbdy,
		struct State *	s,
		const char *	tempfile
	)

Implements CryptModuleSpecs::verify_one()

Definition at line 1683 of file smime.c.

{
  FILE *fp = NULL, *fp_smime_out = NULL, *fp_smime_err = NULL;
  pid_t pid;
  int badsig = -1;
 
  LOFF_T tmpoffset = 0;
  size_t tmplength = 0;
  int orig_type = sigbdy->type;
 
  struct Buffer *signedfile = mutt_buffer_pool_get();
 
  mutt_buffer_printf(signedfile, "%s.sig", tempfile);
 
  /* decode to a tempfile, saving the original destination */
  fp = s->fp_out;
  s->fp_out = mutt_file_fopen(mutt_buffer_string(signedfile), "w");
  if (!s->fp_out)
  {
    mutt_perror(mutt_buffer_string(signedfile));
    goto cleanup;
  }
  /* decoding the attachment changes the size and offset, so save a copy
   * of the "real" values now, and restore them after processing */
  tmplength = sigbdy->length;
  tmpoffset = sigbdy->offset;
 
  /* if we are decoding binary bodies, we don't want to prefix each
   * line with the prefix or else the data will get corrupted.  */
  char *save_prefix = s->prefix;
  s->prefix = NULL;
 
  mutt_decode_attachment(sigbdy, s);
 
  sigbdy->length = ftello(s->fp_out);
  sigbdy->offset = 0;
  mutt_file_fclose(&s->fp_out);
 
  /* restore final destination and substitute the tempfile for input */
  s->fp_out = fp;
  fp = s->fp_in;
  s->fp_in = fopen(mutt_buffer_string(signedfile), "r");
 
  /* restore the prefix */
  s->prefix = save_prefix;
 
  sigbdy->type = orig_type;
 
  fp_smime_err = mutt_file_mkstemp();
  if (!fp_smime_err)
  {
    mutt_perror(_("Can't create temporary file"));
    goto cleanup;
  }
 
  crypt_current_time(s, "OpenSSL");
 
  pid = smime_invoke_verify(NULL, &fp_smime_out, NULL, -1, -1, fileno(fp_smime_err),
                            tempfile, mutt_buffer_string(signedfile), 0);
  if (pid != -1)
  {
    fflush(fp_smime_out);
    mutt_file_fclose(&fp_smime_out);
 
    if (filter_wait(pid))
      badsig = -1;
    else
    {
      char *line = NULL;
      size_t linelen;
 
      fflush(fp_smime_err);
      rewind(fp_smime_err);
 
      line = mutt_file_read_line(line, &linelen, fp_smime_err, NULL, MUTT_RL_NO_FLAGS);
      if (linelen && mutt_istr_equal(line, "verification successful"))
        badsig = 0;
 
      FREE(&line);
    }
  }
 
  fflush(fp_smime_err);
  rewind(fp_smime_err);
  mutt_file_copy_stream(fp_smime_err, s->fp_out);
  mutt_file_fclose(&fp_smime_err);
 
  state_attach_puts(s, _("[-- End of OpenSSL output --]\n\n"));
 
  mutt_file_unlink(mutt_buffer_string(signedfile));
 
  sigbdy->length = tmplength;
  sigbdy->offset = tmpoffset;
 
  /* restore the original source stream */
  mutt_file_fclose(&s->fp_in);
  s->fp_in = fp;
 
cleanup:
  mutt_buffer_pool_release(&signedfile);
  return badsig;
}

Here is the call graph for this function:

smime_class_verify_sender()

int smime_class_verify_sender	(	struct Mailbox *	m,
		struct Email *	e
	)

Implements CryptModuleSpecs::smime_verify_sender()

Definition at line 1197 of file smime.c.

{
  char *mbox = NULL, *certfile = NULL;
  int rc = 1;
 
  struct Buffer *tempfname = mutt_buffer_pool_get();
  mutt_buffer_mktemp(tempfname);
  FILE *fp_out = mutt_file_fopen(mutt_buffer_string(tempfname), "w");
  if (!fp_out)
  {
    mutt_perror(mutt_buffer_string(tempfname));
    goto cleanup;
  }
 
  if (e->security & SEC_ENCRYPT)
  {
    mutt_copy_message(fp_out, m, e, MUTT_CM_DECODE_CRYPT & MUTT_CM_DECODE_SMIME,
                      CH_MIME | CH_WEED | CH_NONEWLINE, 0);
  }
  else
    mutt_copy_message(fp_out, m, e, MUTT_CM_NO_FLAGS, CH_NO_FLAGS, 0);
 
  fflush(fp_out);
  mutt_file_fclose(&fp_out);
 
  if (!TAILQ_EMPTY(&e->env->from))
  {
    mutt_expand_aliases(&e->env->from);
    mbox = TAILQ_FIRST(&e->env->from)->mailbox;
  }
  else if (!TAILQ_EMPTY(&e->env->sender))
  {
    mutt_expand_aliases(&e->env->sender);
    mbox = TAILQ_FIRST(&e->env->sender)->mailbox;
  }
 
  if (mbox)
  {
    certfile = smime_extract_signer_certificate(mutt_buffer_string(tempfname));
    if (certfile)
    {
      mutt_file_unlink(mutt_buffer_string(tempfname));
      if (smime_handle_cert_email(certfile, mbox, false, NULL, NULL))
      {
        if (isendwin())
          mutt_any_key_to_continue(NULL);
      }
      else
        rc = 0;
      mutt_file_unlink(certfile);
      FREE(&certfile);
    }
    else
      mutt_any_key_to_continue(_("no certfile"));
  }
  else
    mutt_any_key_to_continue(_("no mbox"));
 
  mutt_file_unlink(mutt_buffer_string(tempfname));
 
cleanup:
  mutt_buffer_pool_release(&tempfname);
  return rc;
}

Here is the call graph for this function:

smime_class_void_passphrase()

void smime_class_void_passphrase

(

void

)

Implements CryptModuleSpecs::void_passphrase()

Definition at line 158 of file smime.c.

{
  memset(SmimePass, 0, sizeof(SmimePass));
  SmimeExpTime = 0;
}

Here is the caller graph for this function: