notmuch/util/crypto.h

#ifndef _CRYPTO_H
#define _CRYPTO_H

#include <stdbool.h>
#include "gmime-extra.h"
#include "notmuch.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct _notmuch_crypto {
    bool verify;
    notmuch_decryption_policy_t decrypt;
#if (GMIME_MAJOR_VERSION < 3)
    GMimeCryptoContext* gpgctx;
    GMimeCryptoContext* pkcs7ctx;
    const char *gpgpath;
#endif
} _notmuch_crypto_t;

GMimeObject *
_notmuch_crypto_decrypt (bool *attempted,
			 notmuch_decryption_policy_t decrypt,
			 notmuch_message_t *message,
			 GMimeCryptoContext* crypto_ctx,
			 GMimeMultipartEncrypted *part,
			 GMimeDecryptResult **decrypt_result,
			 GError **err);

#if (GMIME_MAJOR_VERSION < 3)
notmuch_status_t
_notmuch_crypto_get_gmime_ctx_for_protocol (_notmuch_crypto_t *crypto,
					    const char *protocol,
					    GMimeCryptoContext **ctx);
#endif

void
_notmuch_crypto_cleanup (_notmuch_crypto_t *crypto);

#ifdef __cplusplus
}
#endif
#endif
crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00			`#ifndef _CRYPTO_H`
			`#define _CRYPTO_H`

			`#include <stdbool.h>`
			`#include "gmime-extra.h"`
crypto: make shared crypto code behave library-like If we're going to reuse the crypto code across both the library and the client, then it needs to report error states properly and not write to stderr. 2017-10-17 21:09:56 +02:00			`#include "notmuch.h"`
crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00
util: make remaining headers includable from C++ libnotmuch_util.a is supposed to be usable from the library and the CLI, but much the library is compiled as C++. Add in appropriate wrapping to prevent symbol mangling. These wrappers already existed in string-util.h; it seems better to be consistent. 2019-03-02 21:26:06 +01:00			`#ifdef __cplusplus`
			`extern "C" {`
			`#endif`

crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00			`typedef struct _notmuch_crypto {`
			`bool verify;`
lib: convert notmuch decryption policy to an enum Future patches in this series will introduce new policies; this merely readies the way for them. We also convert --try-decrypt to a keyword argument instead of a boolean. 2017-12-08 07:23:52 +01:00			`notmuch_decryption_policy_t decrypt;`
crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00			`#if (GMIME_MAJOR_VERSION < 3)`
			`GMimeCryptoContext* gpgctx;`
			`GMimeCryptoContext* pkcs7ctx;`
			`const char *gpgpath;`
			`#endif`
			`} _notmuch_crypto_t;`

crypto: add _notmuch_crypto_decrypt wrapper function We will use this centralized function to consolidate the awkward behavior around different gmime versions. It's only invoked from two places: mime-node.c's node_decrypt_and_verify() and lib/index.cc's _index_encrypted_mime_part(). However, those two places have some markedly distinct logic, so the interface for this _notmuch_crypto_decrypt function is going to get a little bit clunky. It's worthwhile, though, for the sake of keeping these #if directives reasonably well-contained. 2017-11-30 09:59:27 +01:00			`GMimeObject *`
crypto: record whether an actual decryption attempt happened In our consolidation of _notmuch_crypto_decrypt, the callers lost track a little bit of whether any actual decryption was attempted. Now that we have the more-subtle "auto" policy, it's possible that _notmuch_crypto_decrypt could be called without having any actual decryption take place. This change lets the callers be a little bit smarter about whether or not any decryption was actually attempted. 2017-12-08 07:23:58 +01:00			`_notmuch_crypto_decrypt (bool *attempted,`
			`notmuch_decryption_policy_t decrypt,`
crypto: new decryption policy "auto" This new automatic decryption policy should make it possible to decrypt messages that we have stashed session keys for, without incurring a call to the user's asymmetric keys. 2017-12-08 07:23:53 +01:00			`notmuch_message_t *message,`
crypto: use stashed session-key properties for decryption, if available When doing any decryption, if the notmuch database knows of any session keys associated with the message in question, try them before defaulting to using default symmetric crypto. This changeset does the primary work in _notmuch_crypto_decrypt, which grows some new parameters to handle it. The primary advantage this patch offers is a significant speedup when rendering large encrypted threads ("notmuch show") if session keys happen to be cached. Additionally, it permits message composition without access to asymmetric secret keys ("notmuch reply"); and it permits recovering a cleartext index when reindexing after a "notmuch restore" for those messages that already have a session key stored. Note that we may try multiple decryptions here (e.g. if there are multiple session keys in the database), but we will ignore and throw away all the GMime errors except for those that come from last decryption attempt. Since we don't necessarily know at the time of the decryption that this is the last decryption attempt, we'll ask for the errors each time anyway. This does nothing if no session keys are stashed in the database, which is fine. Actually stashing session keys in the database will come as a subsequent patch. 2017-11-30 09:59:29 +01:00			`GMimeCryptoContext* crypto_ctx,`
crypto: add _notmuch_crypto_decrypt wrapper function We will use this centralized function to consolidate the awkward behavior around different gmime versions. It's only invoked from two places: mime-node.c's node_decrypt_and_verify() and lib/index.cc's _index_encrypted_mime_part(). However, those two places have some markedly distinct logic, so the interface for this _notmuch_crypto_decrypt function is going to get a little bit clunky. It's worthwhile, though, for the sake of keeping these #if directives reasonably well-contained. 2017-11-30 09:59:27 +01:00			`GMimeMultipartEncrypted *part,`
			`GMimeDecryptResult **decrypt_result,`
			`GError **err);`
crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00
			`#if (GMIME_MAJOR_VERSION < 3)`
crypto: make shared crypto code behave library-like If we're going to reuse the crypto code across both the library and the client, then it needs to report error states properly and not write to stderr. 2017-10-17 21:09:56 +02:00			`notmuch_status_t`
			`_notmuch_crypto_get_gmime_ctx_for_protocol (_notmuch_crypto_t *crypto,`
			`const char *protocol,`
			`GMimeCryptoContext **ctx);`
crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00			`#endif`

			`void`
			`_notmuch_crypto_cleanup (_notmuch_crypto_t *crypto);`

util: make remaining headers includable from C++ libnotmuch_util.a is supposed to be usable from the library and the CLI, but much the library is compiled as C++. Add in appropriate wrapping to prevent symbol mangling. These wrappers already existed in string-util.h; it seems better to be consistent. 2019-03-02 21:26:06 +01:00			`#ifdef __cplusplus`
			`}`
			`#endif`
crypto: move into libnotmuch_util This prepares us for using the crypto object in both libnotmuch and the client. 2017-10-17 21:09:55 +02:00			`#endif`