verify_one()

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

Collaboration diagram for verify_one():

Functions
int	pgp_gpgme_verify_one (struct Body *sigbdy, struct State *s, const char *tempfile)
	Implements CryptModuleSpecs::verify_one() -. More...
int	smime_gpgme_verify_one (struct Body *sigbdy, struct State *s, const char *tempfile)
	Implements CryptModuleSpecs::verify_one() -. More...
int	pgp_class_verify_one (struct Body *sigbdy, struct State *s, const char *tempfile)
	Implements CryptModuleSpecs::verify_one() -. More...
int	smime_class_verify_one (struct Body *sigbdy, struct State *s, const char *tempfile)
	Implements CryptModuleSpecs::verify_one() -. More...

Detailed Description

Check a signed MIME part against a signature.

Parameters

sigbdy	Body of the signed mail
s	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 *	sigbdy,
		struct State *	s,
		const char *	tempfile
	)

Implements CryptModuleSpecs::verify_one() -.

Definition at line 2027 of file crypt_gpgme.c.

{
  return verify_one(sigbdy, s, tempfile, false);
}

Here is the call graph for this function:

smime_gpgme_verify_one()

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

Implements CryptModuleSpecs::verify_one() -.

Definition at line 2035 of file crypt_gpgme.c.

{
  return verify_one(sigbdy, s, tempfile, true);
}

Here is the call graph for this function:

pgp_class_verify_one()

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

Implements CryptModuleSpecs::verify_one() -.

Definition at line 880 of file pgp.c.

{
  FILE *fp_pgp_out = NULL;
  pid_t pid;
  int badsig = -1;
  struct Buffer *sigfile = mutt_buffer_pool_get();
 
  mutt_buffer_printf(sigfile, "%s.asc", tempfile);
 
  FILE *fp_sig = mutt_file_fopen(mutt_buffer_string(sigfile), "w");
  if (!fp_sig)
  {
    mutt_perror(mutt_buffer_string(sigfile));
    goto cleanup;
  }
 
  if (!mutt_file_seek(s->fp_in, sigbdy->offset, SEEK_SET))
  {
    mutt_file_fclose(&fp_sig);
    goto cleanup;
  }
  mutt_file_copy_bytes(s->fp_in, fp_sig, sigbdy->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(mutt_buffer_string(sigfile));
    goto cleanup;
  }
 
  crypt_current_time(s, "PGP");
 
  pid = pgp_invoke_verify(NULL, &fp_pgp_out, NULL, -1, -1, fileno(fp_pgp_err),
                          tempfile, mutt_buffer_string(sigfile));
  if (pid != -1)
  {
    if (pgp_copy_checksig(fp_pgp_out, s->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, s->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(s, _("[-- End of PGP output --]\n\n"));
 
  mutt_file_unlink(mutt_buffer_string(sigfile));
 
cleanup:
  mutt_buffer_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 *	sigbdy,
		struct State *	s,
		const char *	tempfile
	)

Implements CryptModuleSpecs::verify_one() -.

Definition at line 1728 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: