crypt.h File Reference

Signing/encryption multiplexor. More...

#include <stdbool.h>

Include dependency graph for crypt.h:

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

Go to the source code of this file.

Functions
void	crypt_convert_to_7bit (struct Body *b)
	Convert an email to 7bit encoding.
void	crypt_current_time (struct State *state, const char *app_name)
	Print the current time.
const char *	crypt_get_fingerprint_or_id (const char *p, const char **pphint, const char **ppl, const char **pps)
	Get the fingerprint or long key ID.
bool	crypt_is_numerical_keyid (const char *s)
	Is this a numerical keyid.
int	crypt_write_signed (struct Body *b, struct State *state, const char *tempfile)
	Write the message body/part.

Detailed Description

Signing/encryption multiplexor.

Authors

• Richard Russon
• 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 crypt.h.

Function Documentation

crypt_convert_to_7bit()

void crypt_convert_to_7bit

(

struct Body *

b

)

Convert an email to 7bit encoding.

Parameters

b	Body of email to convert

Definition at line 815 of file crypt.c.

{
  if (!WithCrypto)
    return;
 
  const bool c_pgp_strict_enc = cs_subset_bool(NeoMutt->sub, "pgp_strict_enc");
  while (b)
  {
    if (b->type == TYPE_MULTIPART)
    {
      if (b->encoding != ENC_7BIT)
      {
        b->encoding = ENC_7BIT;
        crypt_convert_to_7bit(b->parts);
      }
      else if (((WithCrypto & APPLICATION_PGP) != 0) && c_pgp_strict_enc)
      {
        crypt_convert_to_7bit(b->parts);
      }
    }
    else if ((b->type == TYPE_MESSAGE) && !mutt_istr_equal(b->subtype, "delivery-status"))
    {
      if (b->encoding != ENC_7BIT)
        mutt_message_to_7bit(b, NULL, NeoMutt->sub);
    }
    else if (b->encoding == ENC_8BIT)
    {
      b->encoding = ENC_QUOTED_PRINTABLE;
    }
    else if (b->encoding == ENC_BINARY)
    {
      b->encoding = ENC_BASE64;
    }
    else if (b->content && (b->encoding != ENC_BASE64) &&
             (b->content->from || (b->content->space && c_pgp_strict_enc)))
    {
      b->encoding = ENC_QUOTED_PRINTABLE;
    }
    b = b->next;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_current_time()

void crypt_current_time	(	struct State *	state,
		const char *	app_name )

Print the current time.

Parameters

state	State to use
app_name	App name, e.g. "PGP"

print the current time to avoid spoofing of the signature output

Definition at line 64 of file crypt.c.

{
  char p[256] = { 0 };
  char tmp[512] = { 0 };
 
  if (!WithCrypto)
    return;
 
  const bool c_crypt_timestamp = cs_subset_bool(NeoMutt->sub, "crypt_timestamp");
  if (c_crypt_timestamp)
  {
    mutt_date_localtime_format(p, sizeof(p), _(" (current time: %c)"), mutt_date_now());
  }
  else
  {
    *p = '\0';
  }
 
  snprintf(tmp, sizeof(tmp), _("[-- %s output follows%s --]\n"), NONULL(app_name), p);
  state_attach_puts(state, tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_get_fingerprint_or_id()

const char * crypt_get_fingerprint_or_id	(	const char *	p,
		const char **	pphint,
		const char **	ppl,
		const char **	pps )

Get the fingerprint or long key ID.

Parameters

[in]	p	String to examine
[out]	pphint	Start of string to be passed to pgp_add_string_to_hints() or crypt_add_string_to_hints()
[out]	ppl	Start of long key ID if detected, else NULL
[out]	pps	Start of short key ID if detected, else NULL

Return values

ptr	Copy of fingerprint, if any, stripped of all spaces. Must be FREE'd by caller
NULL	Otherwise

Obtain pointers to fingerprint or short or long key ID, if any.

Upon return, at most one of return, *ppl and *pps pointers is non-NULL, indicating the longest fingerprint or ID found, if any.

Definition at line 1397 of file crypt.c.

{
  const char *ps = NULL;
  const char *pl = NULL;
  const char *phint = NULL;
  char *pfcopy = NULL;
  char *s1 = NULL;
  char *s2 = NULL;
  char c;
  int isid;
  size_t hexdigits;
 
  /* User input may be partial name, fingerprint or short or long key ID,
   * independent of `$pgp_long_ids`.
   * Fingerprint without spaces is 40 hex digits (SHA-1) or 32 hex digits (MD5).
   * Strip leading "0x" for key ID detection and prepare pl and ps to indicate
   * if an ID was found and to simplify logic in the key loop's inner
   * condition of the caller. */
 
  char *pf = mutt_str_skip_whitespace(p);
  if (mutt_istr_startswith(pf, "0x"))
    pf += 2;
 
  /* Check if a fingerprint is given, must be hex digits only, blanks
   * separating groups of 4 hex digits are allowed. Also pre-check for ID. */
  isid = 2; /* unknown */
  hexdigits = 0;
  s1 = pf;
  do
  {
    c = *(s1++);
    if ((('0' <= c) && (c <= '9')) || (('A' <= c) && (c <= 'F')) ||
        (('a' <= c) && (c <= 'f')))
    {
      hexdigits++;
      if (isid == 2)
        isid = 1; /* it is an ID so far */
    }
    else if (c)
    {
      isid = 0; /* not an ID */
      if ((c == ' ') && ((hexdigits % 4) == 0))
        ; /* skip blank before or after 4 hex digits */
      else
        break; /* any other character or position */
    }
  } while (c);
 
  /* If at end of input, check for correct fingerprint length and copy if. */
  pfcopy = (!c && ((hexdigits == 40) || (hexdigits == 32)) ? mutt_str_dup(pf) : NULL);
 
  if (pfcopy)
  {
    /* Use pfcopy to strip all spaces from fingerprint and as hint. */
    s1 = pfcopy;
    s2 = pfcopy;
    do
    {
      *(s1++) = *(s2 = mutt_str_skip_whitespace(s2));
    } while (*(s2++));
 
    phint = pfcopy;
    ps = NULL;
    pl = NULL;
  }
  else
  {
    phint = p;
    ps = NULL;
    pl = NULL;
    if (isid == 1)
    {
      if (mutt_str_len(pf) == 16)
        pl = pf; /* long key ID */
      else if (mutt_str_len(pf) == 8)
        ps = pf; /* short key ID */
    }
  }
 
  *pphint = phint;
  *ppl = pl;
  *pps = ps;
  return pfcopy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_is_numerical_keyid()

bool crypt_is_numerical_keyid

(

const char *

s

)

Is this a numerical keyid.

Parameters

s	Key to test

Return values

true	Keyid is numeric

Check if a crypt-hook value is a key id.

Definition at line 1490 of file crypt.c.

{
  /* or should we require the "0x"? */
  if (mutt_strn_equal(s, "0x", 2))
    s += 2;
  if (strlen(s) % 8)
    return false;
  while (*s)
    if (!strchr("0123456789ABCDEFabcdef", *s++))
      return false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_write_signed()

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

Write the message body/part.

Parameters

b	Body to write
state	State to use
tempfile	File to write to

Return values

0	Success
-1	Error

Body/part A described by state state to the given TEMPFILE.

Definition at line 765 of file crypt.c.

{
  if (!WithCrypto)
    return -1;
 
  FILE *fp = mutt_file_fopen(tempfile, "w");
  if (!fp)
  {
    mutt_perror("%s", tempfile);
    return -1;
  }
 
  if (!mutt_file_seek(state->fp_in, b->hdr_offset, SEEK_SET))
  {
    mutt_file_fclose(&fp);
    return -1;
  }
  size_t bytes = b->length + b->offset - b->hdr_offset;
  bool hadcr = false;
  while (bytes > 0)
  {
    const int c = fgetc(state->fp_in);
    if (c == EOF)
      break;
 
    bytes--;
 
    if (c == '\r')
    {
      hadcr = true;
    }
    else
    {
      if ((c == '\n') && !hadcr)
        fputc('\r', fp);
 
      hadcr = false;
    }
 
    fputc(c, fp);
  }
  mutt_file_fclose(&fp);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: