decrypt_mime()

Decrypt an encrypted MIME part. More...

Collaboration diagram for decrypt_mime():

Functions
int	pgp_gpgme_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
	Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.
int	smime_gpgme_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
	Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.
int	pgp_class_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
	Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.
int	smime_class_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
	Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.

Detailed Description

Decrypt an encrypted MIME part.

Parameters

[in]	fp_in	File containing the encrypted part
[out]	fp_out	File containing the decrypted part
[in]	b	Body of the email
[out]	b_dec	Body containing the decrypted part

Return values

0	Success
-1	Failure

Function Documentation

pgp_gpgme_decrypt_mime()

int pgp_gpgme_decrypt_mime	(	FILE *	fp_in,
		FILE **	fp_out,
		struct Body *	b,
		struct Body **	b_dec
	)

Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.

Definition at line 1851 of file crypt_gpgme.c.

{
  struct State state = { 0 };
  struct Body *first_part = b;
  int is_signed = 0;
  bool need_decode = false;
  LOFF_T saved_offset = 0;
  size_t saved_length = 0;
  FILE *fp_decoded = NULL;
  int rc = 0;
 
  first_part->goodsig = false;
  first_part->warnsig = false;
 
  if (mutt_is_valid_multipart_pgp_encrypted(b))
  {
    b = b->parts->next;
    /* Some clients improperly encode the octetstream part. */
    if (b->encoding != ENC_7BIT)
      need_decode = true;
  }
  else if (mutt_is_malformed_multipart_pgp_encrypted(b))
  {
    b = b->parts->next->next;
    need_decode = true;
  }
  else
  {
    return -1;
  }
 
  state.fp_in = fp_in;
 
  if (need_decode)
  {
    saved_offset = b->offset;
    saved_length = b->length;
 
    fp_decoded = mutt_file_mkstemp();
    if (!fp_decoded)
    {
      mutt_perror(_("Can't create temporary file"));
      return -1;
    }
 
    if (!mutt_file_seek(state.fp_in, b->offset, SEEK_SET))
    {
      rc = -1;
      goto bail;
    }
    state.fp_out = fp_decoded;
 
    mutt_decode_attachment(b, &state);
 
    fflush(fp_decoded);
    b->length = ftello(fp_decoded);
    b->offset = 0;
    rewind(fp_decoded);
    state.fp_in = fp_decoded;
    state.fp_out = 0;
  }
 
  *fp_out = mutt_file_mkstemp();
  if (!*fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    rc = -1;
    goto bail;
  }
 
  *b_dec = decrypt_part(b, &state, *fp_out, false, &is_signed);
  if (*b_dec)
  {
    rewind(*fp_out);
    if (is_signed > 0)
      first_part->goodsig = true;
  }
  else
  {
    rc = -1;
    mutt_file_fclose(fp_out);
  }
 
bail:
  if (need_decode)
  {
    b->length = saved_length;
    b->offset = saved_offset;
    mutt_file_fclose(&fp_decoded);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smime_gpgme_decrypt_mime()

int smime_gpgme_decrypt_mime	(	FILE *	fp_in,
		FILE **	fp_out,
		struct Body *	b,
		struct Body **	b_dec
	)

Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.

Definition at line 1948 of file crypt_gpgme.c.

{
  struct State state = { 0 };
  int is_signed;
  LOFF_T saved_b_offset;
  size_t saved_b_length;
 
  if (mutt_is_application_smime(b) == SEC_NO_FLAGS)
    return -1;
 
  if (b->parts)
    return -1;
 
  /* Decode the body - we need to pass binary CMS to the
   * backend.  The backend allows for Base64 encoded data but it does
   * not allow for QP which I have seen in some messages.  So better
   * do it here. */
  saved_b_offset = b->offset;
  saved_b_length = b->length;
  state.fp_in = fp_in;
  if (!mutt_file_seek(state.fp_in, b->offset, SEEK_SET))
  {
    return -1;
  }
  FILE *fp_tmp = mutt_file_mkstemp();
  if (!fp_tmp)
  {
    mutt_perror(_("Can't create temporary file"));
    return -1;
  }
 
  state.fp_out = fp_tmp;
  mutt_decode_attachment(b, &state);
  fflush(fp_tmp);
  b->length = ftello(state.fp_out);
  b->offset = 0;
  rewind(fp_tmp);
 
  memset(&state, 0, sizeof(state));
  state.fp_in = fp_tmp;
  state.fp_out = 0;
  *fp_out = mutt_file_mkstemp();
  if (!*fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    return -1;
  }
 
  *b_dec = decrypt_part(b, &state, *fp_out, true, &is_signed);
  if (*b_dec)
    (*b_dec)->goodsig = is_signed > 0;
  b->length = saved_b_length;
  b->offset = saved_b_offset;
  mutt_file_fclose(&fp_tmp);
  rewind(*fp_out);
  if (*b_dec && !is_signed && !(*b_dec)->parts && mutt_is_application_smime(*b_dec))
  {
    /* Assume that this is a opaque signed s/mime message.  This is an ugly way
     * of doing it but we have anyway a problem with arbitrary encoded S/MIME
     * messages: Only the outer part may be encrypted.  The entire mime parsing
     * should be revamped, probably by keeping the temporary files so that we
     * don't need to decrypt them all the time.  Inner parts of an encrypted
     * part can then point into this file and there won't ever be a need to
     * decrypt again.  This needs a partial rewrite of the MIME engine. */
    struct Body *bb = *b_dec;
 
    saved_b_offset = bb->offset;
    saved_b_length = bb->length;
    memset(&state, 0, sizeof(state));
    state.fp_in = *fp_out;
    if (!mutt_file_seek(state.fp_in, bb->offset, SEEK_SET))
    {
      return -1;
    }
    FILE *fp_tmp2 = mutt_file_mkstemp();
    if (!fp_tmp2)
    {
      mutt_perror(_("Can't create temporary file"));
      return -1;
    }
 
    state.fp_out = fp_tmp2;
    mutt_decode_attachment(bb, &state);
    fflush(fp_tmp2);
    bb->length = ftello(state.fp_out);
    bb->offset = 0;
    rewind(fp_tmp2);
    mutt_file_fclose(fp_out);
 
    memset(&state, 0, sizeof(state));
    state.fp_in = fp_tmp2;
    state.fp_out = 0;
    *fp_out = mutt_file_mkstemp();
    if (!*fp_out)
    {
      mutt_perror(_("Can't create temporary file"));
      return -1;
    }
 
    struct Body *b_tmp = decrypt_part(bb, &state, *fp_out, true, &is_signed);
    if (b_tmp)
      b_tmp->goodsig = is_signed > 0;
    bb->length = saved_b_length;
    bb->offset = saved_b_offset;
    mutt_file_fclose(&fp_tmp2);
    rewind(*fp_out);
    mutt_body_free(b_dec);
    *b_dec = b_tmp;
  }
  return *b_dec ? 0 : -1;
}

Here is the call graph for this function:

pgp_class_decrypt_mime()

int pgp_class_decrypt_mime	(	FILE *	fp_in,
		FILE **	fp_out,
		struct Body *	b,
		struct Body **	b_dec
	)

Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.

Definition at line 1164 of file pgp.c.

{
  struct State state = { 0 };
  struct Body *p = b;
  bool need_decode = false;
  LOFF_T saved_offset = 0;
  size_t saved_length = 0;
  FILE *fp_decoded = NULL;
  int rc = 0;
 
  if (mutt_is_valid_multipart_pgp_encrypted(b))
  {
    b = b->parts->next;
    /* Some clients improperly encode the octetstream part. */
    if (b->encoding != ENC_7BIT)
      need_decode = true;
  }
  else if (mutt_is_malformed_multipart_pgp_encrypted(b))
  {
    b = b->parts->next->next;
    need_decode = true;
  }
  else
  {
    return -1;
  }
 
  state.fp_in = fp_in;
 
  if (need_decode)
  {
    saved_offset = b->offset;
    saved_length = b->length;
 
    fp_decoded = mutt_file_mkstemp();
    if (!fp_decoded)
    {
      mutt_perror(_("Can't create temporary file"));
      return -1;
    }
 
    if (!mutt_file_seek(state.fp_in, b->offset, SEEK_SET))
    {
      rc = -1;
      goto bail;
    }
    state.fp_out = fp_decoded;
 
    mutt_decode_attachment(b, &state);
 
    fflush(fp_decoded);
    b->length = ftello(fp_decoded);
    b->offset = 0;
    rewind(fp_decoded);
    state.fp_in = fp_decoded;
    state.fp_out = 0;
  }
 
  *fp_out = mutt_file_mkstemp();
  if (!*fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    rc = -1;
    goto bail;
  }
 
  *b_dec = pgp_decrypt_part(b, &state, *fp_out, p);
  if (!*b_dec)
    rc = -1;
  rewind(*fp_out);
 
bail:
  if (need_decode)
  {
    b->length = saved_length;
    b->offset = saved_offset;
    mutt_file_fclose(&fp_decoded);
  }
 
  return rc;
}

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 **	b_dec
	)

Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.

Definition at line 2094 of file smime.c.

{
  struct State state = { 0 };
  LOFF_T tmpoffset = b->offset;
  size_t tmplength = b->length;
  int rc = -1;
 
  if (!mutt_is_application_smime(b))
    return -1;
 
  if (b->parts)
    return -1;
 
  state.fp_in = fp_in;
  if (!mutt_file_seek(state.fp_in, b->offset, SEEK_SET))
  {
    return -1;
  }
 
  FILE *fp_tmp = mutt_file_mkstemp();
  if (!fp_tmp)
  {
    mutt_perror(_("Can't create temporary file"));
    return -1;
  }
 
  state.fp_out = fp_tmp;
  mutt_decode_attachment(b, &state);
  fflush(fp_tmp);
  b->length = ftello(state.fp_out);
  b->offset = 0;
  rewind(fp_tmp);
  state.fp_in = fp_tmp;
  state.fp_out = 0;
 
  *fp_out = mutt_file_mkstemp();
  if (!*fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    goto bail;
  }
 
  *b_dec = smime_handle_entity(b, &state, *fp_out);
  if (!*b_dec)
    goto bail;
 
  (*b_dec)->goodsig = b->goodsig;
  (*b_dec)->badsig = b->badsig;
  rc = 0;
 
bail:
  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: