NeoMutt  2020-09-25
Teaching an old dog new tricks
DOXYGEN
lib.h File Reference

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

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
+ Include dependency graph for lib.h:

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)
 (Autocrypt) Message will be, or was Autocrypt encrypt+signed More...
 
#define SEC_AUTOCRYPT_OVERRIDE   (1 << 10)
 (Autocrypt) 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...
 
void crypt_cleanup (void)
 Clean up backend. 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...
 
void pgp_gpgme_init (void)
 Implements CryptModuleSpecs::init() More...
 
int mutt_gpgme_select_secret_key (struct Buffer *keyid)
 Select a private Autocrypt key for a new account. More...
 
const char * mutt_gpgme_print_version (void)
 Get version of GPGME. More...
 

Variables

bool C_CryptOpportunisticEncrypt
 Config: Enable encryption when the recipient's key is available. More...
 
bool C_CryptProtectedHeadersRead
 Config: Display protected headers (Memory Hole) in the pager. More...
 
bool C_CryptProtectedHeadersSave
 Config: Save the cleartext Subject with the headers. More...
 
unsigned char C_CryptVerifySig
 Config: Verify PGP or SMIME signatures. More...
 
bool C_PgpAutoDecode
 Config: Automatically decrypt PGP messages. More...
 
char * C_PgpSignAs
 Config: Use this alternative key for signing messages. More...
 
char * C_SmimeEncryptWith
 Config: Algorithm for encryption. More...
 
bool C_SmimeIsDefault
 Config: Use SMIME rather than PGP by default. More...
 
char * C_SmimeSignAs
 Config: Use this alternative key for signing messages. 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 lib.h.

Macro Definition Documentation

◆ SEC_NO_FLAGS

#define SEC_NO_FLAGS   0

No flags are set.

Definition at line 84 of file lib.h.

◆ SEC_ENCRYPT

#define SEC_ENCRYPT   (1 << 0)

Email is encrypted.

Definition at line 85 of file lib.h.

◆ SEC_SIGN

#define SEC_SIGN   (1 << 1)

Email is signed.

Definition at line 86 of file lib.h.

◆ SEC_GOODSIGN

#define SEC_GOODSIGN   (1 << 2)

Email has a valid signature.

Definition at line 87 of file lib.h.

◆ SEC_BADSIGN

#define SEC_BADSIGN   (1 << 3)

Email has a bad signature.

Definition at line 88 of file lib.h.

◆ SEC_PARTSIGN

#define SEC_PARTSIGN   (1 << 4)

Not all parts of the email is signed.

Definition at line 89 of file lib.h.

◆ SEC_SIGNOPAQUE

#define SEC_SIGNOPAQUE   (1 << 5)

Email has an opaque signature (encrypted)

Definition at line 90 of file lib.h.

◆ SEC_KEYBLOCK

#define SEC_KEYBLOCK   (1 << 6)

Email has a key attached.

Definition at line 91 of file lib.h.

◆ SEC_INLINE

#define SEC_INLINE   (1 << 7)

Email has an inline signature.

Definition at line 92 of file lib.h.

◆ SEC_OPPENCRYPT

#define SEC_OPPENCRYPT   (1 << 8)

Opportunistic encrypt mode.

Definition at line 93 of file lib.h.

◆ SEC_AUTOCRYPT

#define SEC_AUTOCRYPT   (1 << 9)

(Autocrypt) Message will be, or was Autocrypt encrypt+signed

Definition at line 94 of file lib.h.

◆ SEC_AUTOCRYPT_OVERRIDE

#define SEC_AUTOCRYPT_OVERRIDE   (1 << 10)

(Autocrypt) Indicates manual set/unset of encryption

Definition at line 95 of file lib.h.

◆ APPLICATION_PGP

#define APPLICATION_PGP   (1 << 11)

Use PGP to encrypt/sign.

Definition at line 97 of file lib.h.

◆ APPLICATION_SMIME

#define APPLICATION_SMIME   (1 << 12)

Use SMIME to encrypt/sign.

Definition at line 98 of file lib.h.

◆ PGP_TRADITIONAL_CHECKED

#define PGP_TRADITIONAL_CHECKED   (1 << 13)

Email has a traditional (inline) signature.

Definition at line 99 of file lib.h.

◆ SEC_ALL_FLAGS

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

Definition at line 101 of file lib.h.

◆ PGP_ENCRYPT

#define PGP_ENCRYPT   (APPLICATION_PGP | SEC_ENCRYPT)

Definition at line 103 of file lib.h.

◆ PGP_SIGN

#define PGP_SIGN   (APPLICATION_PGP | SEC_SIGN)

Definition at line 104 of file lib.h.

◆ PGP_GOODSIGN

#define PGP_GOODSIGN   (APPLICATION_PGP | SEC_GOODSIGN)

Definition at line 105 of file lib.h.

◆ PGP_KEY

#define PGP_KEY   (APPLICATION_PGP | SEC_KEYBLOCK)

Definition at line 106 of file lib.h.

◆ PGP_INLINE

#define PGP_INLINE   (APPLICATION_PGP | SEC_INLINE)

Definition at line 107 of file lib.h.

◆ SMIME_ENCRYPT

#define SMIME_ENCRYPT   (APPLICATION_SMIME | SEC_ENCRYPT)

Definition at line 109 of file lib.h.

◆ SMIME_SIGN

#define SMIME_SIGN   (APPLICATION_SMIME | SEC_SIGN)

Definition at line 110 of file lib.h.

◆ SMIME_GOODSIGN

#define SMIME_GOODSIGN   (APPLICATION_SMIME | SEC_GOODSIGN)

Definition at line 111 of file lib.h.

◆ SMIME_BADSIGN

#define SMIME_BADSIGN   (APPLICATION_SMIME | SEC_BADSIGN)

Definition at line 112 of file lib.h.

◆ SMIME_OPAQUE

#define SMIME_OPAQUE   (APPLICATION_SMIME | SEC_SIGNOPAQUE)

Definition at line 113 of file lib.h.

◆ WithCrypto

#define WithCrypto   (APPLICATION_PGP | APPLICATION_SMIME)

Definition at line 123 of file lib.h.

◆ KEYFLAG_NO_FLAGS

#define KEYFLAG_NO_FLAGS   0

No flags are set.

Definition at line 133 of file lib.h.

◆ KEYFLAG_CANSIGN

#define KEYFLAG_CANSIGN   (1 << 0)

Key is suitable for signing.

Definition at line 134 of file lib.h.

◆ KEYFLAG_CANENCRYPT

#define KEYFLAG_CANENCRYPT   (1 << 1)

Key is suitable for encryption.

Definition at line 135 of file lib.h.

◆ KEYFLAG_ISX509

#define KEYFLAG_ISX509   (1 << 2)

Key is an X.509 key.

Definition at line 136 of file lib.h.

◆ KEYFLAG_SECRET

#define KEYFLAG_SECRET   (1 << 7)

Key is a secret key.

Definition at line 137 of file lib.h.

◆ KEYFLAG_EXPIRED

#define KEYFLAG_EXPIRED   (1 << 8)

Key is expired.

Definition at line 138 of file lib.h.

◆ KEYFLAG_REVOKED

#define KEYFLAG_REVOKED   (1 << 9)

Key is revoked.

Definition at line 139 of file lib.h.

◆ KEYFLAG_DISABLED

#define KEYFLAG_DISABLED   (1 << 10)

Key is marked disabled.

Definition at line 140 of file lib.h.

◆ KEYFLAG_SUBKEY

#define KEYFLAG_SUBKEY   (1 << 11)

Key is a subkey.

Definition at line 141 of file lib.h.

◆ KEYFLAG_CRITICAL

#define KEYFLAG_CRITICAL   (1 << 12)

Key is marked critical.

Definition at line 142 of file lib.h.

◆ KEYFLAG_PREFER_ENCRYPTION

#define KEYFLAG_PREFER_ENCRYPTION   (1 << 13)

Key's owner prefers encryption.

Definition at line 143 of file lib.h.

◆ KEYFLAG_PREFER_SIGNING

#define KEYFLAG_PREFER_SIGNING   (1 << 14)

Key's owner prefers signing.

Definition at line 144 of file lib.h.

◆ KEYFLAG_CANTUSE

#define KEYFLAG_CANTUSE   (KEYFLAG_DISABLED | KEYFLAG_REVOKED | KEYFLAG_EXPIRED)

Definition at line 146 of file lib.h.

◆ KEYFLAG_RESTRICTIONS

#define KEYFLAG_RESTRICTIONS   (KEYFLAG_CANTUSE | KEYFLAG_CRITICAL)

Definition at line 147 of file lib.h.

◆ KEYFLAG_ABILITIES

Definition at line 149 of file lib.h.

Typedef Documentation

◆ SecurityFlags

typedef uint16_t SecurityFlags

Flags, e.g. SEC_ENCRYPT.

Definition at line 83 of file lib.h.

◆ KeyFlags

typedef uint16_t KeyFlags

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

Definition at line 132 of file lib.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 844 of file crypt.c.

845 {
846  if (!WithCrypto)
847  return;
848 
849  struct Buffer *tempfname = mutt_buffer_pool_get();
850  mutt_buffer_mktemp(tempfname);
851  FILE *fp_out = mutt_file_fopen(mutt_b2s(tempfname), "w");
852  if (!fp_out)
853  {
854  mutt_perror(mutt_b2s(tempfname));
855  goto cleanup;
856  }
857 
859  OptDontHandlePgpKeys = true;
860 
861  struct EmailNode *en = NULL;
862  STAILQ_FOREACH(en, el, entries)
863  {
864  struct Email *e = en->email;
865 
868  {
869  mutt_file_fclose(&fp_out);
870  break;
871  }
872 
873  if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
874  {
876  fflush(fp_out);
877 
878  mutt_endwin();
879  puts(_("Trying to extract PGP keys...\n"));
880  crypt_pgp_invoke_import(mutt_b2s(tempfname));
881  }
882 
883  if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
884  {
885  if (e->security & SEC_ENCRYPT)
886  {
888  CH_NO_FLAGS, 0);
889  }
890  else
892  fflush(fp_out);
893 
894  char *mbox = NULL;
895  if (!TAILQ_EMPTY(&e->env->from))
896  {
898  mbox = TAILQ_FIRST(&e->env->from)->mailbox;
899  }
900  else if (!TAILQ_EMPTY(&e->env->sender))
901  {
903  mbox = TAILQ_FIRST(&e->env->sender)->mailbox;
904  }
905  if (mbox)
906  {
907  mutt_endwin();
908  puts(_("Trying to extract S/MIME certificates..."));
909  crypt_smime_invoke_import(mutt_b2s(tempfname), mbox);
910  }
911  }
912 
913  rewind(fp_out);
914  }
915 
916  mutt_file_fclose(&fp_out);
917  if (isendwin())
919 
920  mutt_file_unlink(mutt_b2s(tempfname));
921 
922  if (WithCrypto & APPLICATION_PGP)
923  OptDontHandlePgpKeys = false;
924 
925 cleanup:
926  mutt_buffer_pool_release(&tempfname);
927 }
#define MUTT_CM_DECODE_CRYPT
Definition: copy.h:47
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:77
#define WithCrypto
Definition: lib.h:123
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:294
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
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.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:195
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:48
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:828
#define _(a)
Definition: message.h:28
#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:134
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:153
struct Envelope * env
Envelope information.
Definition: email.h:90
WHERE bool OptDontHandlePgpKeys
(pseudo) used to extract PGP keys
Definition: options.h:36
#define mutt_b2s(buf)
Definition: buffer.h:41
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
void mutt_endwin(void)
Shutdown curses/slang.
Definition: curs_lib.c:571
void crypt_pgp_invoke_import(const char *fname)
Wrapper for CryptModuleSpecs::pgp_invoke_import()
Definition: cryptglue.c:362
#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/lib.h pgplib...
Definition: email.h:39
#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:604
void crypt_smime_invoke_import(const char *infile, const char *mailbox)
Wrapper for CryptModuleSpecs::smime_invoke_import()
Definition: cryptglue.c:508
struct Email * email
Email in the list.
Definition: email.h:127
struct AddressList sender
Email&#39;s sender.
Definition: envelope.h:61
List of Emails.
Definition: email.h:125
#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:588
+ 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 92 of file crypt.c.

93 {
96 
99 
100  if (WithCrypto)
101  {
102  /* L10N: Due to the implementation details (e.g. some passwords are managed
103  by gpg-agent) we can't know whether we forgot zero, 1, 12, ...
104  passwords. So in English we use "Passphrases". Your language might
105  have other means to express this. */
106  mutt_message(_("Passphrases forgotten"));
107  }
108 }
#define WithCrypto
Definition: lib.h:123
#define mutt_message(...)
Definition: logging.h:83
void crypt_pgp_void_passphrase(void)
Wrapper for CryptModuleSpecs::void_passphrase()
Definition: cryptglue.c:187
#define _(a)
Definition: message.h:28
void crypt_smime_void_passphrase(void)
Wrapper for CryptModuleSpecs::void_passphrase()
Definition: cryptglue.c:411
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
+ 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 943 of file crypt.c.

944 {
945  if (!WithCrypto)
946  return 0;
947 
948  struct AddressList addrlist = TAILQ_HEAD_INITIALIZER(addrlist);
949  const char *fqdn = mutt_fqdn(true, NeoMutt->sub);
950  char *self_encrypt = NULL;
951 
952  /* Do a quick check to make sure that we can find all of the encryption
953  * keys if the user has requested this service. */
954 
955  *keylist = NULL;
956 
957 #ifdef USE_AUTOCRYPT
958  if (!oppenc_mode && (e->security & SEC_AUTOCRYPT))
959  {
961  return -1;
962  return 0;
963  }
964 #endif
965 
967  OptPgpCheckTrust = true;
968 
969  mutt_addrlist_copy(&addrlist, &e->env->to, false);
970  mutt_addrlist_copy(&addrlist, &e->env->cc, false);
971  mutt_addrlist_copy(&addrlist, &e->env->bcc, false);
972  mutt_addrlist_qualify(&addrlist, fqdn);
973  mutt_addrlist_dedupe(&addrlist);
974 
975  if (oppenc_mode || (e->security & SEC_ENCRYPT))
976  {
977  if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
978  {
979  *keylist = crypt_pgp_find_keys(&addrlist, oppenc_mode);
980  if (!*keylist)
981  {
982  mutt_addrlist_clear(&addrlist);
983  return -1;
984  }
985  OptPgpCheckTrust = false;
987  self_encrypt = C_PgpDefaultKey;
988  }
989  if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
990  {
991  *keylist = crypt_smime_find_keys(&addrlist, oppenc_mode);
992  if (!*keylist)
993  {
994  mutt_addrlist_clear(&addrlist);
995  return -1;
996  }
998  self_encrypt = C_SmimeDefaultKey;
999  }
1000  }
1001 
1002  if (!oppenc_mode && self_encrypt)
1003  {
1004  const size_t keylist_size = mutt_str_len(*keylist);
1005  mutt_mem_realloc(keylist, keylist_size + mutt_str_len(self_encrypt) + 2);
1006  sprintf(*keylist + keylist_size, " %s", self_encrypt);
1007  }
1008 
1009  mutt_addrlist_clear(&addrlist);
1010 
1011  return 0;
1012 }
#define WithCrypto
Definition: lib.h:123
char * crypt_smime_find_keys(struct AddressList *addrlist, bool oppenc_mode)
Wrapper for CryptModuleSpecs::find_keys()
Definition: cryptglue.c:475
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:1468
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:737
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:94
unsigned char C_SmimeEncryptSelf
Definition: config.c:80
Container for Accounts, Notifications.
Definition: neomutt.h:36
Do no use Autocrypt.
Definition: lib.h:157
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1405
struct Envelope * env
Envelope information.
Definition: email.h:90
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
char * C_PgpDefaultKey
Config: Default key to use for PGP operations.
Definition: config.c:66
bool C_SmimeSelfEncrypt
Config: Encrypted messages will also be encrypt to C_SmimeDefaultKey too.
Definition: config.c:81
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:114
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
WHERE bool OptPgpCheckTrust
(pseudo) used by dlg_select_pgp_key()
Definition: options.h:49
char * C_SmimeDefaultKey
Config: Default key for SMIME operations.
Definition: config.c:69
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:631
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
Expand local names in an Address list using a hostname.
Definition: address.c:650
char * crypt_pgp_find_keys(struct AddressList *addrlist, bool oppenc_mode)
Wrapper for CryptModuleSpecs::find_keys()
Definition: cryptglue.c:314
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:1181
enum AutocryptRec mutt_autocrypt_ui_recommendation(struct Email *e, char **keylist)
Get the recommended action for an Email.
Definition: autocrypt.c:551
unsigned char C_PgpEncryptSelf
Definition: config.c:75
bool C_PgpSelfEncrypt
Config: Encrypted messages will also be encrypted to C_PgpDefaultKey too.
Definition: config.c:78
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:630
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
+ 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 1021 of file crypt.c.

1022 {
1023  if (!WithCrypto)
1024  return;
1025 
1027  return;
1028 
1029  char *pgpkeylist = NULL;
1030 
1031  crypt_get_keys(e, &pgpkeylist, 1);
1032  if (pgpkeylist)
1033  {
1034  e->security |= SEC_ENCRYPT;
1035  FREE(&pgpkeylist);
1036  }
1037  else
1038  {
1039  e->security &= ~SEC_ENCRYPT;
1040  }
1041 }
#define WithCrypto
Definition: lib.h:123
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
int crypt_get_keys(struct Email *e, char **keylist, bool oppenc_mode)
Check we have all the keys we need.
Definition: crypt.c:943
bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: config.c:56
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:93
#define FREE(x)
Definition: memory.h:40
+ 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 685 of file crypt.c.

686 {
687  if (!WithCrypto || !m)
688  return SEC_NO_FLAGS;
689 
691 
692  if (m->type == TYPE_APPLICATION)
693  {
695  rc |= mutt_is_application_pgp(m);
696 
698  {
699  rc |= mutt_is_application_smime(m);
700  if (rc && m->goodsig)
701  rc |= SEC_GOODSIGN;
702  if (rc && m->badsig)
703  rc |= SEC_BADSIGN;
704  }
705  }
706  else if (((WithCrypto & APPLICATION_PGP) != 0) && (m->type == TYPE_TEXT))
707  {
708  rc |= mutt_is_application_pgp(m);
709  if (rc && m->goodsig)
710  rc |= SEC_GOODSIGN;
711  }
712 
713  if (m->type == TYPE_MULTIPART)
714  {
716  rc |= mutt_is_multipart_signed(m);
718 
719  if (rc && m->goodsig)
720  rc |= SEC_GOODSIGN;
721 #ifdef USE_AUTOCRYPT
722  if (rc && m->is_autocrypt)
723  rc |= SEC_AUTOCRYPT;
724 #endif
725  }
726 
727  if ((m->type == TYPE_MULTIPART) || (m->type == TYPE_MESSAGE))
728  {
729  SecurityFlags u = m->parts ? SEC_ALL_FLAGS : SEC_NO_FLAGS; /* Bits set in all parts */
730  SecurityFlags w = SEC_NO_FLAGS; /* Bits set in any part */
731 
732  for (struct Body *b = m->parts; b; b = b->next)
733  {
734  const SecurityFlags v = crypt_query(b);
735  u &= v;
736  w |= v;
737  }
738  rc |= u | (w & ~SEC_GOODSIGN);
739 
740  if ((w & SEC_GOODSIGN) && !(u & SEC_GOODSIGN))
741  rc |= SEC_PARTSIGN;
742  }
743 
744  return rc;
745 }
#define WithCrypto
Definition: lib.h:123
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
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_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:94
#define SEC_ALL_FLAGS
Definition: lib.h:101
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:83
The body of an email.
Definition: body.h:34
SecurityFlags mutt_is_multipart_encrypted(struct Body *b)
Does the message have encrypted parts?
Definition: crypt.c:447
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:407
bool goodsig
Good cryptographic signature.
Definition: body.h:75
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
SecurityFlags mutt_is_application_pgp(struct Body *m)
Does the message use PGP?
Definition: crypt.c:552
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
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:508
SecurityFlags mutt_is_application_smime(struct Body *m)
Does the message use S/MIME?
Definition: crypt.c:610
#define SEC_BADSIGN
Email has a bad signature.
Definition: lib.h:88
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
Type: &#39;message/*&#39;.
Definition: mime.h:35
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
SecurityFlags crypt_query(struct Body *m)
Check out the type of encryption used.
Definition: crypt.c:685
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:87
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:89
Type: &#39;application/*&#39;.
Definition: mime.h:33
+ 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 134 of file crypt.c.

135 {
136  bool rc = false;
137 
138 #ifndef DEBUG
139  disable_coredumps();
140 #endif
141 
142  if (((WithCrypto & APPLICATION_PGP) != 0) && (flags & APPLICATION_PGP))
144 
145  if (((WithCrypto & APPLICATION_SMIME) != 0) && (flags & APPLICATION_SMIME))
147 
148  return rc;
149 }
#define WithCrypto
Definition: lib.h:123
bool crypt_smime_valid_passphrase(void)
Wrapper for CryptModuleSpecs::valid_passphrase()
Definition: cryptglue.c:420
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
bool crypt_pgp_valid_passphrase(void)
Wrapper for CryptModuleSpecs::valid_passphrase()
Definition: cryptglue.c:196
+ 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 552 of file crypt.c.

553 {
555  char *p = NULL;
556 
557  if (m->type == TYPE_APPLICATION)
558  {
559  if (mutt_istr_equal(m->subtype, "pgp") ||
560  mutt_istr_equal(m->subtype, "x-pgp-message"))
561  {
562  p = mutt_param_get(&m->parameter, "x-action");
563  if (p && (mutt_istr_equal(p, "sign") || mutt_istr_equal(p, "signclear")))
564  {
565  t |= PGP_SIGN;
566  }
567 
568  p = mutt_param_get(&m->parameter, "format");
569  if (p && mutt_istr_equal(p, "keys-only"))
570  {
571  t |= PGP_KEY;
572  }
573 
574  if (t == SEC_NO_FLAGS)
575  t |= PGP_ENCRYPT; /* not necessarily correct, but... */
576  }
577 
578  if (mutt_istr_equal(m->subtype, "pgp-signed"))
579  t |= PGP_SIGN;
580 
581  if (mutt_istr_equal(m->subtype, "pgp-keys"))
582  t |= PGP_KEY;
583  }
584  else if ((m->type == TYPE_TEXT) && mutt_istr_equal("plain", m->subtype))
585  {
586  if (((p = mutt_param_get(&m->parameter, "x-mutt-action")) ||
587  (p = mutt_param_get(&m->parameter, "x-action")) ||
588  (p = mutt_param_get(&m->parameter, "action"))) &&
589  mutt_istr_startswith(p, "pgp-sign"))
590  {
591  t |= PGP_SIGN;
592  }
593  else if (p && mutt_istr_startswith(p, "pgp-encrypt"))
594  t |= PGP_ENCRYPT;
595  else if (p && mutt_istr_startswith(p, "pgp-keys"))
596  t |= PGP_KEY;
597  }
598  if (t)
599  t |= PGP_INLINE;
600 
601  return t;
602 }
#define PGP_INLINE
Definition: lib.h:107
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
#define PGP_ENCRYPT
Definition: lib.h:103
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:83
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
char * subtype
content-type subtype
Definition: body.h:37
Type: &#39;text/*&#39;.
Definition: mime.h:38
#define PGP_SIGN
Definition: lib.h:104
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:172
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
#define PGP_KEY
Definition: lib.h:106
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
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_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 610 of file crypt.c.

611 {
612  if (!m)
613  return SEC_NO_FLAGS;
614 
615  if (((m->type & TYPE_APPLICATION) == 0) || !m->subtype)
616  return SEC_NO_FLAGS;
617 
618  char *t = NULL;
619  bool complain = false;
620  /* S/MIME MIME types don't need x- anymore, see RFC2311 */
621  if (mutt_istr_equal(m->subtype, "x-pkcs7-mime") || mutt_istr_equal(m->subtype, "pkcs7-mime"))
622  {
623  t = mutt_param_get(&m->parameter, "smime-type");
624  if (t)
625  {
626  if (mutt_istr_equal(t, "enveloped-data"))
627  return SMIME_ENCRYPT;
628  if (mutt_istr_equal(t, "signed-data"))
629  return SMIME_SIGN | SMIME_OPAQUE;
630  return SEC_NO_FLAGS;
631  }
632  /* Netscape 4.7 uses
633  * Content-Description: S/MIME Encrypted Message
634  * instead of Content-Type parameter */
635  if (mutt_istr_equal(m->description, "S/MIME Encrypted Message"))
636  return SMIME_ENCRYPT;
637  complain = true;
638  }
639  else if (!mutt_istr_equal(m->subtype, "octet-stream"))
640  return SEC_NO_FLAGS;
641 
642  t = mutt_param_get(&m->parameter, "name");
643 
644  if (!t)
645  t = m->d_filename;
646  if (!t)
647  t = m->filename;
648  if (!t)
649  {
650  if (complain)
651  {
652  mutt_message(
653  _("S/MIME messages with no hints on content are unsupported"));
654  }
655  return SEC_NO_FLAGS;
656  }
657 
658  /* no .p7c, .p10 support yet. */
659 
660  int len = mutt_str_len(t) - 4;
661  if ((len > 0) && (*(t + len) == '.'))
662  {
663  len++;
664  if (mutt_istr_equal((t + len), "p7m"))
665  {
666  /* Not sure if this is the correct thing to do, but
667  * it's required for compatibility with Outlook */
668  return SMIME_SIGN | SMIME_OPAQUE;
669  }
670  else if (mutt_istr_equal((t + len), "p7s"))
671  return SMIME_SIGN | SMIME_OPAQUE;
672  }
673 
674  return SEC_NO_FLAGS;
675 }
#define SMIME_OPAQUE
Definition: lib.h:113
char * filename
when sending a message, this is the file to which this structure refers
Definition: body.h:46
#define SMIME_SIGN
Definition: lib.h:110
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
#define mutt_message(...)
Definition: logging.h:83
#define SMIME_ENCRYPT
Definition: lib.h:109
#define _(a)
Definition: message.h:28
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
char * subtype
content-type subtype
Definition: body.h:37
char * description
content-description
Definition: body.h:40
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:631
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 508 of file crypt.c.

509 {
510  if (!(WithCrypto & APPLICATION_PGP))
511  return SEC_NO_FLAGS;
512 
513  if (!b || (b->type != TYPE_MULTIPART) || !b->subtype || !mutt_istr_equal(b->subtype, "mixed"))
514  {
515  return SEC_NO_FLAGS;
516  }
517 
518  b = b->parts;
519  if (!b || (b->type != TYPE_TEXT) || !b->subtype ||
520  !mutt_istr_equal(b->subtype, "plain") || (b->length != 0))
521  {
522  return SEC_NO_FLAGS;
523  }
524 
525  b = b->next;
526  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
527  !mutt_istr_equal(b->subtype, "pgp-encrypted"))
528  {
529  return SEC_NO_FLAGS;
530  }
531 
532  b = b->next;
533  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
534  !mutt_istr_equal(b->subtype, "octet-stream"))
535  {
536  return SEC_NO_FLAGS;
537  }
538 
539  b = b->next;
540  if (b)
541  return SEC_NO_FLAGS;
542 
543  return PGP_ENCRYPT;
544 }
#define WithCrypto
Definition: lib.h:123
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
#define PGP_ENCRYPT
Definition: lib.h:103
struct Body * next
next attachment in the list
Definition: body.h:53
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
char * subtype
content-type subtype
Definition: body.h:37
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
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, ContentType
Definition: body.h:65
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
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_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 447 of file crypt.c.

448 {
449  if ((WithCrypto & APPLICATION_PGP) == 0)
450  return SEC_NO_FLAGS;
451 
452  char *p = NULL;
453 
454  if (!b || (b->type != TYPE_MULTIPART) || !b->subtype ||
455  !mutt_istr_equal(b->subtype, "encrypted") ||
456  !(p = mutt_param_get(&b->parameter, "protocol")) ||
457  !mutt_istr_equal(p, "application/pgp-encrypted"))
458  {
459  return SEC_NO_FLAGS;
460  }
461 
462  return PGP_ENCRYPT;
463 }
#define WithCrypto
Definition: lib.h:123
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
#define PGP_ENCRYPT
Definition: lib.h:103
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
char * subtype
content-type subtype
Definition: body.h:37
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
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
+ 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 407 of file crypt.c.

408 {
409  if (!b || (b->type != TYPE_MULTIPART) || !b->subtype || !mutt_istr_equal(b->subtype, "signed"))
410  {
411  return SEC_NO_FLAGS;
412  }
413 
414  char *p = mutt_param_get(&b->parameter, "protocol");
415  if (!p)
416  return SEC_NO_FLAGS;
417 
418  if (mutt_istr_equal(p, "multipart/mixed"))
419  return SEC_SIGN;
420 
421  if (((WithCrypto & APPLICATION_PGP) != 0) &&
422  mutt_istr_equal(p, "application/pgp-signature"))
423  {
424  return PGP_SIGN;
425  }
426 
427  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
428  mutt_istr_equal(p, "application/x-pkcs7-signature"))
429  {
430  return SMIME_SIGN;
431  }
432  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
433  mutt_istr_equal(p, "application/pkcs7-signature"))
434  {
435  return SMIME_SIGN;
436  }
437 
438  return SEC_NO_FLAGS;
439 }
#define SMIME_SIGN
Definition: lib.h:110
#define WithCrypto
Definition: lib.h:123
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
char * subtype
content-type subtype
Definition: body.h:37
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
#define PGP_SIGN
Definition: lib.h:104
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
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
+ 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 471 of file crypt.c.

472 {
474  return 0;
475 
476  b = b->parts;
477  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
478  !mutt_istr_equal(b->subtype, "pgp-encrypted"))
479  {
480  return 0;
481  }
482 
483  b = b->next;
484  if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
485  !mutt_istr_equal(b->subtype, "octet-stream"))
486  {
487  return 0;
488  }
489 
490  return PGP_ENCRYPT;
491 }
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
#define PGP_ENCRYPT
Definition: lib.h:103
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:447
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
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, ContentType
Definition: body.h:65
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_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 159 of file crypt.c.

160 {
161  struct Body *pbody = NULL, *tmp_pbody = NULL;
162  struct Body *tmp_smime_pbody = NULL;
163  struct Body *tmp_pgp_pbody = NULL;
164  bool has_retainable_sig = false;
165 
166  if (!WithCrypto)
167  return -1;
168 
169  int security = e->security;
170  int sign = security & (SEC_AUTOCRYPT | SEC_SIGN);
171  if (postpone)
172  {
173  sign = SEC_NO_FLAGS;
174  security &= ~SEC_SIGN;
175  }
176 
177  if (!(security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) && !sign)
178  return 0;
179 
180  if (sign && !(security & SEC_AUTOCRYPT) && !crypt_valid_passphrase(security))
181  return -1;
182 
183  if (((WithCrypto & APPLICATION_PGP) != 0) && !(security & SEC_AUTOCRYPT) &&
184  ((security & PGP_INLINE) == PGP_INLINE))
185  {
186  if ((e->body->type != TYPE_TEXT) ||
187  !mutt_istr_equal(e->body->subtype, "plain"))
188  {
190  _("Inline PGP can't be used with attachments. "
191  "Revert to PGP/MIME?")) != MUTT_YES)
192  {
193  mutt_error(
194  _("Mail not sent: inline PGP can't be used with attachments"));
195  return -1;
196  }
197  }
198  else if (mutt_istr_equal("flowed",
199  mutt_param_get(&e->body->parameter, "format")))
200  {
202  _("Inline PGP can't be used with format=flowed. "
203  "Revert to PGP/MIME?"))) != MUTT_YES)
204  {
205  mutt_error(
206  _("Mail not sent: inline PGP can't be used with format=flowed"));
207  return -1;
208  }
209  }
210  else
211  {
212  /* they really want to send it inline... go for it */
213  if (!isendwin())
214  {
215  mutt_endwin();
216  puts(_("Invoking PGP..."));
217  }
218  pbody = crypt_pgp_traditional_encryptsign(e->body, security, keylist);
219  if (pbody)
220  {
221  e->body = pbody;
222  return 0;
223  }
224 
225  /* otherwise inline won't work...ask for revert */
226  if (query_quadoption(
228  _("Message can't be sent inline. Revert to using PGP/MIME?")) != MUTT_YES)
229  {
230  mutt_error(_("Mail not sent"));
231  return -1;
232  }
233  }
234 
235  /* go ahead with PGP/MIME */
236  }
237 
238  if (!isendwin())
239  mutt_endwin();
240 
242  tmp_smime_pbody = e->body;
243  if (WithCrypto & APPLICATION_PGP)
244  tmp_pgp_pbody = e->body;
245 
246 #ifdef CRYPT_BACKEND_GPGME
247  if (sign && C_CryptUsePka)
248 #else
249  if (sign)
250 #endif
251  {
252  /* Set sender (necessary for e.g. PKA). */
253  const char *mailbox = NULL;
254  struct Address *from = TAILQ_FIRST(&e->env->from);
255  bool free_from = false;
256 
257  if (!from)
258  {
259  free_from = true;
260  from = mutt_default_from(NeoMutt->sub);
261  }
262 
263  mailbox = from->mailbox;
264  if (!mailbox && C_EnvelopeFromAddress)
265  mailbox = C_EnvelopeFromAddress->mailbox;
266 
267  if (((WithCrypto & APPLICATION_SMIME) != 0) && (security & APPLICATION_SMIME))
268  crypt_smime_set_sender(mailbox);
269  else if (((WithCrypto & APPLICATION_PGP) != 0) && (security & APPLICATION_PGP))
270  crypt_pgp_set_sender(mailbox);
271 
272  if (free_from)
273  mutt_addr_free(&from);
274  }
275 
277  {
278  struct Envelope *protected_headers = mutt_env_new();
279  mutt_str_replace(&protected_headers->subject, e->env->subject);
280  /* Note: if other headers get added, such as to, cc, then a call to
281  * mutt_env_to_intl() will need to be added here too. */
282  mutt_prepare_envelope(protected_headers, 0, NeoMutt->sub);
283 
285  e->body->mime_headers = protected_headers;
286  /* Optional part of the draft RFC, but required by Enigmail */
287  mutt_param_set(&e->body->parameter, "protected-headers", "v1");
288  }
289  else
290  {
291  mutt_param_delete(&e->body->parameter, "protected-headers");
292  }
293 
294 #ifdef USE_AUTOCRYPT
295  /* A note about e->body->mime_headers. If postpone or send
296  * fails, the mime_headers is cleared out before returning to the
297  * compose menu. So despite the "robustness" code above and in the
298  * gen_gossip_list function below, mime_headers will not be set when
299  * entering mutt_protect().
300  *
301  * This is important to note because the user could toggle
302  * $crypt_protected_headers_write or $autocrypt off back in the
303  * compose menu. We don't want mutt_write_rfc822_header() to write
304  * stale data from one option if the other is set.
305  */
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->body, &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->body, &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->body) && (tmp_smime_pbody != tmp_pbody))
354  {
355  /* detach and don't delete e->body,
356  * which tmp_smime_pbody->parts after signing. */
357  tmp_smime_pbody->parts = tmp_smime_pbody->parts->next;
358  e->body->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 signatures.
382  if (has_retainable_sig)
383  {
384  tmp_pgp_pbody = mutt_remove_multipart(tmp_pgp_pbody);
385  mutt_body_free(&tmp_pgp_pbody->next);
386  }
387  }
388  }
389 
390  if (pbody)
391  {
392  e->body = pbody;
393  return 0;
394  }
395 
396 bail:
398  return -1;
399 }
#define PGP_INLINE
Definition: lib.h:107
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:63
#define WithCrypto
Definition: lib.h:123
#define TAILQ_FIRST(head)
Definition: queue.h:716
struct Body * body
List of MIME parts.
Definition: email.h:91
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: config.c:37
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
void crypt_pgp_set_sender(const char *sender)
Wrapper for CryptModuleSpecs::set_sender()
Definition: cryptglue.c:402
#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
unsigned char C_PgpMimeAuto
Config: Prompt the user to use MIME if inline PGP fails.
Definition: config.c:76
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:94
void mutt_addr_free(struct Address **ptr)
Free a single Address.
Definition: address.c:440
Container for Accounts, Notifications.
Definition: neomutt.h:36
The body of an email.
Definition: body.h:34
void crypt_smime_set_sender(const char *sender)
Wrapper for CryptModuleSpecs::set_sender()
Definition: cryptglue.c:539
struct Body * crypt_smime_sign_message(struct Body *a, const struct AddressList *from)
Wrapper for CryptModuleSpecs::sign_message()
Definition: cryptglue.c:486
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:134
void mutt_prepare_envelope(struct Envelope *env, bool final, struct ConfigSubset *sub)
Prepare an email header.
Definition: sendlib.c:1237
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct Envelope * env
Envelope information.
Definition: email.h:90
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:42
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
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:336
bool C_CryptUsePka
Config: Use GPGME to use PKA (lookup PGP keys using DNS)
Definition: config.c:53
void mutt_param_delete(struct ParameterList *pl, const char *attribute)
Delete a matching Parameter.
Definition: parameter.c:142
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: multipart.c:126
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
void mutt_endwin(void)
Shutdown curses/slang.
Definition: curs_lib.c:571
struct Address * mutt_default_from(struct ConfigSubset *sub)
Get a default &#39;from&#39; Address.
Definition: send.c:1323
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:292
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
bool C_PgpRetainableSigs
Config: Create nested multipart/signed or encrypted messages.
Definition: config.c:77
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: curs_lib.c:517
struct Body * crypt_smime_build_smime_entity(struct Body *a, char *certlist)
Wrapper for CryptModuleSpecs::smime_build_smime_entity()
Definition: cryptglue.c:497
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:808
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:446
#define mutt_error(...)
Definition: logging.h:84
struct Body * crypt_pgp_sign_message(struct Body *a, const struct AddressList *from)
Wrapper for CryptModuleSpecs::sign_message()
Definition: cryptglue.c:325
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
struct Address * C_EnvelopeFromAddress
Config: Manually set the sender for outgoing messages.
Definition: config.c:73
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:110
The header of an Email.
Definition: envelope.h:54
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
bool C_CryptProtectedHeadersWrite
Config: Generate protected header (Memory Hole) for signed and encrypted emails.
Definition: config.c:60
+ 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 1087 of file crypt.c.

1088 {
1089  if (C_CryptProtectedHeadersRead && a->mime_headers)
1090  {
1091  if (a->mime_headers->subject)
1092  {
1093  const bool display = (s->flags & MUTT_DISPLAY);
1094 
1095  if (display && C_Weed && mutt_matches_ignore("subject"))
1096  return 0;
1097 
1099  int wraplen = display ? mutt_window_wrap_cols(s->wraplen, C_Wrap) : 0;
1100 
1101  mutt_write_one_header(s->fp_out, "Subject", a->mime_headers->subject, s->prefix,
1102  wraplen, display ? CH_DISPLAY : CH_NO_FLAGS, NeoMutt->sub);
1103  state_puts(s, "\n");
1104  }
1105  }
1106 
1107  return 0;
1108 }
bool mutt_matches_ignore(const char *s)
Does the string match the ignore list.
Definition: parse.c:314
#define MUTT_DISPLAY
Output is displayed to the user.
Definition: state.h:32
#define state_puts(STATE, STR)
Definition: state.h:55
bool C_CryptProtectedHeadersRead
Config: Display protected headers (Memory Hole) in the pager.
Definition: config.c:58
char * prefix
String to add to the beginning of each output line.
Definition: state.h:48
FILE * fp_out
File to write to.
Definition: state.h:47
Container for Accounts, Notifications.
Definition: neomutt.h:36
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
WHERE short C_Wrap
Config: Width to wrap text in the pager.
Definition: mutt_globals.h:116
#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:487
void state_mark_protected_header(struct State *s)
Write a unique marker around protected headers.
Definition: state.c:56
bool C_Weed
Config: Filter headers when displaying/forwarding/printing/replying.
Definition: globals.c:40
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
int mutt_write_one_header(FILE *fp, const char *tag, const char *value, const char *pfx, int wraplen, CopyHeaderFlags chflags, struct ConfigSubset *sub)
Write one header line to a file.
Definition: header.c:419
+ 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 1073 of file crypt.c.

1074 {
1077  {
1078  return true;
1079  }
1080 
1081  return false;
1082 }
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:94
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:92
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
char * C_CryptProtectedHeadersSubject
Config: Use this as the subject for encrypted emails.
Definition: config.c:72
bool C_CryptProtectedHeadersWrite
Config: Generate protected header (Memory Hole) for signed and encrypted emails.
Definition: config.c:60
+ 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 1113 of file crypt.c.

1114 {
1115  if (!WithCrypto)
1116  return -1;
1117 
1118  bool inconsistent = false;
1119  struct Body *b = a;
1120  struct Body **signatures = NULL;
1121  int sigcnt = 0;
1122  int rc = 0;
1123  struct Buffer *tempfile = NULL;
1124 
1125  a = a->parts;
1126  SecurityFlags signed_type = mutt_is_multipart_signed(b);
1127  if (signed_type == SEC_NO_FLAGS)
1128  {
1129  /* A null protocol value is already checked for in mutt_body_handler() */
1130  state_printf(s,
1131  _("[-- Error: "
1132  "Unknown multipart/signed protocol %s --]\n\n"),
1133  mutt_param_get(&b->parameter, "protocol"));
1134  return mutt_body_handler(a, s);
1135  }
1136 
1137  if (!(a && a->next))
1138  inconsistent = true;
1139  else
1140  {
1141  switch (signed_type)
1142  {
1143  case SEC_SIGN:
1144  if ((a->next->type != TYPE_MULTIPART) || !mutt_istr_equal(a->next->subtype, "mixed"))
1145  {
1146  inconsistent = true;
1147  }
1148  break;
1149  case PGP_SIGN:
1150  if ((a->next->type != TYPE_APPLICATION) ||
1151  !mutt_istr_equal(a->next->subtype, "pgp-signature"))
1152  {
1153  inconsistent = true;
1154  }
1155  break;
1156  case SMIME_SIGN:
1157  if ((a->next->type != TYPE_APPLICATION) ||
1158  (!mutt_istr_equal(a->next->subtype, "x-pkcs7-signature") &&
1159  !mutt_istr_equal(a->next->subtype, "pkcs7-signature")))
1160  {
1161  inconsistent = true;
1162  }
1163  break;
1164  default:
1165  inconsistent = true;
1166  }
1167  }
1168  if (inconsistent)
1169  {
1170  state_attach_puts(s, _("[-- Error: Missing or bad-format multipart/signed "
1171  "signature --]\n\n"));
1172  return mutt_body_handler(a, s);
1173  }
1174 
1175  if (s->flags & MUTT_DISPLAY)
1176  {
1177  crypt_fetch_signatures(&signatures, a->next, &sigcnt);
1178 
1179  if (sigcnt != 0)
1180  {
1181  tempfile = mutt_buffer_pool_get();
1182  mutt_buffer_mktemp(tempfile);
1183  bool goodsig = true;
1184  if (crypt_write_signed(a, s, mutt_b2s(tempfile)) == 0)
1185  {
1186  for (int i = 0; i < sigcnt; i++)
1187  {
1188  if (((WithCrypto & APPLICATION_PGP) != 0) &&
1189  (signatures[i]->type == TYPE_APPLICATION) &&
1190  mutt_istr_equal(signatures[i]->subtype, "pgp-signature"))
1191  {
1192  if (crypt_pgp_verify_one(signatures[i], s, mutt_b2s(tempfile)) != 0)
1193  goodsig = false;
1194 
1195  continue;
1196  }
1197 
1198  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
1199  (signatures[i]->type == TYPE_APPLICATION) &&
1200  (mutt_istr_equal(signatures[i]->subtype, "x-pkcs7-signature") ||
1201  mutt_istr_equal(signatures[i]->subtype, "pkcs7-signature")))
1202  {
1203  if (crypt_smime_verify_one(signatures[i], s, mutt_b2s(tempfile)) != 0)
1204  goodsig = false;
1205 
1206  continue;
1207  }
1208 
1209  state_printf(s,
1210  _("[-- Warning: "
1211  "We can't verify %s/%s signatures. --]\n\n"),
1212  TYPE(signatures[i]), signatures[i]->subtype);
1213  }
1214  }
1215 
1216  mutt_file_unlink(mutt_b2s(tempfile));
1217  mutt_buffer_pool_release(&tempfile);
1218 
1219  b->goodsig = goodsig;
1220  b->badsig = !goodsig;
1221 
1222  /* Now display the signed body */
1223  state_attach_puts(s, _("[-- The following data is signed --]\n\n"));
1224 
1226 
1227  FREE(&signatures);
1228  }
1229  else
1230  {
1232  _("[-- Warning: Can't find any signatures. --]\n\n"));
1233  }
1234  }
1235 
1236  rc = mutt_body_handler(a, s);
1237 
1238  if ((s->flags & MUTT_DISPLAY) && (sigcnt != 0))
1239  state_attach_puts(s, _("\n[-- End of signed data --]\n"));
1240 
1241  return rc;
1242 }
int mutt_protected_headers_handler(struct Body *a, struct State *s)
Process a protected header - Implements handler_t.
Definition: crypt.c:1087
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:77
#define MUTT_DISPLAY
Output is displayed to the user.
Definition: state.h:32
#define SMIME_SIGN
Definition: lib.h:110
#define WithCrypto
Definition: lib.h:123
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: lib.h:84
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:195
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
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:83
int crypt_write_signed(struct Body *a, struct State *s, const char *tempfile)
Write the message body/part.
Definition: crypt.c:757
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:407
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
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 APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
#define PGP_SIGN
Definition: lib.h:104
static void crypt_fetch_signatures(struct Body ***signatures, struct Body *a, int *n)
Create an array of an emails parts.
Definition: crypt.c:1049
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
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:89
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
#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:517
int mutt_body_handler(struct Body *b, struct State *s)
Handler for the Body of an email.
Definition: handler.c:1593
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
Type: &#39;application/*&#39;.
Definition: mime.h:33
int crypt_pgp_verify_one(struct Body *sigbdy, struct State *s, const char *tempf)
Wrapper for CryptModuleSpecs::verify_one()
Definition: cryptglue.c:371
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ crypt_cleanup()

void crypt_cleanup ( void  )

Clean up backend.

Definition at line 138 of file cryptglue.c.

139 {
140  if (CRYPT_MOD_CALL_CHECK(PGP, cleanup))
141  (CRYPT_MOD_CALL(PGP, cleanup))();
142 
143  if (CRYPT_MOD_CALL_CHECK(SMIME, cleanup))
144  (CRYPT_MOD_CALL(SMIME, cleanup))();
145 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 167 of file cryptglue.c.

168 {
169  if (((WithCrypto & APPLICATION_PGP) != 0) && (type & APPLICATION_PGP) &&
170  crypto_module_lookup(APPLICATION_PGP))
171  {
172  return true;
173  }
174 
175  if (((WithCrypto & APPLICATION_SMIME) != 0) && (type & APPLICATION_SMIME) &&
176  crypto_module_lookup(APPLICATION_SMIME))
177  {
178  return true;
179  }
180 
181  return false;
182 }
#define WithCrypto
Definition: lib.h:123
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
struct CryptModuleSpecs * crypto_module_lookup(int identifier)
Lookup a crypto module by name.
Definition: crypt_mod.c:65
+ 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 93 of file cryptglue.c.

94 {
95 #ifdef CRYPT_BACKEND_CLASSIC_PGP
96  if (
97 #ifdef CRYPT_BACKEND_GPGME
99 #else
100  1
101 #endif
102  )
104 #endif
105 
106 #ifdef CRYPT_BACKEND_CLASSIC_SMIME
107  if (
108 #ifdef CRYPT_BACKEND_GPGME
109  (!C_CryptUseGpgme)
110 #else
111  1
112 #endif
113  )
115 #endif
116 
117 #ifdef CRYPT_BACKEND_GPGME
118  if (C_CryptUseGpgme)
119  {
122  }
123 #endif
124 
125 #if defined(CRYPT_BACKEND_CLASSIC_PGP) || \
126  defined(CRYPT_BACKEND_CLASSIC_SMIME) || defined(CRYPT_BACKEND_GPGME)
127  if (CRYPT_MOD_CALL_CHECK(PGP, init))
128  CRYPT_MOD_CALL(PGP, init)();
129 
130  if (CRYPT_MOD_CALL_CHECK(SMIME, init))
131  CRYPT_MOD_CALL(SMIME, init)();
132 #endif
133 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
bool C_CryptUseGpgme
Config: Use GPGME crypto backend.
Definition: config.c:83
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.
struct CryptModuleSpecs CryptModPgpGpgme
GPGME PGP - Implements CryptModuleSpecs.
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
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 153 of file cryptglue.c.

154 {
155  if (((WithCrypto & APPLICATION_PGP) != 0) && (type & APPLICATION_PGP))
156  mutt_message(_("Invoking PGP..."));
157  else if (((WithCrypto & APPLICATION_SMIME) != 0) && (type & APPLICATION_SMIME))
158  mutt_message(_("Invoking S/MIME..."));
159 }
#define WithCrypto
Definition: lib.h:123
#define mutt_message(...)
Definition: logging.h:83
#define _(a)
Definition: message.h:28
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
+ 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 234 of file cryptglue.c.

235 {
236  if (CRYPT_MOD_CALL_CHECK(PGP, application_handler))
237  return CRYPT_MOD_CALL(PGP, application_handler)(m, s);
238 
239  return -1;
240 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 281 of file cryptglue.c.

282 {
283  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_check_traditional))
284  return CRYPT_MOD_CALL(PGP, pgp_check_traditional)(fp, b, just_one);
285 
286  return 0;
287 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 207 of file cryptglue.c.

208 {
209 #ifdef USE_AUTOCRYPT
210  if (C_Autocrypt)
211  {
212  OptAutocryptGpgme = true;
213  int result = pgp_gpgme_decrypt_mime(fp_in, fp_out, b, cur);
214  OptAutocryptGpgme = false;
215  if (result == 0)
216  {
217  b->is_autocrypt = true;
218  return result;
219  }
220  }
221 #endif
222 
223  if (CRYPT_MOD_CALL_CHECK(PGP, decrypt_mime))
224  return CRYPT_MOD_CALL(PGP, decrypt_mime)(fp_in, fp_out, b, cur);
225 
226  return -1;
227 }
bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: config.c:37
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:33
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
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:2194
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 247 of file cryptglue.c.

248 {
249 #ifdef USE_AUTOCRYPT
250  if (C_Autocrypt)
251  {
252  OptAutocryptGpgme = true;
253  int result = pgp_gpgme_encrypted_handler(a, s);
254  OptAutocryptGpgme = false;
255  if (result == 0)
256  {
257  a->is_autocrypt = true;
258  return result;
259  }
260  }
261 #endif
262 
263  if (CRYPT_MOD_CALL_CHECK(PGP, encrypted_handler))
264  return CRYPT_MOD_CALL(PGP, encrypted_handler)(a, s);
265 
266  return -1;
267 }
bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: config.c:37
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:33
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
int pgp_gpgme_encrypted_handler(struct Body *a, struct State *s)
Implements CryptModuleSpecs::encrypted_handler()
Definition: crypt_gpgme.c:3042
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 393 of file cryptglue.c.

394 {
395  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_extract_key_from_attachment))
396  CRYPT_MOD_CALL(PGP, pgp_extract_key_from_attachment)(fp, top);
397 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 272 of file cryptglue.c.

273 {
274  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_invoke_getkeys))
275  CRYPT_MOD_CALL(PGP, pgp_invoke_getkeys)(addr);
276 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 303 of file cryptglue.c.

304 {
305  if (CRYPT_MOD_CALL_CHECK(PGP, pgp_make_key_attachment))
306  return CRYPT_MOD_CALL(PGP, pgp_make_key_attachment)();
307 
308  return NULL;
309 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 382 of file cryptglue.c.

383 {
384  if (CRYPT_MOD_CALL_CHECK(PGP, send_menu))
385  return CRYPT_MOD_CALL(PGP, send_menu)(e);
386 
387  return 0;
388 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 444 of file cryptglue.c.

445 {
446  if (CRYPT_MOD_CALL_CHECK(SMIME, application_handler))
447  return CRYPT_MOD_CALL(SMIME, application_handler)(m, s);
448 
449  return -1;
450 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 431 of file cryptglue.c.

432 {
433  if (CRYPT_MOD_CALL_CHECK(SMIME, decrypt_mime))
434  return CRYPT_MOD_CALL(SMIME, decrypt_mime)(fp_in, fp_out, b, cur);
435 
436  return -1;
437 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 455 of file cryptglue.c.

456 {
457  if (CRYPT_MOD_CALL_CHECK(SMIME, smime_getkeys))
458  CRYPT_MOD_CALL(SMIME, smime_getkeys)(env);
459 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 528 of file cryptglue.c.

529 {
530  if (CRYPT_MOD_CALL_CHECK(SMIME, send_menu))
531  return CRYPT_MOD_CALL(SMIME, send_menu)(e);
532 
533  return 0;
534 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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 464 of file cryptglue.c.

465 {
466  if (CRYPT_MOD_CALL_CHECK(SMIME, smime_verify_sender))
467  return CRYPT_MOD_CALL(SMIME, smime_verify_sender)(m, e);
468 
469  return 1;
470 }
#define CRYPT_MOD_CALL(identifier, func)
Definition: cryptglue.c:85
#define CRYPT_MOD_CALL_CHECK(identifier, func)
Definition: cryptglue.c:79
+ 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:

◆ pgp_gpgme_init()

void pgp_gpgme_init ( void  )

Implements CryptModuleSpecs::init()

Definition at line 4130 of file crypt_gpgme.c.

4131 {
4132  init_common();
4133  init_pgp();
4134 }
static void init_common(void)
Initialise code common to PGP and SMIME parts of GPGME.
Definition: crypt_gpgme.c:4089
static void init_pgp(void)
Initialise the PGP crypto backend.
Definition: crypt_gpgme.c:4108
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_gpgme_select_secret_key()

int mutt_gpgme_select_secret_key ( struct Buffer keyid)

Select a private Autocrypt key for a new account.

Parameters
keyidAutocrypt Key id
Return values
0Success
-1Error

Unfortunately, the internal ncrypt/crypt_gpgme.c functions use CryptKeyInfo, and so aren't exportable.

This function queries all private keys, provides the crypt_select_keys() menu, and returns the selected key fingerprint in keyid.

Definition at line 3942 of file crypt_gpgme.c.

3943 {
3944  int rc = -1, junk;
3945  gpgme_error_t err;
3946  gpgme_key_t key = NULL;
3947  gpgme_user_id_t uid = NULL;
3948  struct CryptKeyInfo *results = NULL, *k = NULL;
3949  struct CryptKeyInfo **kend = NULL;
3950  struct CryptKeyInfo *choice = NULL;
3951 
3952  gpgme_ctx_t ctx = create_gpgme_context(false);
3953 
3954  /* list all secret keys */
3955  if (gpgme_op_keylist_start(ctx, NULL, 1))
3956  goto cleanup;
3957 
3958  kend = &results;
3959 
3960  while (!(err = gpgme_op_keylist_next(ctx, &key)))
3961  {
3963 
3965  flags |= KEYFLAG_CANENCRYPT;
3966  if (key_check_cap(key, KEY_CAP_CAN_SIGN))
3967  flags |= KEYFLAG_CANSIGN;
3968 
3969  if (key->revoked)
3970  flags |= KEYFLAG_REVOKED;
3971  if (key->expired)
3972  flags |= KEYFLAG_EXPIRED;
3973  if (key->disabled)
3974  flags |= KEYFLAG_DISABLED;
3975 
3976  int idx;
3977  for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3978  {
3979  k = mutt_mem_calloc(1, sizeof(*k));
3980  k->kobj = key;
3981  gpgme_key_ref(k->kobj);
3982  k->idx = idx;
3983  k->uid = uid->uid;
3984  k->flags = flags;
3985  if (uid->revoked)
3986  k->flags |= KEYFLAG_REVOKED;
3987  k->validity = uid->validity;
3988  *kend = k;
3989  kend = &k->next;
3990  }
3991  gpgme_key_unref(key);
3992  }
3993  if (gpg_err_code(err) != GPG_ERR_EOF)
3994  mutt_error(_("gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3995  gpgme_op_keylist_end(ctx);
3996 
3997  if (!results)
3998  {
3999  /* L10N: mutt_gpgme_select_secret_key() tries to list all secret keys to choose
4000  from. This error is displayed if no results were found. */
4001  mutt_error(_("No secret keys found"));
4002  goto cleanup;
4003  }
4004 
4005  choice = dlg_select_gpgme_key(results, NULL, "*", APPLICATION_PGP, &junk);
4006  if (!(choice && choice->kobj && choice->kobj->subkeys && choice->kobj->subkeys->fpr))
4007  goto cleanup;
4008  mutt_buffer_strcpy(keyid, choice->kobj->subkeys->fpr);
4009 
4010  rc = 0;
4011 
4012 cleanup:
4013  crypt_key_free(&choice);
4014  crypt_key_free(&results);
4015  gpgme_release(ctx);
4016  return rc;
4017 }
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
static void crypt_key_free(struct CryptKeyInfo **keylist)
Release all the keys in a list.
Definition: crypt_gpgme.c:461
struct CryptKeyInfo * dlg_select_gpgme_key(struct CryptKeyInfo *keys, struct Address *p, const char *s, unsigned int app, int *forced_valid)
Get the user to select a key.
Definition: dlggpgme.c:1196
#define _(a)
Definition: message.h:28
Key can be used for encryption.
Definition: crypt_gpgme.h:76
Key can be used for signing.
Definition: crypt_gpgme.h:77
struct CryptKeyInfo * next
Definition: crypt_gpgme.h:45
#define KEYFLAG_CANENCRYPT
Key is suitable for encryption.
Definition: lib.h:135
A stored PGP key.
Definition: crypt_gpgme.h:43
int idx
and the user ID at this index
Definition: crypt_gpgme.h:47
#define KEYFLAG_EXPIRED
Key is expired.
Definition: lib.h:138
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
#define KEYFLAG_NO_FLAGS
No flags are set.
Definition: lib.h:133
gpgme_ctx_t create_gpgme_context(bool for_smime)
Create a new GPGME context.
Definition: crypt_gpgme.c:570
uint16_t KeyFlags
Flags describing PGP/SMIME keys, e.g. KEYFLAG_CANSIGN.
Definition: lib.h:132
gpgme_key_t kobj
Definition: crypt_gpgme.h:46
unsigned int key_check_cap(gpgme_key_t key, enum KeyCap cap)
Check the capabilities of a key.
Definition: crypt_gpgme.c:3237
#define KEYFLAG_DISABLED
Key is marked disabled.
Definition: lib.h:140
#define KEYFLAG_CANSIGN
Key is suitable for signing.
Definition: lib.h:134
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
KeyFlags flags
global and per uid flags (for convenience)
Definition: crypt_gpgme.h:49
#define mutt_error(...)
Definition: logging.h:84
#define KEYFLAG_REVOKED
Key is revoked.
Definition: lib.h:139
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_gpgme_print_version()

const char* mutt_gpgme_print_version ( void  )

Get version of GPGME.

Return values
ptrGPGME version string

Definition at line 4425 of file crypt_gpgme.c.

4426 {
4427  return GPGME_VERSION;
4428 }
+ Here is the caller graph for this function:

Variable Documentation

◆ C_CryptOpportunisticEncrypt

bool C_CryptOpportunisticEncrypt

Config: Enable encryption when the recipient's key is available.

Definition at line 56 of file config.c.

◆ C_CryptProtectedHeadersRead

bool C_CryptProtectedHeadersRead

Config: Display protected headers (Memory Hole) in the pager.

Definition at line 58 of file config.c.

◆ C_CryptProtectedHeadersSave

bool C_CryptProtectedHeadersSave

Config: Save the cleartext Subject with the headers.

Definition at line 59 of file config.c.

◆ C_CryptVerifySig

unsigned char C_CryptVerifySig

Config: Verify PGP or SMIME signatures.

Definition at line 123 of file config.c.

◆ C_PgpAutoDecode

bool C_PgpAutoDecode

Config: Automatically decrypt PGP messages.

Definition at line 122 of file config.c.

◆ C_PgpSignAs

char* C_PgpSignAs

Config: Use this alternative key for signing messages.

Definition at line 67 of file config.c.

◆ C_SmimeEncryptWith

char* C_SmimeEncryptWith

Config: Algorithm for encryption.

Definition at line 71 of file config.c.

◆ C_SmimeIsDefault

bool C_SmimeIsDefault

Config: Use SMIME rather than PGP by default.

Definition at line 61 of file config.c.

◆ C_SmimeSignAs

char* C_SmimeSignAs

Config: Use this alternative key for signing messages.

Definition at line 70 of file config.c.