smime_build_smime_entity()

Encrypt the email body to all recipients. More...

Collaboration diagram for smime_build_smime_entity():

Functions
struct Body *	smime_gpgme_build_smime_entity (struct Body *a, char *keylist)
	Implements CryptModuleSpecs::smime_build_smime_entity() -. More...
struct Body *	smime_class_build_smime_entity (struct Body *a, char *certlist)
	Implements CryptModuleSpecs::smime_build_smime_entity() -. More...

Detailed Description

Encrypt the email body to all recipients.

Parameters

a	Body of email
certlist	List of key fingerprints (space separated)

Return values

ptr	New S/MIME encrypted Body
NULL	Error

Function Documentation

smime_gpgme_build_smime_entity()

struct Body * smime_gpgme_build_smime_entity	(	struct Body *	a,
		char *	keylist
	)

Implements CryptModuleSpecs::smime_build_smime_entity() -.

Definition at line 1077 of file crypt_gpgme.c.

{
  /* OpenSSL converts line endings to crlf when encrypting.  Some clients
   * depend on this for signed+encrypted messages: they do not convert line
   * endings between decrypting and checking the signature.  */
  gpgme_data_t plaintext = body_to_data_object(a, true);
  if (!plaintext)
    return NULL;
 
  char *outfile = encrypt_gpgme_object(plaintext, keylist, true, false, NULL);
  gpgme_data_release(plaintext);
  if (!outfile)
    return NULL;
 
  struct Body *t = mutt_body_new();
  t->type = TYPE_APPLICATION;
  t->subtype = mutt_str_dup("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 = outfile;
  t->unlink = true; /* delete after sending the message */
  t->parts = 0;
  t->next = 0;
 
  return t;
}

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 1353 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);
      const char *const c_smime_certificates = cs_subset_path(NeoMutt->sub, "smime_certificates");
      snprintf(certfile + off, sizeof(certfile) - off, "%s%s/%s",
               (off != 0) ? " " : "", NONULL(c_smime_certificates), 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("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: