NeoMutt  2019-12-07-60-g0cfa53
Teaching an old dog new tricks
DOXYGEN
ncrypt.h File Reference

API for encryption/signing of emails. More...

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
+ Include dependency graph for ncrypt.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define SEC_NO_FLAGS   0
 No flags are set. More...
 
#define SEC_ENCRYPT   (1 << 0)
 Email is encrypted. More...
 
#define SEC_SIGN   (1 << 1)
 Email is signed. More...
 
#define SEC_GOODSIGN   (1 << 2)
 Email has a valid signature. More...
 
#define SEC_BADSIGN   (1 << 3)
 Email has a bad signature. More...
 
#define SEC_PARTSIGN   (1 << 4)
 Not all parts of the email is signed. More...
 
#define SEC_SIGNOPAQUE   (1 << 5)
 Email has an opaque signature (encrypted) More...
 
#define SEC_KEYBLOCK   (1 << 6)
 Email has a key attached. More...
 
#define SEC_INLINE   (1 << 7)
 Email has an inline signature. More...
 
#define SEC_OPPENCRYPT   (1 << 8)
 Opportunistic encrypt mode. More...
 
#define SEC_AUTOCRYPT   (1 << 9)
 Message will be, or was Autocrypt encrypt+signed. More...
 
#define SEC_AUTOCRYPT_OVERRIDE   (1 << 10)
 Indicates manual set/unset of encryption. More...
 
#define APPLICATION_PGP   (1 << 11)
 Use PGP to encrypt/sign. More...
 
#define APPLICATION_SMIME   (1 << 12)
 Use SMIME to encrypt/sign. More...
 
#define PGP_TRADITIONAL_CHECKED   (1 << 13)
 Email has a traditional (inline) signature. More...
 
#define SEC_ALL_FLAGS   ((1 << 14) - 1)
 
#define PGP_ENCRYPT   (APPLICATION_PGP | SEC_ENCRYPT)
 
#define PGP_SIGN   (APPLICATION_PGP | SEC_SIGN)
 
#define PGP_GOODSIGN   (APPLICATION_PGP | SEC_GOODSIGN)
 
#define PGP_KEY   (APPLICATION_PGP | SEC_KEYBLOCK)
 
#define PGP_INLINE   (APPLICATION_PGP | SEC_INLINE)
 
#define SMIME_ENCRYPT   (APPLICATION_SMIME | SEC_ENCRYPT)
 
#define SMIME_SIGN   (APPLICATION_SMIME | SEC_SIGN)
 
#define SMIME_GOODSIGN   (APPLICATION_SMIME | SEC_GOODSIGN)
 
#define SMIME_BADSIGN   (APPLICATION_SMIME | SEC_BADSIGN)
 
#define SMIME_OPAQUE   (APPLICATION_SMIME | SEC_SIGNOPAQUE)
 
#define WithCrypto   (APPLICATION_PGP | APPLICATION_SMIME)
 
#define KEYFLAG_NO_FLAGS   0
 No flags are set. More...
 
#define KEYFLAG_CANSIGN   (1 << 0)
 Key is suitable for signing. More...
 
#define KEYFLAG_CANENCRYPT   (1 << 1)
 Key is suitable for encryption. More...
 
#define KEYFLAG_ISX509   (1 << 2)
 Key is an X.509 key. More...
 
#define KEYFLAG_SECRET   (1 << 7)
 Key is a secret key. More...
 
#define KEYFLAG_EXPIRED   (1 << 8)
 Key is expired. More...
 
#define KEYFLAG_REVOKED   (1 << 9)
 Key is revoked. More...
 
#define KEYFLAG_DISABLED   (1 << 10)
 Key is marked disabled. More...
 
#define KEYFLAG_SUBKEY   (1 << 11)
 Key is a subkey. More...
 
#define KEYFLAG_CRITICAL   (1 << 12)
 Key is marked critical. More...
 
#define KEYFLAG_PREFER_ENCRYPTION   (1 << 13)
 Key's owner prefers encryption. More...
 
#define KEYFLAG_PREFER_SIGNING   (1 << 14)
 Key's owner prefers signing. More...
 
#define KEYFLAG_CANTUSE   (KEYFLAG_DISABLED | KEYFLAG_REVOKED | KEYFLAG_EXPIRED)
 
#define KEYFLAG_RESTRICTIONS   (KEYFLAG_CANTUSE | KEYFLAG_CRITICAL)
 
#define KEYFLAG_ABILITIES   (KEYFLAG_CANSIGN | KEYFLAG_CANENCRYPT | KEYFLAG_PREFER_ENCRYPTION | KEYFLAG_PREFER_SIGNING)
 

Typedefs

typedef uint16_t SecurityFlags
 Flags, e.g. SEC_ENCRYPT. More...
 
typedef uint16_t KeyFlags
 Flags describing PGP/SMIME keys, e.g. KEYFLAG_CANSIGN. More...
 

Functions

void crypt_extract_keys_from_messages (struct Mailbox *m, struct EmailList *el)
 Extract keys from a message. More...
 
void crypt_forget_passphrase (void)
 Forget a passphrase and display a message. More...
 
int crypt_get_keys (struct Email *e, char **keylist, bool oppenc_mode)
 Check we have all the keys we need. More...
 
void crypt_opportunistic_encrypt (struct Email *e)
 Can all recipients be determined. More...
 
SecurityFlags crypt_query (struct Body *m)
 Check out the type of encryption used. More...
 
bool crypt_valid_passphrase (SecurityFlags flags)
 Check that we have a usable passphrase, ask if not. More...
 
SecurityFlags mutt_is_application_pgp (struct Body *m)
 Does the message use PGP? More...
 
SecurityFlags mutt_is_application_smime (struct Body *m)
 Does the message use S/MIME? More...
 
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted (struct Body *b)
 Check for malformed layout. More...
 
SecurityFlags mutt_is_multipart_encrypted (struct Body *b)
 Does the message have encrypted parts? More...
 
SecurityFlags mutt_is_multipart_signed (struct Body *b)
 Is a message signed? More...
 
int mutt_is_valid_multipart_pgp_encrypted (struct Body *b)
 Is this a valid multi-part encrypted message? More...
 
int mutt_protect (struct Email *e, char *keylist, bool postpone)
 Encrypt and/or sign a message. More...
 
int mutt_protected_headers_handler (struct Body *m, struct State *s)
 Process a protected header - Implements handler_t. More...
 
bool mutt_should_hide_protected_subject (struct Email *e)
 Should NeoMutt hide the protected subject? More...
 
int mutt_signed_handler (struct Body *a, struct State *s)
 Verify a "multipart/signed" body - Implements handler_t. More...
 
bool crypt_has_module_backend (SecurityFlags type)
 Is there a crypto backend for a given type? More...
 
void crypt_init (void)
 Initialise the crypto backends. More...
 
void crypt_invoke_message (SecurityFlags type)
 Display an informative message. More...
 
int crypt_pgp_application_handler (struct Body *m, struct State *s)
 Wrapper for CryptModuleSpecs::application_handler() More...
 
int crypt_pgp_check_traditional (FILE *fp, struct Body *b, bool just_one)
 Wrapper for CryptModuleSpecs::pgp_check_traditional() More...
 
int crypt_pgp_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
 Wrapper for CryptModuleSpecs::decrypt_mime() More...
 
int crypt_pgp_encrypted_handler (struct Body *a, struct State *s)
 Wrapper for CryptModuleSpecs::encrypted_handler() More...
 
void crypt_pgp_extract_key_from_attachment (FILE *fp, struct Body *top)
 Wrapper for CryptModuleSpecs::pgp_extract_key_from_attachment() More...
 
void crypt_pgp_invoke_getkeys (struct Address *addr)
 Wrapper for CryptModuleSpecs::pgp_invoke_getkeys() More...
 
struct Bodycrypt_pgp_make_key_attachment (void)
 Wrapper for CryptModuleSpecs::pgp_make_key_attachment() More...
 
int crypt_pgp_send_menu (struct Email *e)
 Wrapper for CryptModuleSpecs::send_menu() More...
 
int crypt_smime_application_handler (struct Body *m, struct State *s)
 Wrapper for CryptModuleSpecs::application_handler() More...
 
int crypt_smime_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
 Wrapper for CryptModuleSpecs::decrypt_mime() More...
 
void crypt_smime_getkeys (struct Envelope *env)
 Wrapper for CryptModuleSpecs::smime_getkeys() More...
 
int crypt_smime_send_menu (struct Email *e)
 Wrapper for CryptModuleSpecs::send_menu() More...
 
int crypt_smime_verify_sender (struct Mailbox *m, struct Email *e)
 Wrapper for CryptModuleSpecs::smime_verify_sender() More...
 
void crypto_module_free (void)
 Clean up the crypto modules. More...
 

Variables

bool C_CryptTimestamp
 Config: Add a timestamp to PGP or SMIME output to prevent spoofing. More...
 
unsigned char C_PgpEncryptSelf
 Deprecated, see C_PgpSelfEncrypt. More...
 
unsigned char C_PgpMimeAuto
 Config: Prompt the user to use MIME if inline PGP fails. More...
 
bool C_PgpRetainableSigs
 Config: Create nested multipart/signed or encrypted messages. More...
 
bool C_PgpSelfEncrypt
 Config: Encrypted messages will also be encrypted to C_PgpDefaultKey too. More...
 
bool C_PgpStrictEnc
 Config: Encode PGP signed messages with quoted-printable (don't unset) More...
 
unsigned char C_SmimeEncryptSelf
 Deprecated, see C_SmimeSelfEncrypt. More...
 
bool C_SmimeSelfEncrypt
 Config: Encrypted messages will also be encrypt to C_SmimeDefaultKey too. More...
 
bool C_CryptUseGpgme
 Config: Use GPGME crypto backend. More...
 
bool C_PgpCheckExit
 Config: Check the exit code of PGP subprocess. More...
 
bool C_PgpCheckGpgDecryptStatusFd
 Config: File descriptor used for status info. More...
 
struct RegexC_PgpDecryptionOkay
 Config: Text indicating a successful decryption. More...
 
struct RegexC_PgpGoodSign
 Config: Text indicating a good signature. More...
 
long C_PgpTimeout
 Config: Time in seconds to cache a passphrase. More...
 
bool C_PgpUseGpgAgent
 Config: Use a PGP agent for caching passwords. More...
 
char * C_PgpClearsignCommand
 Config: (pgp) External command to inline-sign a message. More...
 
char * C_PgpDecodeCommand
 Config: (pgp) External command to decode a PGP attachment. More...
 
char * C_PgpDecryptCommand
 Config: (pgp) External command to decrypt a PGP message. More...
 
char * C_PgpEncryptOnlyCommand
 Config: (pgp) External command to encrypt, but not sign a message. More...
 
char * C_PgpEncryptSignCommand
 Config: (pgp) External command to encrypt and sign a message. More...
 
char * C_PgpExportCommand
 Config: (pgp) External command to export a public key from the user's keyring. More...
 
char * C_PgpGetkeysCommand
 Config: (pgp) External command to download a key for an email address. More...
 
char * C_PgpImportCommand
 Config: (pgp) External command to import a key into the user's keyring. More...
 
char * C_PgpListPubringCommand
 Config: (pgp) External command to list the public keys in a user's keyring. More...
 
char * C_PgpListSecringCommand
 Config: (pgp) External command to list the private keys in a user's keyring. More...
 
char * C_PgpSignCommand
 Config: (pgp) External command to create a detached PGP signature. More...
 
char * C_PgpVerifyCommand
 Config: (pgp) External command to verify PGP signatures. More...
 
char * C_PgpVerifyKeyCommand
 Config: (pgp) External command to verify key information. More...
 
bool C_SmimeAskCertLabel
 Config: Prompt the user for a label for SMIME certificates. More...
 
char * C_SmimeCaLocation
 Config: File containing trusted certificates. More...
 
char * C_SmimeCertificates
 Config: File containing user's public certificates. More...
 
char * C_SmimeDecryptCommand
 Config: (smime) External command to decrypt an SMIME message. More...
 
bool C_SmimeDecryptUseDefaultKey
 Config: Use the default key for decryption. More...
 
char * C_SmimeEncryptCommand
 Config: (smime) External command to encrypt a message. More...
 
char * C_SmimeGetCertCommand
 Config: (smime) External command to extract a certificate from a message. More...
 
char * C_SmimeGetCertEmailCommand
 Config: (smime) External command to get a certificate for an email. More...
 
char * C_SmimeGetSignerCertCommand
 Config: (smime) External command to extract a certificate from an email. More...
 
char * C_SmimeImportCertCommand
 Config: (smime) External command to import a certificate. More...
 
char * C_SmimeKeys
 Config: File containing user's private certificates. More...
 
char * C_SmimePk7outCommand
 Config: (smime) External command to extract a public certificate. More...
 
char * C_SmimeSignCommand
 Config: (smime) External command to sign a message. More...
 
char * C_SmimeSignDigestAlg
 Config: Digest algorithm. More...
 
long C_SmimeTimeout
 Config: Time in seconds to cache a passphrase. More...
 
char * C_SmimeVerifyCommand
 Config: (smime) External command to verify a signed message. More...
 
char * C_SmimeVerifyOpaqueCommand
 Config: (smime) External command to verify a signature. More...
 

Detailed Description

API for encryption/signing of emails.

Authors
  • Werner Koch
  • g10code GmbH
  • Pietro Cerutti

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 ncrypt.h.

Macro Definition Documentation

◆ SEC_NO_FLAGS

#define SEC_NO_FLAGS   0

No flags are set.

Definition at line 121 of file ncrypt.h.

◆ SEC_ENCRYPT

#define SEC_ENCRYPT   (1 << 0)

Email is encrypted.

Definition at line 122 of file ncrypt.h.

◆ SEC_SIGN

#define SEC_SIGN   (1 << 1)

Email is signed.

Definition at line 123 of file ncrypt.h.

◆ SEC_GOODSIGN

#define SEC_GOODSIGN   (1 << 2)

Email has a valid signature.

Definition at line 124 of file ncrypt.h.

◆ SEC_BADSIGN

#define SEC_BADSIGN   (1 << 3)

Email has a bad signature.

Definition at line 125 of file ncrypt.h.

◆ SEC_PARTSIGN

#define SEC_PARTSIGN   (1 << 4)

Not all parts of the email is signed.

Definition at line 126 of file ncrypt.h.

◆ SEC_SIGNOPAQUE

#define SEC_SIGNOPAQUE   (1 << 5)

Email has an opaque signature (encrypted)

Definition at line 127 of file ncrypt.h.

◆ SEC_KEYBLOCK

#define SEC_KEYBLOCK   (1 << 6)

Email has a key attached.

Definition at line 128 of file ncrypt.h.

◆ SEC_INLINE

#define SEC_INLINE   (1 << 7)

Email has an inline signature.

Definition at line 129 of file ncrypt.h.

◆ SEC_OPPENCRYPT

#define SEC_OPPENCRYPT   (1 << 8)

Opportunistic encrypt mode.

Definition at line 130 of file ncrypt.h.

◆ SEC_AUTOCRYPT

#define SEC_AUTOCRYPT   (1 << 9)

Message will be, or was Autocrypt encrypt+signed.

Definition at line 131 of file ncrypt.h.

◆ SEC_AUTOCRYPT_OVERRIDE

#define SEC_AUTOCRYPT_OVERRIDE   (1 << 10)

Indicates manual set/unset of encryption.

Definition at line 132 of file ncrypt.h.

◆ APPLICATION_PGP

#define APPLICATION_PGP   (1 << 11)

Use PGP to encrypt/sign.

Definition at line 134 of file ncrypt.h.

◆ APPLICATION_SMIME

#define APPLICATION_SMIME   (1 << 12)

Use SMIME to encrypt/sign.

Definition at line 135 of file ncrypt.h.

◆ PGP_TRADITIONAL_CHECKED

#define PGP_TRADITIONAL_CHECKED   (1 << 13)

Email has a traditional (inline) signature.

Definition at line 136 of file ncrypt.h.

◆ SEC_ALL_FLAGS

#define SEC_ALL_FLAGS   ((1 << 14) - 1)

Definition at line 138 of file ncrypt.h.

◆ PGP_ENCRYPT

#define PGP_ENCRYPT   (APPLICATION_PGP | SEC_ENCRYPT)

Definition at line 140 of file ncrypt.h.

◆ PGP_SIGN

#define PGP_SIGN   (APPLICATION_PGP | SEC_SIGN)

Definition at line 141 of file ncrypt.h.

◆ PGP_GOODSIGN

#define PGP_GOODSIGN   (APPLICATION_PGP | SEC_GOODSIGN)

Definition at line 142 of file ncrypt.h.

◆ PGP_KEY

#define PGP_KEY   (APPLICATION_PGP | SEC_KEYBLOCK)

Definition at line 143 of file ncrypt.h.

◆ PGP_INLINE

#define PGP_INLINE   (APPLICATION_PGP | SEC_INLINE)

Definition at line 144 of file ncrypt.h.

◆ SMIME_ENCRYPT

#define SMIME_ENCRYPT   (APPLICATION_SMIME | SEC_ENCRYPT)

Definition at line 146 of file ncrypt.h.

◆ SMIME_SIGN

#define SMIME_SIGN   (APPLICATION_SMIME | SEC_SIGN)

Definition at line 147 of file ncrypt.h.

◆ SMIME_GOODSIGN

#define SMIME_GOODSIGN   (APPLICATION_SMIME | SEC_GOODSIGN)

Definition at line 148 of file ncrypt.h.

◆ SMIME_BADSIGN

#define SMIME_BADSIGN   (APPLICATION_SMIME | SEC_BADSIGN)

Definition at line 149 of file ncrypt.h.

◆ SMIME_OPAQUE

#define SMIME_OPAQUE   (APPLICATION_SMIME | SEC_SIGNOPAQUE)

Definition at line 150 of file ncrypt.h.

◆ WithCrypto

#define WithCrypto   (APPLICATION_PGP | APPLICATION_SMIME)

Definition at line 160 of file ncrypt.h.

◆ KEYFLAG_NO_FLAGS

#define KEYFLAG_NO_FLAGS   0

No flags are set.

Definition at line 170 of file ncrypt.h.

◆ KEYFLAG_CANSIGN

#define KEYFLAG_CANSIGN   (1 << 0)

Key is suitable for signing.

Definition at line 171 of file ncrypt.h.

◆ KEYFLAG_CANENCRYPT

#define KEYFLAG_CANENCRYPT   (1 << 1)

Key is suitable for encryption.

Definition at line 172 of file ncrypt.h.

◆ KEYFLAG_ISX509

#define KEYFLAG_ISX509   (1 << 2)

Key is an X.509 key.

Definition at line 173 of file ncrypt.h.

◆ KEYFLAG_SECRET

#define KEYFLAG_SECRET   (1 << 7)

Key is a secret key.

Definition at line 174 of file ncrypt.h.

◆ KEYFLAG_EXPIRED

#define KEYFLAG_EXPIRED   (1 << 8)

Key is expired.

Definition at line 175 of file ncrypt.h.

◆ KEYFLAG_REVOKED

#define KEYFLAG_REVOKED   (1 << 9)

Key is revoked.

Definition at line 176 of file ncrypt.h.

◆ KEYFLAG_DISABLED

#define KEYFLAG_DISABLED   (1 << 10)

Key is marked disabled.

Definition at line 177 of file ncrypt.h.

◆ KEYFLAG_SUBKEY

#define KEYFLAG_SUBKEY   (1 << 11)

Key is a subkey.

Definition at line 178 of file ncrypt.h.

◆ KEYFLAG_CRITICAL

#define KEYFLAG_CRITICAL   (1 << 12)

Key is marked critical.

Definition at line 179 of file ncrypt.h.

◆ KEYFLAG_PREFER_ENCRYPTION

#define KEYFLAG_PREFER_ENCRYPTION   (1 << 13)

Key's owner prefers encryption.

Definition at line 180 of file ncrypt.h.

◆ KEYFLAG_PREFER_SIGNING

#define KEYFLAG_PREFER_SIGNING   (1 << 14)

Key's owner prefers signing.

Definition at line 181 of file ncrypt.h.

◆ KEYFLAG_CANTUSE

#define KEYFLAG_CANTUSE   (KEYFLAG_DISABLED | KEYFLAG_REVOKED | KEYFLAG_EXPIRED)

Definition at line 183 of file ncrypt.h.

◆ KEYFLAG_RESTRICTIONS

#define KEYFLAG_RESTRICTIONS   (KEYFLAG_CANTUSE | KEYFLAG_CRITICAL)

Definition at line 184 of file ncrypt.h.

◆ KEYFLAG_ABILITIES

Definition at line 186 of file ncrypt.h.

Typedef Documentation

◆ SecurityFlags

typedef uint16_t SecurityFlags

Flags, e.g. SEC_ENCRYPT.

Definition at line 120 of file ncrypt.h.

◆ KeyFlags

typedef uint16_t KeyFlags

Flags describing PGP/SMIME keys, e.g. KEYFLAG_CANSIGN.

Definition at line 169 of file ncrypt.h.

Function Documentation

◆ crypt_extract_keys_from_messages()

void crypt_extract_keys_from_messages ( struct Mailbox m,
struct EmailList *  el 
)

Extract keys from a message.

Parameters
mMailbox
elList of Emails to process

The extracted keys will be added to the user's keyring.

Definition at line 851 of file crypt.c.

852 {
853  if (!WithCrypto)
854  return;
855 
856  struct Buffer *tempfname = mutt_buffer_pool_get();
857  mutt_buffer_mktemp(tempfname);
858  FILE *fp_out = mutt_file_fopen(mutt_b2s(tempfname), "w");
859  if (!fp_out)
860  {
861  mutt_perror(mutt_b2s(tempfname));
862  goto cleanup;
863  }
864 
866  OptDontHandlePgpKeys = true;
867 
868  struct EmailNode *en = NULL;
869  STAILQ_FOREACH(en, el, entries)
870  {
871  struct Email *e = en->email;
872 
875  {
876  mutt_file_fclose(&fp_out);
877  break;
878  }
879 
880  if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
881  {
883  fflush(fp_out);
884 
885  mutt_endwin();
886  puts(_("Trying to extract PGP keys...\n"));
887  crypt_pgp_invoke_import(mutt_b2s(tempfname));
888  }
889 
890  if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
891  {
892  if (e->security & SEC_ENCRYPT)
893  {
895  CH_NO_FLAGS, 0);
896  }
897  else
899  fflush(fp_out);
900 
901  char *mbox = NULL;
902  if (!TAILQ_EMPTY(&e->env->from))
903  {
905  mbox = TAILQ_FIRST(&e->env->from)->mailbox;
906  }
907  else if (!TAILQ_EMPTY(&e->env->sender))
908  {
910  mbox = TAILQ_FIRST(&e->env->sender)->mailbox;
911  }
912  if (mbox)
913  {
914  mutt_endwin();
915  puts(_("Trying to extract S/MIME certificates..."));
916  crypt_smime_invoke_import(mutt_b2s(tempfname), mbox);
917  }
918  }
919 
920  rewind(fp_out);
921  }
922 
923  mutt_file_fclose(&fp_out);
924  if (isendwin())
926 
927  mutt_file_unlink(mutt_b2s(tempfname));
928 
929  if (WithCrypto & APPLICATION_PGP)
930  OptDontHandlePgpKeys = false;
931 
932 cleanup:
933  mutt_buffer_pool_release(&tempfname);
934 }
#define MUTT_CM_DECODE_CRYPT
Definition: copy.h:47
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:78
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:303
The envelope/body of an email.
Definition: email.h:37
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FIRST(head)
Definition: queue.h:716
#define mutt_perror(...)
Definition: logging.h:85
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:194
String manipulation buffer.
Definition: buffer.h:33
void mutt_parse_mime_message(struct Mailbox *m, struct Email *e)
Parse a MIME email.
Definition: mutt_parse.c:49
int mutt_copy_message(FILE *fp_out, struct Mailbox *m, struct Email *e, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:810
#define _(a)
Definition: message.h:28
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
#define MUTT_CM_NO_FLAGS
No flags are set.
Definition: copy.h:34
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:145
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
struct Envelope * env
Envelope information.
Definition: email.h:89
WHERE bool OptDontHandlePgpKeys
(pseudo) used to extract PGP keys
Definition: options.h:34
#define mutt_b2s(buf)
Definition: buffer.h:41
void mutt_endwin(void)
Shutdown curses/slang.
Definition: curs_lib.c:545
void crypt_pgp_invoke_import(const char *fname)
Wrapper for CryptModuleSpecs::pgp_invoke_import()
Definition: cryptglue.c:358
#define CH_NO_FLAGS
No flags are set.
Definition: copy.h:50
#define MUTT_CM_DECODE
Decode the message body into text/plain.
Definition: copy.h:37
#define MUTT_CM_CHARCONV
Perform character set conversions.
Definition: copy.h:41
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
#define MUTT_CM_DECODE_SMIME
Used for decoding S/MIME messages.
Definition: copy.h:45
int mutt_any_key_to_continue(const char *s)
Prompt the user to &#39;press any key&#39; and wait.
Definition: curs_lib.c:578
void crypt_smime_invoke_import(const char *infile, const char *mailbox)
Wrapper for CryptModuleSpecs::smime_invoke_import()
Definition: cryptglue.c:504
struct Email * email
Email in the list.
Definition: email.h:116
struct AddressList sender
Email&#39;s sender.
Definition: envelope.h:61
List of Emails.
Definition: email.h:114
#define TAILQ_EMPTY(head)
Definition: queue.h:714
#define MUTT_CM_NOHEADER
Don&#39;t copy the message header.
Definition: copy.h:35
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:585
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_forget_passphrase()

void crypt_forget_passphrase ( void  )

Forget a passphrase and display a message.

Definition at line 103 of file crypt.c.

104 {
107 
110 
111  if (WithCrypto)
112  {
113  /* L10N: Due to the implementation details (e.g. some passwords are managed
114  by gpg-agent) we can't know whether we forgot zero, 1, 12, ...
115  passwords. So in English we use "Passphrases". Your language might
116  have other means to express this. */
117  mutt_message(_("Passphrases forgotten"));
118  }
119 }
#define mutt_message(...)
Definition: logging.h:83
void crypt_pgp_void_passphrase(void)
Wrapper for CryptModuleSpecs::void_passphrase()
Definition: cryptglue.c:183
#define _(a)
Definition: message.h:28
void crypt_smime_void_passphrase(void)
Wrapper for CryptModuleSpecs::void_passphrase()
Definition: cryptglue.c:407
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_get_keys()

int crypt_get_keys ( struct Email e,
char **  keylist,
bool  oppenc_mode 
)

Check we have all the keys we need.

Parameters
[in]eEmail with addresses to match
[out]keylistKeys needed
[in]oppenc_modeIf true, use opportunistic encryption
Return values
0Success
-1Error

Do a quick check to make sure that we can find all of the encryption keys if the user has requested this service. Return the list of keys in KEYLIST. If oppenc_mode is true, only keys that can be determined without prompting will be used.

Definition at line 950 of file crypt.c.

951 {
952  if (!WithCrypto)
953  return 0;
954 
955  struct AddressList addrlist = TAILQ_HEAD_INITIALIZER(addrlist);
956  const char *fqdn = mutt_fqdn(true);
957  char *self_encrypt = NULL;
958 
959  /* Do a quick check to make sure that we can find all of the encryption
960  * keys if the user has requested this service. */
961 
962  *keylist = NULL;
963 
964 #ifdef USE_AUTOCRYPT
965  if (!oppenc_mode && (e->security & SEC_AUTOCRYPT))
966  {
968  return -1;
969  return 0;
970  }
971 #endif
972 
974  OptPgpCheckTrust = true;
975 
976  mutt_addrlist_copy(&addrlist, &e->env->to, false);
977  mutt_addrlist_copy(&addrlist, &e->env->cc, false);
978  mutt_addrlist_copy(&addrlist, &e->env->bcc, false);
979  mutt_addrlist_qualify(&addrlist, fqdn);
980  mutt_addrlist_dedupe(&addrlist);
981 
982  if (oppenc_mode || (e->security & SEC_ENCRYPT))
983  {
984  if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
985  {
986  *keylist = crypt_pgp_find_keys(&addrlist, oppenc_mode);
987  if (!*keylist)
988  {
989  mutt_addrlist_clear(&addrlist);
990  return -1;
991  }
992  OptPgpCheckTrust = false;
994  self_encrypt = C_PgpDefaultKey;
995  }
996  if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
997  {
998  *keylist = crypt_smime_find_keys(&addrlist, oppenc_mode);
999  if (!*keylist)
1000  {
1001  mutt_addrlist_clear(&addrlist);
1002  return -1;
1003  }
1005  self_encrypt = C_SmimeDefaultKey;
1006  }
1007  }
1008 
1009  if (!oppenc_mode && self_encrypt)
1010  {
1011  const size_t keylist_size = mutt_str_strlen(*keylist);
1012  mutt_mem_realloc(keylist, keylist_size + mutt_str_strlen(self_encrypt) + 2);
1013  sprintf(*keylist + keylist_size, " %s", self_encrypt);
1014  }
1015 
1016  mutt_addrlist_clear(&addrlist);
1017 
1018  return 0;
1019 }
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
char * crypt_smime_find_keys(struct AddressList *addrlist, bool oppenc_mode)
Wrapper for CryptModuleSpecs::find_keys()
Definition: cryptglue.c:471
WHERE char * C_SmimeDefaultKey
Config: Default key for SMIME operations.
Definition: globals.h:163
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1382
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:728
size_t mutt_str_strlen(const char *a)
Calculate the length of a string, safely.
Definition: string.c:666
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
bool C_PgpSelfEncrypt
Config: Encrypted messages will also be encrypted to C_PgpDefaultKey too.
Definition: crypt.c:70
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1319
unsigned char C_PgpEncryptSelf
Deprecated, see C_PgpSelfEncrypt.
Definition: crypt.c:67
struct Envelope * env
Envelope information.
Definition: email.h:89
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:114
bool C_SmimeSelfEncrypt
Config: Encrypted messages will also be encrypt to C_SmimeDefaultKey too.
Definition: crypt.c:73
Do no use Autocrypt.
Definition: autocrypt.h:104
unsigned char C_SmimeEncryptSelf
Deprecated, see C_SmimeSelfEncrypt.
Definition: crypt.c:72
WHERE bool OptPgpCheckTrust
(pseudo) used by pgp_select_key()
Definition: options.h:47
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
const char * mutt_fqdn(bool may_hide_host)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:2531
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
Expand local names in an Address list using a hostname.
Definition: address.c:641
char * crypt_pgp_find_keys(struct AddressList *addrlist, bool oppenc_mode)
Wrapper for CryptModuleSpecs::find_keys()
Definition: cryptglue.c:310
enum AutocryptRec mutt_autocrypt_ui_recommendation(struct Email *e, char **keylist)
Get the recommended action for an Email.
Definition: autocrypt.c:561
WHERE char * C_PgpDefaultKey
Config: Default key to use for PGP operations.
Definition: globals.h:159
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:630
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_opportunistic_encrypt()

void crypt_opportunistic_encrypt ( struct Email e)

Can all recipients be determined.

Parameters
eEmail

Check if all recipients keys can be automatically determined. Enable encryption if they can, otherwise disable encryption.

Definition at line 1028 of file crypt.c.

1029 {
1030  if (!WithCrypto)
1031  return;
1032 
1034  return;
1035 
1036  char *pgpkeylist = NULL;
1037 
1038  crypt_get_keys(e, &pgpkeylist, 1);
1039  if (pgpkeylist)
1040  {
1041  e->security |= SEC_ENCRYPT;
1042  FREE(&pgpkeylist);
1043  }
1044  else
1045  {
1046  e->security &= ~SEC_ENCRYPT;
1047  }
1048 }
int crypt_get_keys(struct Email *e, char **keylist, bool oppenc_mode)
Check we have all the keys we need.
Definition: crypt.c:950
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
WHERE bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: globals.h:269
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: ncrypt.h:130
#define FREE(x)
Definition: memory.h:40
#define WithCrypto
Definition: ncrypt.h:160
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_query()

SecurityFlags crypt_query ( struct Body m)

Check out the type of encryption used.

Parameters
mBody of email
Return values
numFlags, see SecurityFlags
0Error (SEC_NO_FLAGS)

Set the cached status values if there are any.

Definition at line 692 of file crypt.c.

693 {
694  if (!WithCrypto || !m)
695  return SEC_NO_FLAGS;
696 
698 
699  if (m->type == TYPE_APPLICATION)
700  {
702  rc |= mutt_is_application_pgp(m);
703 
705  {
706  rc |= mutt_is_application_smime(m);
707  if (rc && m->goodsig)
708  rc |= SEC_GOODSIGN;
709  if (rc && m->badsig)
710  rc |= SEC_BADSIGN;
711  }
712  }
713  else if (((WithCrypto & APPLICATION_PGP) != 0) && (m->type == TYPE_TEXT))
714  {
715  rc |= mutt_is_application_pgp(m);
716  if (rc && m->goodsig)
717  rc |= SEC_GOODSIGN;
718  }
719 
720  if (m->type == TYPE_MULTIPART)
721  {
723  rc |= mutt_is_multipart_signed(m);
725 
726  if (rc && m->goodsig)
727  rc |= SEC_GOODSIGN;
728 #ifdef USE_AUTOCRYPT
729  if (rc && m->is_autocrypt)
730  rc |= SEC_AUTOCRYPT;
731 #endif
732  }
733 
734  if ((m->type == TYPE_MULTIPART) || (m->type == TYPE_MESSAGE))
735  {
736  SecurityFlags u = m->parts ? SEC_ALL_FLAGS : SEC_NO_FLAGS; /* Bits set in all parts */
737  SecurityFlags w = SEC_NO_FLAGS; /* Bits set in any part */
738 
739  for (struct Body *b = m->parts; b; b = b->next)
740  {
741  const SecurityFlags v = crypt_query(b);
742  u &= v;
743  w |= v;
744  }
745  rc |= u | (w & ~SEC_GOODSIGN);
746 
747  if ((w & SEC_GOODSIGN) && !(u & SEC_GOODSIGN))
748  rc |= SEC_PARTSIGN;
749  }
750 
751  return rc;
752 }
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
bool is_autocrypt
Flag autocrypt-decrypted messages for replying.
Definition: body.h:79
struct Body * next
next attachment in the list
Definition: body.h:53
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: ncrypt.h:126
The body of an email.
Definition: body.h:34
#define SEC_BADSIGN
Email has a bad signature.
Definition: ncrypt.h:125
#define SEC_ALL_FLAGS
Definition: ncrypt.h:138
SecurityFlags mutt_is_multipart_encrypted(struct Body *b)
Does the message have encrypted parts?
Definition: crypt.c:451
#define SEC_GOODSIGN
Email has a valid signature.
Definition: ncrypt.h:124
bool badsig
Bad cryptographic signature (needed to check encrypted s/mime-signatures)
Definition: body.h:77
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:410
bool goodsig
Good cryptographic signature.
Definition: body.h:75
SecurityFlags mutt_is_application_pgp(struct Body *m)
Does the message use PGP?
Definition: crypt.c:557
Type: &#39;text/*&#39;.
Definition: mime.h:38
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Definition: crypt.c:512
SecurityFlags mutt_is_application_smime(struct Body *m)
Does the message use S/MIME?
Definition: crypt.c:616
unsigned int type
content-type primary type
Definition: body.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
Type: &#39;message/*&#39;.
Definition: mime.h:35
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: ncrypt.h:120
#define WithCrypto
Definition: ncrypt.h:160
SecurityFlags crypt_query(struct Body *m)
Check out the type of encryption used.
Definition: crypt.c:692
Type: &#39;application/*&#39;.
Definition: mime.h:33
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_valid_passphrase()

bool crypt_valid_passphrase ( SecurityFlags  flags)

Check that we have a usable passphrase, ask if not.

Parameters
flagsFlags, see SecurityFlags
Return values
trueSuccess
falseFailed

Definition at line 145 of file crypt.c.

146 {
147  bool rc = false;
148 
149 #ifndef DEBUG
150  disable_coredumps();
151 #endif
152 
153  if (((WithCrypto & APPLICATION_PGP) != 0) && (flags & APPLICATION_PGP))
155 
156  if (((WithCrypto & APPLICATION_SMIME) != 0) && (flags & APPLICATION_SMIME))
158 
159  return rc;
160 }
bool crypt_smime_valid_passphrase(void)
Wrapper for CryptModuleSpecs::valid_passphrase()
Definition: cryptglue.c:416
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
#define WithCrypto
Definition: ncrypt.h:160
bool crypt_pgp_valid_passphrase(void)
Wrapper for CryptModuleSpecs::valid_passphrase()
Definition: cryptglue.c:192
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_is_application_pgp()

SecurityFlags mutt_is_application_pgp ( struct Body m)

Does the message use PGP?

Parameters
mBody of email
Return values
>0Message uses PGP, e.g. PGP_ENCRYPT
0Message doesn't use PGP, (SEC_NO_FLAGS)

Definition at line 557 of file crypt.c.

558 {
560  char *p = NULL;
561 
562  if (m->type == TYPE_APPLICATION)
563  {
564  if ((mutt_str_strcasecmp(m->subtype, "pgp") == 0) ||
565  (mutt_str_strcasecmp(m->subtype, "x-pgp-message") == 0))
566  {
567  p = mutt_param_get(&m->parameter, "x-action");
568  if (p && ((mutt_str_strcasecmp(p, "sign") == 0) ||
569  (mutt_str_strcasecmp(p, "signclear") == 0)))
570  {
571  t |= PGP_SIGN;
572  }
573 
574  p = mutt_param_get(&m->parameter, "format");
575  if (p && (mutt_str_strcasecmp(p, "keys-only") == 0))
576  {
577  t |= PGP_KEY;
578  }
579 
580  if (t == SEC_NO_FLAGS)
581  t |= PGP_ENCRYPT; /* not necessarily correct, but... */
582  }
583 
584  if (mutt_str_strcasecmp(m->subtype, "pgp-signed") == 0)
585  t |= PGP_SIGN;
586 
587  if (mutt_str_strcasecmp(m->subtype, "pgp-keys") == 0)
588  t |= PGP_KEY;
589  }
590  else if ((m->type == TYPE_TEXT) && (mutt_str_strcasecmp("plain", m->subtype) == 0))
591  {
592  if (((p = mutt_param_get(&m->parameter, "x-mutt-action")) ||
593  (p = mutt_param_get(&m->parameter, "x-action")) ||
594  (p = mutt_param_get(&m->parameter, "action"))) &&
595  mutt_str_startswith(p, "pgp-sign", CASE_IGNORE))
596  {
597  t |= PGP_SIGN;
598  }
599  else if (p && mutt_str_startswith(p, "pgp-encrypt", CASE_IGNORE))
600  t |= PGP_ENCRYPT;
601  else if (p && mutt_str_startswith(p, "pgp-keys", CASE_IGNORE))
602  t |= PGP_KEY;
603  }
604  if (t)
605  t |= PGP_INLINE;
606 
607  return t;
608 }
#define PGP_INLINE
Definition: ncrypt.h:144
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
#define PGP_SIGN
Definition: ncrypt.h:141
char * subtype
content-type subtype
Definition: body.h:37
#define PGP_KEY
Definition: ncrypt.h:143
Type: &#39;text/*&#39;.
Definition: mime.h:38
Ignore case when comparing strings.
Definition: string2.h:68
unsigned int type
content-type primary type
Definition: body.h:65
size_t mutt_str_startswith(const char *str, const char *prefix, enum CaseSensitivity cs)
Check whether a string starts with a prefix.
Definition: string.c:168
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: ncrypt.h:120
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
Type: &#39;application/*&#39;.
Definition: mime.h:33
#define PGP_ENCRYPT
Definition: ncrypt.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_is_application_smime()

SecurityFlags mutt_is_application_smime ( struct Body m)

Does the message use S/MIME?

Parameters
mBody of email
Return values
>0Message uses S/MIME, e.g. SMIME_ENCRYPT
0Message doesn't use S/MIME, (SEC_NO_FLAGS)

Definition at line 616 of file crypt.c.

617 {
618  if (!m)
619  return SEC_NO_FLAGS;
620 
621  if (((m->type & TYPE_APPLICATION) == 0) || !m->subtype)
622  return SEC_NO_FLAGS;
623 
624  char *t = NULL;
625  bool complain = false;
626  /* S/MIME MIME types don't need x- anymore, see RFC2311 */
627  if ((mutt_str_strcasecmp(m->subtype, "x-pkcs7-mime") == 0) ||
628  (mutt_str_strcasecmp(m->subtype, "pkcs7-mime") == 0))
629  {
630  t = mutt_param_get(&m->parameter, "smime-type");
631  if (t)
632  {
633  if (mutt_str_strcasecmp(t, "enveloped-data") == 0)
634  return SMIME_ENCRYPT;
635  if (mutt_str_strcasecmp(t, "signed-data") == 0)
636  return SMIME_SIGN | SMIME_OPAQUE;
637  return SEC_NO_FLAGS;
638  }
639  /* Netscape 4.7 uses
640  * Content-Description: S/MIME Encrypted Message
641  * instead of Content-Type parameter */
642  if (mutt_str_strcasecmp(m->description, "S/MIME Encrypted Message") == 0)
643  return SMIME_ENCRYPT;
644  complain = true;
645  }
646  else if (mutt_str_strcasecmp(m->subtype, "octet-stream") != 0)
647  return SEC_NO_FLAGS;
648 
649  t = mutt_param_get(&m->parameter, "name");
650 
651  if (!t)
652  t = m->d_filename;
653  if (!t)
654  t = m->filename;
655  if (!t)
656  {
657  if (complain)
658  {
659  mutt_message(
660  _("S/MIME messages with no hints on content are unsupported"));
661  }
662  return SEC_NO_FLAGS;
663  }
664 
665  /* no .p7c, .p10 support yet. */
666 
667  int len = mutt_str_strlen(t) - 4;
668  if ((len > 0) && (*(t + len) == '.'))
669  {
670  len++;
671  if (mutt_str_strcasecmp((t + len), "p7m") == 0)
672  {
673  /* Not sure if this is the correct thing to do, but
674  * it's required for compatibility with Outlook */
675  return SMIME_SIGN | SMIME_OPAQUE;
676  }
677  else if (mutt_str_strcasecmp((t + len), "p7s") == 0)
678  return SMIME_SIGN | SMIME_OPAQUE;
679  }
680 
681  return SEC_NO_FLAGS;
682 }
char * filename
when sending a message, this is the file to which this structure refers
Definition: body.h:46
#define mutt_message(...)
Definition: logging.h:83
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
#define _(a)
Definition: message.h:28
#define SMIME_SIGN
Definition: ncrypt.h:147
size_t mutt_str_strlen(const char *a)
Calculate the length of a string, safely.
Definition: string.c:666
#define SMIME_OPAQUE
Definition: ncrypt.h:150
char * subtype
content-type subtype
Definition: body.h:37
char * description
content-description
Definition: body.h:40
unsigned int type
content-type primary type
Definition: body.h:65
#define SMIME_ENCRYPT
Definition: ncrypt.h:146
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
char * d_filename
filename to be used for the content-disposition header.
Definition: body.h:47
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
Type: &#39;application/*&#39;.
Definition: mime.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_is_malformed_multipart_pgp_encrypted()

SecurityFlags mutt_is_malformed_multipart_pgp_encrypted ( struct Body b)

Check for malformed layout.

Parameters
bBody of email
Return values
numSuccess, see SecurityFlags
0Error, (SEC_NO_FLAGS)

This checks for the malformed layout caused by MS Exchange in some cases:

<multipart/mixed>
<text/plain>
<application/pgp-encrypted> [BASE64-encoded]
<application/octet-stream> [BASE64-encoded]

Definition at line 512 of file crypt.c.

513 {
514  if (!(WithCrypto & APPLICATION_PGP))
515  return SEC_NO_FLAGS;
516 
517  if (!b || (b->type != TYPE_MULTIPART) || !b->subtype ||
518  (mutt_str_strcasecmp(b->subtype, "mixed") != 0))
519  {
520  return SEC_NO_FLAGS;
521  }
522 
523  b = b->parts;
524  if (!b || (b->type != TYPE_TEXT) || !b->subtype ||
525  (mutt_str_strcasecmp(b->subtype, "plain") != 0) || (b->length != 0))
526  {
527  return SEC_NO_FLAGS;
528  }
529 
530  b = b->next;
531  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
532  (mutt_str_strcasecmp(b->subtype, "pgp-encrypted") != 0))
533  {
534  return SEC_NO_FLAGS;
535  }
536 
537  b = b->next;
538  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
539  (mutt_str_strcasecmp(b->subtype, "octet-stream") != 0))
540  {
541  return SEC_NO_FLAGS;
542  }
543 
544  b = b->next;
545  if (b)
546  return SEC_NO_FLAGS;
547 
548  return PGP_ENCRYPT;
549 }
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
struct Body * next
next attachment in the list
Definition: body.h:53
char * subtype
content-type subtype
Definition: body.h:37
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
Type: &#39;text/*&#39;.
Definition: mime.h:38
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
unsigned int type
content-type primary type
Definition: body.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
#define WithCrypto
Definition: ncrypt.h:160
Type: &#39;application/*&#39;.
Definition: mime.h:33
#define PGP_ENCRYPT
Definition: ncrypt.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_is_multipart_encrypted()

SecurityFlags mutt_is_multipart_encrypted ( struct Body b)

Does the message have encrypted parts?

Parameters
bBody of email
Return values
numMessage has got encrypted parts, see SecurityFlags
0Message hasn't got encrypted parts (SEC_NO_FLAGS)

Definition at line 451 of file crypt.c.

452 {
453  if ((WithCrypto & APPLICATION_PGP) == 0)
454  return SEC_NO_FLAGS;
455 
456  char *p = NULL;
457 
458  if (!b || (b->type != TYPE_MULTIPART) || !b->subtype ||
459  (mutt_str_strcasecmp(b->subtype, "encrypted") != 0) ||
460  !(p = mutt_param_get(&b->parameter, "protocol")) ||
461  (mutt_str_strcasecmp(p, "application/pgp-encrypted") != 0))
462  {
463  return SEC_NO_FLAGS;
464  }
465 
466  return PGP_ENCRYPT;
467 }
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
char * subtype
content-type subtype
Definition: body.h:37
unsigned int type
content-type primary type
Definition: body.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
#define WithCrypto
Definition: ncrypt.h:160
#define PGP_ENCRYPT
Definition: ncrypt.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_is_multipart_signed()

SecurityFlags mutt_is_multipart_signed ( struct Body b)

Is a message signed?

Parameters
bBody of email
Return values
numMessage is signed, see SecurityFlags
0Message is not signed (SEC_NO_FLAGS)

Definition at line 410 of file crypt.c.

411 {
412  if (!b || (b->type != TYPE_MULTIPART) || !b->subtype ||
413  (mutt_str_strcasecmp(b->subtype, "signed") != 0))
414  {
415  return SEC_NO_FLAGS;
416  }
417 
418  char *p = mutt_param_get(&b->parameter, "protocol");
419  if (!p)
420  return SEC_NO_FLAGS;
421 
422  if (!(mutt_str_strcasecmp(p, "multipart/mixed") != 0))
423  return SEC_SIGN;
424 
425  if (((WithCrypto & APPLICATION_PGP) != 0) &&
426  !(mutt_str_strcasecmp(p, "application/pgp-signature") != 0))
427  {
428  return PGP_SIGN;
429  }
430 
431  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
432  !(mutt_str_strcasecmp(p, "application/x-pkcs7-signature") != 0))
433  {
434  return SMIME_SIGN;
435  }
436  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
437  !(mutt_str_strcasecmp(p, "application/pkcs7-signature") != 0))
438  {
439  return SMIME_SIGN;
440  }
441 
442  return SEC_NO_FLAGS;
443 }
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
#define SMIME_SIGN
Definition: ncrypt.h:147
#define PGP_SIGN
Definition: ncrypt.h:141
char * subtype
content-type subtype
Definition: body.h:37
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
unsigned int type
content-type primary type
Definition: body.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_is_valid_multipart_pgp_encrypted()

int mutt_is_valid_multipart_pgp_encrypted ( struct Body b)

Is this a valid multi-part encrypted message?

Parameters
bBody of email
Return values
>0Message is valid, with encrypted parts, e.g. PGP_ENCRYPT
0Message hasn't got encrypted parts

Definition at line 475 of file crypt.c.

476 {
478  return 0;
479 
480  b = b->parts;
481  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
482  (mutt_str_strcasecmp(b->subtype, "pgp-encrypted") != 0))
483  {
484  return 0;
485  }
486 
487  b = b->next;
488  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
489  (mutt_str_strcasecmp(b->subtype, "octet-stream") != 0))
490  {
491  return 0;
492  }
493 
494  return PGP_ENCRYPT;
495 }
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
struct Body * next
next attachment in the list
Definition: body.h:53
SecurityFlags mutt_is_multipart_encrypted(struct Body *b)
Does the message have encrypted parts?
Definition: crypt.c:451
char * subtype
content-type subtype
Definition: body.h:37
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
unsigned int type
content-type primary type
Definition: body.h:65
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
Type: &#39;application/*&#39;.
Definition: mime.h:33
#define PGP_ENCRYPT
Definition: ncrypt.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_protect()

int mutt_protect ( struct Email e,
char *  keylist,
bool  postpone 
)

Encrypt and/or sign a message.

Parameters
eEmail
keylistList of keys to encrypt to (space-separated)
postponeWhen true, signing is automatically disabled
Return values
0Success
-1Error

Definition at line 170 of file crypt.c.

171 {
172  struct Body *pbody = NULL, *tmp_pbody = NULL;
173  struct Body *tmp_smime_pbody = NULL;
174  struct Body *tmp_pgp_pbody = NULL;
175  bool has_retainable_sig = false;
176 
177  if (!WithCrypto)
178  return -1;
179 
180  int security = e->security;
181  int sign = security & (SEC_AUTOCRYPT | SEC_SIGN);
182  if (postpone)
183  {
184  sign = SEC_NO_FLAGS;
185  security &= ~SEC_SIGN;
186  }
187 
188  if (!(security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) && !sign)
189  return 0;
190 
191  if (sign && !(security & SEC_AUTOCRYPT) && !crypt_valid_passphrase(security))
192  return -1;
193 
194  if (((WithCrypto & APPLICATION_PGP) != 0) && !(security & SEC_AUTOCRYPT) &&
195  ((security & PGP_INLINE) == PGP_INLINE))
196  {
197  if ((e->content->type != TYPE_TEXT) ||
198  (mutt_str_strcasecmp(e->content->subtype, "plain") != 0))
199  {
201  _("Inline PGP can't be used with attachments. "
202  "Revert to PGP/MIME?")) != MUTT_YES)
203  {
204  mutt_error(
205  _("Mail not sent: inline PGP can't be used with attachments"));
206  return -1;
207  }
208  }
209  else if (mutt_str_strcasecmp("flowed", mutt_param_get(&e->content->parameter, "format")) == 0)
210  {
212  _("Inline PGP can't be used with format=flowed. "
213  "Revert to PGP/MIME?"))) != MUTT_YES)
214  {
215  mutt_error(
216  _("Mail not sent: inline PGP can't be used with format=flowed"));
217  return -1;
218  }
219  }
220  else
221  {
222  /* they really want to send it inline... go for it */
223  if (!isendwin())
224  {
225  mutt_endwin();
226  puts(_("Invoking PGP..."));
227  }
228  pbody = crypt_pgp_traditional_encryptsign(e->content, security, keylist);
229  if (pbody)
230  {
231  e->content = pbody;
232  return 0;
233  }
234 
235  /* otherwise inline won't work...ask for revert */
236  if (query_quadoption(
238  _("Message can't be sent inline. Revert to using PGP/MIME?")) != MUTT_YES)
239  {
240  mutt_error(_("Mail not sent"));
241  return -1;
242  }
243  }
244 
245  /* go ahead with PGP/MIME */
246  }
247 
248  if (!isendwin())
249  mutt_endwin();
250 
252  tmp_smime_pbody = e->content;
253  if (WithCrypto & APPLICATION_PGP)
254  tmp_pgp_pbody = e->content;
255 
256  if (C_CryptUsePka && sign)
257  {
258  /* Set sender (necessary for e.g. PKA). */
259  const char *mailbox = NULL;
260  struct Address *from = TAILQ_FIRST(&e->env->from);
261  bool free_from = false;
262 
263  if (!from)
264  {
265  free_from = true;
266  from = mutt_default_from();
267  }
268 
269  mailbox = from->mailbox;
270  if (!mailbox && C_EnvelopeFromAddress)
271  mailbox = C_EnvelopeFromAddress->mailbox;
272 
273  if (((WithCrypto & APPLICATION_SMIME) != 0) && (security & APPLICATION_SMIME))
274  crypt_smime_set_sender(mailbox);
275  else if (((WithCrypto & APPLICATION_PGP) != 0) && (security & APPLICATION_PGP))
276  crypt_pgp_set_sender(mailbox);
277 
278  if (free_from)
279  mutt_addr_free(&from);
280  }
281 
283  {
284  struct Envelope *protected_headers = mutt_env_new();
285  mutt_str_replace(&protected_headers->subject, e->env->subject);
286  /* Note: if other headers get added, such as to, cc, then a call to
287  * mutt_env_to_intl() will need to be added here too. */
288  mutt_prepare_envelope(protected_headers, 0);
289 
291  e->content->mime_headers = protected_headers;
292  }
293 
294  /* A note about e->content->mime_headers. If postpone or send
295  * fails, the mime_headers is cleared out before returning to the
296  * compose menu. So despite the "robustness" code above and in the
297  * gen_gossip_list function below, mime_headers will not be set when
298  * entering mutt_protect().
299  *
300  * This is important to note because the user could toggle
301  * $crypt_protected_headers_write or $autocrypt off back in the
302  * compose menu. We don't want mutt_write_rfc822_header() to write
303  * stale data from one option if the other is set.
304  */
305 #ifdef USE_AUTOCRYPT
306  if (C_Autocrypt && !postpone && (security & SEC_AUTOCRYPT))
307  {
309  }
310 #endif
311 
312  if (sign)
313  {
314  if (((WithCrypto & APPLICATION_SMIME) != 0) && (security & APPLICATION_SMIME))
315  {
316  tmp_pbody = crypt_smime_sign_message(e->content, &e->env->from);
317  if (!tmp_pbody)
318  goto bail;
319  pbody = tmp_pbody;
320  tmp_smime_pbody = tmp_pbody;
321  }
322 
323  if (((WithCrypto & APPLICATION_PGP) != 0) && (security & APPLICATION_PGP) &&
324  (!(security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) || C_PgpRetainableSigs))
325  {
326  tmp_pbody = crypt_pgp_sign_message(e->content, &e->env->from);
327  if (!tmp_pbody)
328  goto bail;
329 
330  has_retainable_sig = true;
331  sign = SEC_NO_FLAGS;
332  pbody = tmp_pbody;
333  tmp_pgp_pbody = tmp_pbody;
334  }
335 
336  if ((WithCrypto != 0) && (security & APPLICATION_SMIME) && (security & APPLICATION_PGP))
337  {
338  /* here comes the draft ;-) */
339  }
340  }
341 
342  if (security & (SEC_ENCRYPT | SEC_AUTOCRYPT))
343  {
344  if (((WithCrypto & APPLICATION_SMIME) != 0) && (security & APPLICATION_SMIME))
345  {
346  tmp_pbody = crypt_smime_build_smime_entity(tmp_smime_pbody, keylist);
347  if (!tmp_pbody)
348  {
349  /* signed ? free it! */
350  goto bail;
351  }
352  /* free tmp_body if messages was signed AND encrypted ... */
353  if ((tmp_smime_pbody != e->content) && (tmp_smime_pbody != tmp_pbody))
354  {
355  /* detach and don't delete e->content,
356  * which tmp_smime_pbody->parts after signing. */
357  tmp_smime_pbody->parts = tmp_smime_pbody->parts->next;
358  e->content->next = NULL;
359  mutt_body_free(&tmp_smime_pbody);
360  }
361  pbody = tmp_pbody;
362  }
363 
364  if (((WithCrypto & APPLICATION_PGP) != 0) && (security & APPLICATION_PGP))
365  {
366  pbody = crypt_pgp_encrypt_message(e, tmp_pgp_pbody, keylist, sign, &e->env->from);
367  if (!pbody)
368  {
369  /* did we perform a retainable signature? */
370  if (has_retainable_sig)
371  {
372  /* remove the outer multipart layer */
373  tmp_pgp_pbody = mutt_remove_multipart(tmp_pgp_pbody);
374  /* get rid of the signature */
375  mutt_body_free(&tmp_pgp_pbody->next);
376  }
377 
378  goto bail;
379  }
380 
381  /* destroy temporary signature envelope when doing retainable
382  * signatures.
383 
384  */
385  if (has_retainable_sig)
386  {
387  tmp_pgp_pbody = mutt_remove_multipart(tmp_pgp_pbody);
388  mutt_body_free(&tmp_pgp_pbody->next);
389  }
390  }
391  }
392 
393  if (pbody)
394  {
395  e->content = pbody;
396  return 0;
397  }
398 
399 bail:
401  return -1;
402 }
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
WHERE bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: globals.h:198
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:63
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: sendlib.c:1772
#define PGP_INLINE
Definition: ncrypt.h:144
#define TAILQ_FIRST(head)
Definition: queue.h:716
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
struct Body * content
List of MIME parts.
Definition: email.h:90
WHERE bool C_CryptUsePka
Config: Use GPGME to use PKA (lookup PGP keys using DNS)
Definition: globals.h:264
WHERE bool C_CryptProtectedHeadersWrite
Config: Generate protected header (Memory Hole) for signed and encrypted emails.
Definition: globals.h:272
void crypt_pgp_set_sender(const char *sender)
Wrapper for CryptModuleSpecs::set_sender()
Definition: cryptglue.c:398
#define _(a)
Definition: message.h:28
struct Body * next
next attachment in the list
Definition: body.h:53
An email address.
Definition: address.h:34
char * mailbox
Mailbox and host address.
Definition: address.h:37
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
void mutt_addr_free(struct Address **ptr)
Free a single Address.
Definition: address.c:440
The body of an email.
Definition: body.h:34
void mutt_prepare_envelope(struct Envelope *env, bool final)
Prepare an email header.
Definition: sendlib.c:3001
void crypt_smime_set_sender(const char *sender)
Wrapper for CryptModuleSpecs::set_sender()
Definition: cryptglue.c:535
struct Body * crypt_smime_sign_message(struct Body *a, const struct AddressList *from)
Wrapper for CryptModuleSpecs::sign_message()
Definition: cryptglue.c:482
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:145
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
bool C_PgpRetainableSigs
Config: Create nested multipart/signed or encrypted messages.
Definition: crypt.c:69
struct Envelope * env
Envelope information.
Definition: email.h:89
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:42
char * subtype
content-type subtype
Definition: body.h:37
struct Body * crypt_pgp_encrypt_message(struct Email *e, struct Body *a, char *keylist, int sign, const struct AddressList *from)
Wrapper for CryptModuleSpecs::pgp_encrypt_message()
Definition: cryptglue.c:332
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
struct Address * mutt_default_from(void)
Get a default &#39;from&#39; Address.
Definition: send.c:1334
void mutt_endwin(void)
Shutdown curses/slang.
Definition: curs_lib.c:545
Type: &#39;text/*&#39;.
Definition: mime.h:38
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
Definition: envelope.c:96
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
struct Body * crypt_pgp_traditional_encryptsign(struct Body *a, int flags, char *keylist)
Wrapper for CryptModuleSpecs::pgp_traditional_encryptsign()
Definition: cryptglue.c:288
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
void mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:453
unsigned int type
content-type primary type
Definition: body.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
unsigned char C_PgpMimeAuto
Config: Prompt the user to use MIME if inline PGP fails.
Definition: crypt.c:68
struct Body * crypt_smime_build_smime_entity(struct Body *a, char *certlist)
Wrapper for CryptModuleSpecs::smime_build_smime_entity()
Definition: cryptglue.c:493
char * subject
Email&#39;s subject.
Definition: envelope.h:66
int mutt_autocrypt_generate_gossip_list(struct Email *e)
Create the gossip list headers.
Definition: autocrypt.c:797
#define mutt_error(...)
Definition: logging.h:84
WHERE struct Address * C_EnvelopeFromAddress
Config: Manually set the sender for outgoing messages.
Definition: globals.h:93
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
struct Body * crypt_pgp_sign_message(struct Body *a, const struct AddressList *from)
Wrapper for CryptModuleSpecs::sign_message()
Definition: cryptglue.c:321
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
#define WithCrypto
Definition: ncrypt.h:160
The header of an Email.
Definition: envelope.h:54
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_protected_headers_handler()

int mutt_protected_headers_handler ( struct Body m,
struct State s 
)

Process a protected header - Implements handler_t.

Definition at line 1094 of file crypt.c.

1095 {
1096  if (C_CryptProtectedHeadersRead && a->mime_headers)
1097  {
1098  if (a->mime_headers->subject)
1099  {
1100  const bool display = (s->flags & MUTT_DISPLAY);
1101 
1102  if (display && C_Weed && mutt_matches_ignore("subject"))
1103  return 0;
1104 
1106  int wraplen = display ? mutt_window_wrap_cols(s->wraplen, C_Wrap) : 0;
1107 
1108  mutt_write_one_header(s->fp_out, "Subject", a->mime_headers->subject,
1109  s->prefix, wraplen, display ? CH_DISPLAY : CH_NO_FLAGS);
1110  state_puts(s, "\n");
1111  }
1112  }
1113 
1114  return 0;
1115 }
bool mutt_matches_ignore(const char *s)
Does the string match the ignore list.
Definition: parse.c:309
#define MUTT_DISPLAY
Output is displayed to the user.
Definition: state.h:32
#define state_puts(STATE, STR)
Definition: state.h:55
char * prefix
String to add to the beginning of each output line.
Definition: state.h:48
WHERE short C_Wrap
Config: Width to wrap text in the pager.
Definition: globals.h:152
FILE * fp_out
File to write to.
Definition: state.h:47
StateFlags flags
Flags, e.g. MUTT_DISPLAY.
Definition: state.h:49
int wraplen
Width to wrap lines to (when flags & MUTT_DISPLAY)
Definition: state.h:50
#define CH_NO_FLAGS
No flags are set.
Definition: copy.h:50
#define CH_DISPLAY
Display result to user.
Definition: copy.h:69
int mutt_window_wrap_cols(int width, short wrap)
Calculate the wrap column for a given screen width.
Definition: mutt_window.c:383
void state_mark_protected_header(struct State *s)
Write a unique marker around protected headers.
Definition: state.c:56
WHERE bool C_CryptProtectedHeadersRead
Config: Display protected headers (Memory Hole) in the pager.
Definition: globals.h:270
int mutt_write_one_header(FILE *fp, const char *tag, const char *value, const char *pfx, int wraplen, CopyHeaderFlags chflags)
Write one header line to a file.
Definition: sendlib.c:2154
bool C_Weed
Config: Filter headers when displaying/forwarding/printing/replying.
Definition: email_globals.c:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_should_hide_protected_subject()

bool mutt_should_hide_protected_subject ( struct Email e)

Should NeoMutt hide the protected subject?

Parameters
eEmail to test
Return values
boolTrue if the subject should be protected

Definition at line 1080 of file crypt.c.

1081 {
1084  {
1085  return true;
1086  }
1087 
1088  return false;
1089 }
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
WHERE char * C_CryptProtectedHeadersSubject
Config: Use this as the subject for encrypted emails.
Definition: globals.h:105
WHERE bool C_CryptProtectedHeadersWrite
Config: Generate protected header (Memory Hole) for signed and encrypted emails.
Definition: globals.h:272
#define SEC_INLINE
Email has an inline signature.
Definition: ncrypt.h:129
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
+ Here is the caller graph for this function:

◆ mutt_signed_handler()

int mutt_signed_handler ( struct Body a,
struct State s 
)

Verify a "multipart/signed" body - Implements handler_t.

Definition at line 1120 of file crypt.c.

1121 {
1122  if (!WithCrypto)
1123  return -1;
1124 
1125  bool inconsistent = false;
1126  struct Body *b = a;
1127  struct Body **signatures = NULL;
1128  int sigcnt = 0;
1129  int rc = 0;
1130  struct Buffer *tempfile = NULL;
1131 
1132  a = a->parts;
1133  SecurityFlags signed_type = mutt_is_multipart_signed(b);
1134  if (signed_type == SEC_NO_FLAGS)
1135  {
1136  /* A null protocol value is already checked for in mutt_body_handler() */
1137  state_printf(s,
1138  _("[-- Error: "
1139  "Unknown multipart/signed protocol %s --]\n\n"),
1140  mutt_param_get(&b->parameter, "protocol"));
1141  return mutt_body_handler(a, s);
1142  }
1143 
1144  if (!(a && a->next))
1145  inconsistent = true;
1146  else
1147  {
1148  switch (signed_type)
1149  {
1150  case SEC_SIGN:
1151  if ((a->next->type != TYPE_MULTIPART) ||
1152  (mutt_str_strcasecmp(a->next->subtype, "mixed") != 0))
1153  {
1154  inconsistent = true;
1155  }
1156  break;
1157  case PGP_SIGN:
1158  if ((a->next->type != TYPE_APPLICATION) ||
1159  (mutt_str_strcasecmp(a->next->subtype, "pgp-signature") != 0))
1160  {
1161  inconsistent = true;
1162  }
1163  break;
1164  case SMIME_SIGN:
1165  if ((a->next->type != TYPE_APPLICATION) ||
1166  ((mutt_str_strcasecmp(a->next->subtype, "x-pkcs7-signature") != 0) &&
1167  (mutt_str_strcasecmp(a->next->subtype, "pkcs7-signature") != 0)))
1168  {
1169  inconsistent = true;
1170  }
1171  break;
1172  default:
1173  inconsistent = true;
1174  }
1175  }
1176  if (inconsistent)
1177  {
1178  state_attach_puts(s, _("[-- Error: Missing or bad-format multipart/signed "
1179  "signature --]\n\n"));
1180  return mutt_body_handler(a, s);
1181  }
1182 
1183  if (s->flags & MUTT_DISPLAY)
1184  {
1185  crypt_fetch_signatures(&signatures, a->next, &sigcnt);
1186 
1187  if (sigcnt != 0)
1188  {
1189  tempfile = mutt_buffer_pool_get();
1190  mutt_buffer_mktemp(tempfile);
1191  bool goodsig = true;
1192  if (crypt_write_signed(a, s, mutt_b2s(tempfile)) == 0)
1193  {
1194  for (int i = 0; i < sigcnt; i++)
1195  {
1196  if (((WithCrypto & APPLICATION_PGP) != 0) &&
1197  (signatures[i]->type == TYPE_APPLICATION) &&
1198  (mutt_str_strcasecmp(signatures[i]->subtype, "pgp-signature") == 0))
1199  {
1200  if (crypt_pgp_verify_one(signatures[i], s, mutt_b2s(tempfile)) != 0)
1201  goodsig = false;
1202 
1203  continue;
1204  }
1205 
1206  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
1207  (signatures[i]->type == TYPE_APPLICATION) &&
1208  ((mutt_str_strcasecmp(signatures[i]->subtype,
1209  "x-pkcs7-signature") == 0) ||
1210  (mutt_str_strcasecmp(signatures[i]->subtype,
1211  "pkcs7-signature") == 0)))
1212  {
1213  if (crypt_smime_verify_one(signatures[i], s, mutt_b2s(tempfile)) != 0)
1214  goodsig = false;
1215 
1216  continue;
1217  }
1218 
1219  state_printf(s,
1220  _("[-- Warning: "
1221  "We can't verify %s/%s signatures. --]\n\n"),
1222  TYPE(signatures[i]), signatures[i]->subtype);
1223  }
1224  }
1225 
1226  mutt_file_unlink(mutt_b2s(tempfile));
1227  mutt_buffer_pool_release(&tempfile);
1228 
1229  b->goodsig = goodsig;
1230  b->badsig = !goodsig;
1231 
1232  /* Now display the signed body */
1233  state_attach_puts(s, _("[-- The following data is signed --]\n\n"));
1234 
1236 
1237  FREE(&signatures);
1238  }
1239  else
1241  _("[-- Warning: Can't find any signatures. --]\n\n"));
1242  }
1243 
1244  rc = mutt_body_handler(a, s);
1245 
1246  if ((s->flags & MUTT_DISPLAY) && (sigcnt != 0))
1247  state_attach_puts(s, _("\n[-- End of signed data --]\n"));
1248 
1249  return rc;
1250 }
int mutt_protected_headers_handler(struct Body *a, struct State *s)
Process a protected header - Implements handler_t.
Definition: crypt.c:1094
int state_printf(struct State *s, const char *fmt,...)
Write a formatted string to the State.
Definition: state.c:153
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:78
#define MUTT_DISPLAY
Output is displayed to the user.
Definition: state.h:32
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:194
String manipulation buffer.
Definition: buffer.h:33
#define _(a)
Definition: message.h:28
struct Body * next
next attachment in the list
Definition: body.h:53
#define SMIME_SIGN
Definition: ncrypt.h:147
int crypt_write_signed(struct Body *a, struct State *s, const char *tempfile)
Write the message body/part.
Definition: crypt.c:764
The body of an email.
Definition: body.h:34
StateFlags flags
Flags, e.g. MUTT_DISPLAY.
Definition: state.h:49
bool badsig
Bad cryptographic signature (needed to check encrypted s/mime-signatures)
Definition: body.h:77
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:410
#define PGP_SIGN
Definition: ncrypt.h:141
char * subtype
content-type subtype
Definition: body.h:37
#define mutt_b2s(buf)
Definition: buffer.h:41
bool goodsig
Good cryptographic signature.
Definition: body.h:75
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
static void crypt_fetch_signatures(struct Body ***signatures, struct Body *a, int *n)
Create an array of an emails parts.
Definition: crypt.c:1056
unsigned int type
content-type primary type
Definition: body.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
void state_attach_puts(struct State *s, const char *t)
Write a string to the state.
Definition: state.c:70
#define TYPE(body)
Definition: mime.h:83
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
#define FREE(x)
Definition: memory.h:40
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
int crypt_smime_verify_one(struct Body *sigbdy, struct State *s, const char *tempf)
Wrapper for CryptModuleSpecs::verify_one()
Definition: cryptglue.c:513
int mutt_body_handler(struct Body *b, struct State *s)
Handler for the Body of an email.
Definition: handler.c:1551
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: ncrypt.h:120
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
#define WithCrypto
Definition: ncrypt.h:160
Type: &#39;application/*&#39;.
Definition: mime.h:33
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
int crypt_pgp_verify_one(struct Body *sigbdy, struct State *s, const char *tempf)
Wrapper for CryptModuleSpecs::verify_one()
Definition: cryptglue.c:367
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_has_module_backend()

bool crypt_has_module_backend ( SecurityFlags  type)

Is there a crypto backend for a given type?

Parameters
typeCrypto type, see SecurityFlags
Return values
trueBackend is present
falseBackend is not present

Definition at line 163 of file cryptglue.c.

164 {
165  if (((WithCrypto & APPLICATION_PGP) != 0) && (type & APPLICATION_PGP) &&
166  crypto_module_lookup(APPLICATION_PGP))
167  {
168  return true;
169  }
170 
171  if (((WithCrypto & APPLICATION_SMIME) != 0) && (type & APPLICATION_SMIME) &&
172  crypto_module_lookup(APPLICATION_SMIME))
173  {
174  return true;
175  }
176 
177  return false;
178 }
struct CryptModuleSpecs * crypto_module_lookup(int identifier)
Lookup a crypto module by name.
Definition: crypt_mod.c:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_init()

void crypt_init ( void  )

Initialise the crypto backends.

This calls CryptModuleSpecs::init()

Definition at line 96 of file cryptglue.c.

97 {
98 #ifdef CRYPT_BACKEND_CLASSIC_PGP
99  if (
100 #ifdef CRYPT_BACKEND_GPGME
101  (!C_CryptUseGpgme)
102 #else
103  1
104 #endif
105  )
107 #endif
108 
109 #ifdef CRYPT_BACKEND_CLASSIC_SMIME
110  if (
111 #ifdef CRYPT_BACKEND_GPGME
112  (!C_CryptUseGpgme)
113 #else
114  1
115 #endif
116  )
118 #endif
119 
120  if (C_CryptUseGpgme)
121  {
122 #ifdef CRYPT_BACKEND_GPGME
125 #else
126  mutt_message(_("\"crypt_use_gpgme\" set"
127  " but not built with GPGME support"));
128  if (mutt_any_key_to_continue(NULL) == -1)
129  mutt_exit(1);
130 #endif
131  }
132 
133 #if defined(CRYPT_BACKEND_CLASSIC_PGP) || \
134  defined(CRYPT_BACKEND_CLASSIC_SMIME) || defined(CRYPT_BACKEND_GPGME)
135  if (CRYPT_MOD_CALL_CHECK(PGP, init))
136  CRYPT_MOD_CALL(PGP, init)();
137 
138  if (CRYPT_MOD_CALL_CHECK(SMIME, init))
139  CRYPT_MOD_CALL(SMIME, init)();
140 #endif
141 }
struct CryptModuleSpecs CryptModPgpGpgme
GPGME PGP - Implements CryptModuleSpecs.
#define mutt_message(...)
Definition: logging.h:83
bool C_CryptUseGpgme
Config: Use GPGME crypto backend.
Definition: cryptglue.c:61
#define _(a)
Definition: message.h:28
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
void crypto_module_register(struct CryptModuleSpecs *specs)
Register a new crypto module.
Definition: crypt_mod.c:51
struct CryptModuleSpecs CryptModSmimeClassic
CLI SMIME - Implements CryptModuleSpecs.
struct CryptModuleSpecs CryptModPgpClassic
CLI PGP - Implements CryptModuleSpecs.
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
void mutt_exit(int code)
Leave NeoMutt NOW.
Definition: main.c:207
int mutt_any_key_to_continue(const char *s)
Prompt the user to &#39;press any key&#39; and wait.
Definition: curs_lib.c:578
struct CryptModuleSpecs CryptModSmimeGpgme
GPGME SMIME - Implements CryptModuleSpecs.
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_invoke_message()

void crypt_invoke_message ( SecurityFlags  type)

Display an informative message.

Parameters
typeCrypto type, see SecurityFlags

Show a message that a backend will be invoked.

Definition at line 149 of file cryptglue.c.

150 {
151  if (((WithCrypto & APPLICATION_PGP) != 0) && (type & APPLICATION_PGP))
152  mutt_message(_("Invoking PGP..."));
153  else if (((WithCrypto & APPLICATION_SMIME) != 0) && (type & APPLICATION_SMIME))
154  mutt_message(_("Invoking S/MIME..."));
155 }
#define mutt_message(...)
Definition: logging.h:83
#define _(a)
Definition: message.h:28
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the caller graph for this function:

◆ crypt_pgp_application_handler()

int crypt_pgp_application_handler ( struct Body m,
struct State s 
)

Wrapper for CryptModuleSpecs::application_handler()

Implements handler_t

Definition at line 230 of file cryptglue.c.

231 {
232  if (CRYPT_MOD_CALL_CHECK(PGP, application_handler))
233  return CRYPT_MOD_CALL(PGP, application_handler)(m, s);
234 
235  return -1;
236 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_pgp_check_traditional()

int crypt_pgp_check_traditional ( FILE *  fp,
struct Body b,
bool  just_one 
)

Wrapper for CryptModuleSpecs::pgp_check_traditional()

Definition at line 277 of file cryptglue.c.

278 {
279  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_check_traditional))
280  return CRYPT_MOD_CALL(PGP, pgp_check_traditional)(fp, b, just_one);
281 
282  return 0;
283 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_pgp_decrypt_mime()

int crypt_pgp_decrypt_mime ( FILE *  fp_in,
FILE **  fp_out,
struct Body b,
struct Body **  cur 
)

Wrapper for CryptModuleSpecs::decrypt_mime()

Definition at line 203 of file cryptglue.c.

204 {
205 #ifdef USE_AUTOCRYPT
206  if (C_Autocrypt)
207  {
208  OptAutocryptGpgme = true;
209  int result = pgp_gpgme_decrypt_mime(fp_in, fp_out, b, cur);
210  OptAutocryptGpgme = false;
211  if (result == 0)
212  {
213  b->is_autocrypt = true;
214  return result;
215  }
216  }
217 #endif
218 
219  if (CRYPT_MOD_CALL_CHECK(PGP, decrypt_mime))
220  return CRYPT_MOD_CALL(PGP, decrypt_mime)(fp_in, fp_out, b, cur);
221 
222  return -1;
223 }
WHERE bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: globals.h:198
bool is_autocrypt
Flag autocrypt-decrypted messages for replying.
Definition: body.h:79
WHERE bool OptAutocryptGpgme
(pseudo) use Autocrypt context inside ncrypt/crypt_gpgme.c
Definition: options.h:32
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
int pgp_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
Implements CryptModuleSpecs::decrypt_mime()
Definition: crypt_gpgme.c:2379
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_pgp_encrypted_handler()

int crypt_pgp_encrypted_handler ( struct Body a,
struct State s 
)

Wrapper for CryptModuleSpecs::encrypted_handler()

Implements handler_t

Definition at line 243 of file cryptglue.c.

244 {
245 #ifdef USE_AUTOCRYPT
246  if (C_Autocrypt)
247  {
248  OptAutocryptGpgme = true;
249  int result = pgp_gpgme_encrypted_handler(a, s);
250  OptAutocryptGpgme = false;
251  if (result == 0)
252  {
253  a->is_autocrypt = true;
254  return result;
255  }
256  }
257 #endif
258 
259  if (CRYPT_MOD_CALL_CHECK(PGP, encrypted_handler))
260  return CRYPT_MOD_CALL(PGP, encrypted_handler)(a, s);
261 
262  return -1;
263 }
WHERE bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: globals.h:198
bool is_autocrypt
Flag autocrypt-decrypted messages for replying.
Definition: body.h:79
WHERE bool OptAutocryptGpgme
(pseudo) use Autocrypt context inside ncrypt/crypt_gpgme.c
Definition: options.h:32
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
int pgp_gpgme_encrypted_handler(struct Body *a, struct State *s)
Implements CryptModuleSpecs::encrypted_handler()
Definition: crypt_gpgme.c:3227
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_pgp_extract_key_from_attachment()

void crypt_pgp_extract_key_from_attachment ( FILE *  fp,
struct Body top 
)

Wrapper for CryptModuleSpecs::pgp_extract_key_from_attachment()

Definition at line 389 of file cryptglue.c.

390 {
391  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_extract_key_from_attachment))
392  CRYPT_MOD_CALL(PGP, pgp_extract_key_from_attachment)(fp, top);
393 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_pgp_invoke_getkeys()

void crypt_pgp_invoke_getkeys ( struct Address addr)

Wrapper for CryptModuleSpecs::pgp_invoke_getkeys()

Definition at line 268 of file cryptglue.c.

269 {
270  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_invoke_getkeys))
271  CRYPT_MOD_CALL(PGP, pgp_invoke_getkeys)(addr);
272 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_pgp_make_key_attachment()

struct Body* crypt_pgp_make_key_attachment ( void  )

Wrapper for CryptModuleSpecs::pgp_make_key_attachment()

Definition at line 299 of file cryptglue.c.

300 {
301  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_make_key_attachment))
302  return CRYPT_MOD_CALL(PGP, pgp_make_key_attachment)();
303 
304  return NULL;
305 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_pgp_send_menu()

int crypt_pgp_send_menu ( struct Email e)

Wrapper for CryptModuleSpecs::send_menu()

Definition at line 378 of file cryptglue.c.

379 {
380  if (CRYPT_MOD_CALL_CHECK(PGP, send_menu))
381  return CRYPT_MOD_CALL(PGP, send_menu)(e);
382 
383  return 0;
384 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_smime_application_handler()

int crypt_smime_application_handler ( struct Body m,
struct State s 
)

Wrapper for CryptModuleSpecs::application_handler()

Implements handler_t

Definition at line 440 of file cryptglue.c.

441 {
442  if (CRYPT_MOD_CALL_CHECK(SMIME, application_handler))
443  return CRYPT_MOD_CALL(SMIME, application_handler)(m, s);
444 
445  return -1;
446 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_smime_decrypt_mime()

int crypt_smime_decrypt_mime ( FILE *  fp_in,
FILE **  fp_out,
struct Body b,
struct Body **  cur 
)

Wrapper for CryptModuleSpecs::decrypt_mime()

Definition at line 427 of file cryptglue.c.

428 {
429  if (CRYPT_MOD_CALL_CHECK(SMIME, decrypt_mime))
430  return CRYPT_MOD_CALL(SMIME, decrypt_mime)(fp_in, fp_out, b, cur);
431 
432  return -1;
433 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_smime_getkeys()

void crypt_smime_getkeys ( struct Envelope env)

Wrapper for CryptModuleSpecs::smime_getkeys()

Definition at line 451 of file cryptglue.c.

452 {
453  if (CRYPT_MOD_CALL_CHECK(SMIME, smime_getkeys))
454  CRYPT_MOD_CALL(SMIME, smime_getkeys)(env);
455 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_smime_send_menu()

int crypt_smime_send_menu ( struct Email e)

Wrapper for CryptModuleSpecs::send_menu()

Definition at line 524 of file cryptglue.c.

525 {
526  if (CRYPT_MOD_CALL_CHECK(SMIME, send_menu))
527  return CRYPT_MOD_CALL(SMIME, send_menu)(e);
528 
529  return 0;
530 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypt_smime_verify_sender()

int crypt_smime_verify_sender ( struct Mailbox m,
struct Email e 
)

Wrapper for CryptModuleSpecs::smime_verify_sender()

Definition at line 460 of file cryptglue.c.

461 {
462  if (CRYPT_MOD_CALL_CHECK(SMIME, smime_verify_sender))
463  return CRYPT_MOD_CALL(SMIME, smime_verify_sender)(m, e);
464 
465  return 1;
466 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:88
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:82
+ Here is the caller graph for this function:

◆ crypto_module_free()

void crypto_module_free ( void  )

Clean up the crypto modules.

Definition at line 81 of file crypt_mod.c.

82 {
83  struct CryptModule *np = NULL, *tmp = NULL;
84  STAILQ_FOREACH_SAFE(np, &CryptModules, entries, tmp)
85  {
86  STAILQ_REMOVE(&CryptModules, np, CryptModule, entries);
87  FREE(&np);
88  }
89 }
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:399
A crypto plugin module.
Definition: crypt_mod.c:38
static struct CryptModuleList CryptModules
Definition: crypt_mod.c:45
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:359
#define FREE(x)
Definition: memory.h:40
+ Here is the caller graph for this function:

Variable Documentation

◆ C_CryptTimestamp

bool C_CryptTimestamp

Config: Add a timestamp to PGP or SMIME output to prevent spoofing.

Definition at line 63 of file crypt.c.

◆ C_PgpEncryptSelf

unsigned char C_PgpEncryptSelf

Deprecated, see C_PgpSelfEncrypt.

Definition at line 67 of file crypt.c.

◆ C_PgpMimeAuto

unsigned char C_PgpMimeAuto

Config: Prompt the user to use MIME if inline PGP fails.

Definition at line 68 of file crypt.c.

◆ C_PgpRetainableSigs

bool C_PgpRetainableSigs

Config: Create nested multipart/signed or encrypted messages.

Definition at line 69 of file crypt.c.

◆ C_PgpSelfEncrypt

bool C_PgpSelfEncrypt

Config: Encrypted messages will also be encrypted to C_PgpDefaultKey too.

Definition at line 70 of file crypt.c.

◆ C_PgpStrictEnc

bool C_PgpStrictEnc

Config: Encode PGP signed messages with quoted-printable (don't unset)

Definition at line 71 of file crypt.c.

◆ C_SmimeEncryptSelf

unsigned char C_SmimeEncryptSelf

Deprecated, see C_SmimeSelfEncrypt.

Definition at line 72 of file crypt.c.

◆ C_SmimeSelfEncrypt

bool C_SmimeSelfEncrypt

Config: Encrypted messages will also be encrypt to C_SmimeDefaultKey too.

Definition at line 73 of file crypt.c.

◆ C_CryptUseGpgme

bool C_CryptUseGpgme

Config: Use GPGME crypto backend.

Definition at line 61 of file cryptglue.c.

◆ C_PgpCheckExit

bool C_PgpCheckExit

Config: Check the exit code of PGP subprocess.

Definition at line 70 of file pgp.c.

◆ C_PgpCheckGpgDecryptStatusFd

bool C_PgpCheckGpgDecryptStatusFd

Config: File descriptor used for status info.

Definition at line 71 of file pgp.c.

◆ C_PgpDecryptionOkay

struct Regex* C_PgpDecryptionOkay

Config: Text indicating a successful decryption.

Definition at line 72 of file pgp.c.

◆ C_PgpGoodSign

struct Regex* C_PgpGoodSign

Config: Text indicating a good signature.

Definition at line 73 of file pgp.c.

◆ C_PgpTimeout

long C_PgpTimeout

Config: Time in seconds to cache a passphrase.

Definition at line 74 of file pgp.c.

◆ C_PgpUseGpgAgent

bool C_PgpUseGpgAgent

Config: Use a PGP agent for caching passwords.

Definition at line 75 of file pgp.c.

◆ C_PgpClearsignCommand

char* C_PgpClearsignCommand

Config: (pgp) External command to inline-sign a message.

Definition at line 54 of file pgpinvoke.c.

◆ C_PgpDecodeCommand

char* C_PgpDecodeCommand

Config: (pgp) External command to decode a PGP attachment.

Definition at line 55 of file pgpinvoke.c.

◆ C_PgpDecryptCommand

char* C_PgpDecryptCommand

Config: (pgp) External command to decrypt a PGP message.

Definition at line 56 of file pgpinvoke.c.

◆ C_PgpEncryptOnlyCommand

char* C_PgpEncryptOnlyCommand

Config: (pgp) External command to encrypt, but not sign a message.

Definition at line 57 of file pgpinvoke.c.

◆ C_PgpEncryptSignCommand

char* C_PgpEncryptSignCommand

Config: (pgp) External command to encrypt and sign a message.

Definition at line 58 of file pgpinvoke.c.

◆ C_PgpExportCommand

char* C_PgpExportCommand

Config: (pgp) External command to export a public key from the user's keyring.

Definition at line 59 of file pgpinvoke.c.

◆ C_PgpGetkeysCommand

char* C_PgpGetkeysCommand

Config: (pgp) External command to download a key for an email address.

Definition at line 60 of file pgpinvoke.c.

◆ C_PgpImportCommand

char* C_PgpImportCommand

Config: (pgp) External command to import a key into the user's keyring.

Definition at line 61 of file pgpinvoke.c.

◆ C_PgpListPubringCommand

char* C_PgpListPubringCommand

Config: (pgp) External command to list the public keys in a user's keyring.

Definition at line 62 of file pgpinvoke.c.

◆ C_PgpListSecringCommand

char* C_PgpListSecringCommand

Config: (pgp) External command to list the private keys in a user's keyring.

Definition at line 63 of file pgpinvoke.c.

◆ C_PgpSignCommand

char* C_PgpSignCommand

Config: (pgp) External command to create a detached PGP signature.

Definition at line 64 of file pgpinvoke.c.

◆ C_PgpVerifyCommand

char* C_PgpVerifyCommand

Config: (pgp) External command to verify PGP signatures.

Definition at line 65 of file pgpinvoke.c.

◆ C_PgpVerifyKeyCommand

char* C_PgpVerifyKeyCommand

Config: (pgp) External command to verify key information.

Definition at line 66 of file pgpinvoke.c.

◆ C_SmimeAskCertLabel

bool C_SmimeAskCertLabel

Config: Prompt the user for a label for SMIME certificates.

Definition at line 68 of file smime.c.

◆ C_SmimeCaLocation

char* C_SmimeCaLocation

Config: File containing trusted certificates.

Definition at line 69 of file smime.c.

◆ C_SmimeCertificates

char* C_SmimeCertificates

Config: File containing user's public certificates.

Definition at line 70 of file smime.c.

◆ C_SmimeDecryptCommand

char* C_SmimeDecryptCommand

Config: (smime) External command to decrypt an SMIME message.

Definition at line 71 of file smime.c.

◆ C_SmimeDecryptUseDefaultKey

bool C_SmimeDecryptUseDefaultKey

Config: Use the default key for decryption.

Definition at line 72 of file smime.c.

◆ C_SmimeEncryptCommand

char* C_SmimeEncryptCommand

Config: (smime) External command to encrypt a message.

Definition at line 73 of file smime.c.

◆ C_SmimeGetCertCommand

char* C_SmimeGetCertCommand

Config: (smime) External command to extract a certificate from a message.

Definition at line 74 of file smime.c.

◆ C_SmimeGetCertEmailCommand

char* C_SmimeGetCertEmailCommand

Config: (smime) External command to get a certificate for an email.

Definition at line 75 of file smime.c.

◆ C_SmimeGetSignerCertCommand

char* C_SmimeGetSignerCertCommand

Config: (smime) External command to extract a certificate from an email.

Definition at line 76 of file smime.c.

◆ C_SmimeImportCertCommand

char* C_SmimeImportCertCommand

Config: (smime) External command to import a certificate.

Definition at line 77 of file smime.c.

◆ C_SmimeKeys

char* C_SmimeKeys

Config: File containing user's private certificates.

Definition at line 78 of file smime.c.

◆ C_SmimePk7outCommand

char* C_SmimePk7outCommand

Config: (smime) External command to extract a public certificate.

Definition at line 79 of file smime.c.

◆ C_SmimeSignCommand

char* C_SmimeSignCommand

Config: (smime) External command to sign a message.

Definition at line 80 of file smime.c.

◆ C_SmimeSignDigestAlg

char* C_SmimeSignDigestAlg

Config: Digest algorithm.

Definition at line 81 of file smime.c.

◆ C_SmimeTimeout

long C_SmimeTimeout

Config: Time in seconds to cache a passphrase.

Definition at line 82 of file smime.c.

◆ C_SmimeVerifyCommand

char* C_SmimeVerifyCommand

Config: (smime) External command to verify a signed message.

Definition at line 83 of file smime.c.

◆ C_SmimeVerifyOpaqueCommand

char* C_SmimeVerifyOpaqueCommand

Config: (smime) External command to verify a signature.

Definition at line 84 of file smime.c.