verify_one()

Check a signed MIME part against a signature. More...

Collaboration diagram for verify_one():

Functions
int	pgp_gpgme_verify_one (struct Body *b, struct State *state, const char *tempfile)
	Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.
int	smime_gpgme_verify_one (struct Body *b, struct State *state, const char *tempfile)
	Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.
int	pgp_class_verify_one (struct Body *b, struct State *state, const char *tempfile)
	Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.
int	smime_class_verify_one (struct Body *b, struct State *state, const char *tempfile)
	Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.

Detailed Description

Check a signed MIME part against a signature.

Parameters

b	Body of the signed mail
state	State of text being processed
tempf	File containing the key

Return values

0	Success
-1	Error

Function Documentation

pgp_gpgme_verify_one()

int pgp_gpgme_verify_one	(	struct Body *	b,
		struct State *	state,
		const char *	tempfile
	)

Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.

Definition at line 1672 of file crypt_gpgme.c.

{
  return verify_one(b, state, tempfile, false);
}

Here is the call graph for this function:

smime_gpgme_verify_one()

int smime_gpgme_verify_one	(	struct Body *	b,
		struct State *	state,
		const char *	tempfile
	)

Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.

Definition at line 1680 of file crypt_gpgme.c.

{
  return verify_one(b, state, tempfile, true);
}

Here is the call graph for this function:

pgp_class_verify_one()

int pgp_class_verify_one	(	struct Body *	b,
		struct State *	state,
		const char *	tempfile
	)

Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.

Definition at line 898 of file pgp.c.

{
  FILE *fp_pgp_out = NULL;
  pid_t pid;
  int badsig = -1;
  struct Buffer *sigfile = buf_pool_get();
 
  buf_printf(sigfile, "%s.asc", tempfile);
 
  FILE *fp_sig = mutt_file_fopen(buf_string(sigfile), "w");
  if (!fp_sig)
  {
    mutt_perror("%s", buf_string(sigfile));
    goto cleanup;
  }
 
  if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
  {
    mutt_file_fclose(&fp_sig);
    goto cleanup;
  }
  mutt_file_copy_bytes(state->fp_in, fp_sig, b->length);
  mutt_file_fclose(&fp_sig);
 
  FILE *fp_pgp_err = mutt_file_mkstemp();
  if (!fp_pgp_err)
  {
    mutt_perror(_("Can't create temporary file"));
    unlink(buf_string(sigfile));
    goto cleanup;
  }
 
  crypt_current_time(state, "PGP");
 
  pid = pgp_invoke_verify(NULL, &fp_pgp_out, NULL, -1, -1, fileno(fp_pgp_err),
                          tempfile, buf_string(sigfile));
  if (pid != -1)
  {
    if (pgp_copy_checksig(fp_pgp_out, state->fp_out) >= 0)
      badsig = 0;
 
    mutt_file_fclose(&fp_pgp_out);
    fflush(fp_pgp_err);
    rewind(fp_pgp_err);
 
    if (pgp_copy_checksig(fp_pgp_err, state->fp_out) >= 0)
      badsig = 0;
 
    const int rv = filter_wait(pid);
    if (rv)
      badsig = -1;
 
    mutt_debug(LL_DEBUG1, "filter_wait returned %d\n", rv);
  }
 
  mutt_file_fclose(&fp_pgp_err);
 
  state_attach_puts(state, _("[-- End of PGP output --]\n\n"));
 
  mutt_file_unlink(buf_string(sigfile));
 
cleanup:
  buf_pool_release(&sigfile);
 
  mutt_debug(LL_DEBUG1, "returning %d\n", badsig);
  return badsig;
}

Here is the call graph for this function:

smime_class_verify_one()

int smime_class_verify_one	(	struct Body *	b,
		struct State *	state,
		const char *	tempfile
	)

Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.

Definition at line 1705 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 = b->type;
 
  struct Buffer *signedfile = buf_pool_get();
 
  buf_printf(signedfile, "%s.sig", tempfile);
 
  /* decode to a tempfile, saving the original destination */
  fp = state->fp_out;
  state->fp_out = mutt_file_fopen(buf_string(signedfile), "w");
  if (!state->fp_out)
  {
    mutt_perror("%s", buf_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 = b->length;
  tmpoffset = b->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.  */
  const char *save_prefix = state->prefix;
  state->prefix = NULL;
 
  mutt_decode_attachment(b, state);
 
  b->length = ftello(state->fp_out);
  b->offset = 0;
  mutt_file_fclose(&state->fp_out);
 
  /* restore final destination and substitute the tempfile for input */
  state->fp_out = fp;
  fp = state->fp_in;
  state->fp_in = mutt_file_fopen(buf_string(signedfile), "r");
 
  /* restore the prefix */
  state->prefix = save_prefix;
 
  b->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(state, "OpenSSL");
 
  pid = smime_invoke_verify(NULL, &fp_smime_out, NULL, -1, -1, fileno(fp_smime_err),
                            tempfile, buf_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, state->fp_out);
  mutt_file_fclose(&fp_smime_err);
 
  state_attach_puts(state, _("[-- End of OpenSSL output --]\n\n"));
 
  mutt_file_unlink(buf_string(signedfile));
 
  b->length = tmplength;
  b->offset = tmpoffset;
 
  /* restore the original source stream */
  mutt_file_fclose(&state->fp_in);
  state->fp_in = fp;
 
cleanup:
  buf_pool_release(&signedfile);
  return badsig;
}

Here is the call graph for this function: