/*
* Copyright (C) 2003 Werner Koch <wk@gnupg.org>
* Copyright (C) 2004 g10 Code GmbH
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
/*
This file dispatches the generic crypto functions to the
implemented backend or provides dummy stubs. Note, that some
generic functions are handled in crypt.c.
*/
/* Note: This file has been changed to make use of the new module
system. Consequently there's a 1:1 mapping between the functions
contained in this file and the functions implemented by the crypto
modules. */
#if HAVE_CONFIG_H
# include "config.h"
#endif
#include "mutt.h"
#include "mutt_crypt.h"
#include "crypt-mod.h"
#ifdef USE_AUTOCRYPT
#include "autocrypt.h"
#endif
/*
Generic
*/
#ifdef CRYPT_BACKEND_CLASSIC_PGP
extern struct crypt_module_specs crypt_mod_pgp_classic;
#endif
#ifdef CRYPT_BACKEND_CLASSIC_SMIME
extern struct crypt_module_specs crypt_mod_smime_classic;
#endif
#ifdef CRYPT_BACKEND_GPGME
#include "crypt-gpgme.h"
extern struct crypt_module_specs crypt_mod_pgp_gpgme;
extern struct crypt_module_specs crypt_mod_smime_gpgme;
#endif
void crypt_init (void)
{
#ifdef CRYPT_BACKEND_CLASSIC_PGP
if (
#ifdef CRYPT_BACKEND_GPGME
(! option (OPTCRYPTUSEGPGME))
#else
1
#endif
)
crypto_module_register (&crypt_mod_pgp_classic);
#endif
#ifdef CRYPT_BACKEND_CLASSIC_SMIME
if (
#ifdef CRYPT_BACKEND_GPGME
(! option (OPTCRYPTUSEGPGME))
#else
1
#endif
)
crypto_module_register (&crypt_mod_smime_classic);
#endif
if (option (OPTCRYPTUSEGPGME))
{
#ifdef CRYPT_BACKEND_GPGME
crypto_module_register (&crypt_mod_pgp_gpgme);
crypto_module_register (&crypt_mod_smime_gpgme);
#else
mutt_message (_("\"crypt_use_gpgme\" set"
" but not built with GPGME support."));
if (mutt_any_key_to_continue (NULL) == -1)
mutt_exit(1);
#endif
}
#if defined CRYPT_BACKEND_CLASSIC_PGP || defined CRYPT_BACKEND_CLASSIC_SMIME || defined CRYPT_BACKEND_GPGME
if (CRYPT_MOD_CALL_CHECK (PGP, init))
(CRYPT_MOD_CALL (PGP, init)) ();
if (CRYPT_MOD_CALL_CHECK (SMIME, init))
(CRYPT_MOD_CALL (SMIME, init)) ();
#endif
}
void crypt_cleanup (void)
{
if (CRYPT_MOD_CALL_CHECK (PGP, cleanup))
(CRYPT_MOD_CALL (PGP, cleanup)) ();
if (CRYPT_MOD_CALL_CHECK (SMIME, cleanup))
(CRYPT_MOD_CALL (SMIME, cleanup)) ();
}
/* Show a message that a backend will be invoked. */
void crypt_invoke_message (int type)
{
if ((WithCrypto & APPLICATION_PGP) && (type & APPLICATION_PGP))
mutt_message _("Invoking PGP...");
else if ((WithCrypto & APPLICATION_SMIME) && (type & APPLICATION_SMIME))
mutt_message _("Invoking S/MIME...");
}
/* Returns 1 if a module backend is registered for the type */
int crypt_has_module_backend (int type)
{
if ((WithCrypto & APPLICATION_PGP) &&
(type & APPLICATION_PGP) &&
crypto_module_lookup (APPLICATION_PGP))
return 1;
if ((WithCrypto & APPLICATION_SMIME) &&
(type & APPLICATION_SMIME) &&
crypto_module_lookup (APPLICATION_SMIME))
return 1;
return 0;
}
/*
PGP
*/
/* Reset a PGP passphrase */
void crypt_pgp_void_passphrase (void)
{
if (CRYPT_MOD_CALL_CHECK (PGP, void_passphrase))
(CRYPT_MOD_CALL (PGP, void_passphrase)) ();
}
int crypt_pgp_valid_passphrase (void)
{
if (CRYPT_MOD_CALL_CHECK (PGP, valid_passphrase))
return (CRYPT_MOD_CALL (PGP, valid_passphrase)) ();
return 0;
}
/* Decrypt a PGP/MIME message. */
int crypt_pgp_decrypt_mime (FILE *a, FILE **b, BODY *c, BODY **d)
{
#ifdef USE_AUTOCRYPT
int result;
if (option (OPTAUTOCRYPT))
{
set_option (OPTAUTOCRYPTGPGME);
result = pgp_gpgme_decrypt_mime (a, b, c, d);
unset_option (OPTAUTOCRYPTGPGME);
if (result == 0)
{
c->is_autocrypt = 1;
return result;
}
}
#endif
if (CRYPT_MOD_CALL_CHECK (PGP, decrypt_mime))
return (CRYPT_MOD_CALL (PGP, decrypt_mime)) (a, b, c, d);
return -1;
}
/* MIME handler for the application/pgp content-type. */
int crypt_pgp_application_pgp_handler (BODY *m, STATE *s)
{
if (CRYPT_MOD_CALL_CHECK (PGP, application_handler))
return (CRYPT_MOD_CALL (PGP, application_handler)) (m, s);
return -1;
}
/* MIME handler for an PGP/MIME encrypted message. */
int crypt_pgp_encrypted_handler (BODY *a, STATE *s)
{
#ifdef USE_AUTOCRYPT
int result;
if (option (OPTAUTOCRYPT))
{
set_option (OPTAUTOCRYPTGPGME);
result = pgp_gpgme_encrypted_handler (a, s);
unset_option (OPTAUTOCRYPTGPGME);
if (result == 0)
{
a->is_autocrypt = 1;
return result;
}
}
#endif
if (CRYPT_MOD_CALL_CHECK (PGP, encrypted_handler))
return (CRYPT_MOD_CALL (PGP, encrypted_handler)) (a, s);
return -1;
}
/* fixme: needs documentation. */
void crypt_pgp_invoke_getkeys (ADDRESS *addr)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_getkeys))
(CRYPT_MOD_CALL (PGP, pgp_invoke_getkeys)) (addr);
}
/* Check for a traditional PGP message in body B. */
int crypt_pgp_check_traditional (FILE *fp, BODY *b, int just_one)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_check_traditional))
return (CRYPT_MOD_CALL (PGP, pgp_check_traditional)) (fp, b, just_one);
return 0;
}
/* fixme: needs documentation. */
BODY *crypt_pgp_traditional_encryptsign (BODY *a, int flags, char *keylist)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_traditional_encryptsign))
return (CRYPT_MOD_CALL (PGP, pgp_traditional_encryptsign)) (a, flags, keylist);
return NULL;
}
/* Generate a PGP public key attachment. */
BODY *crypt_pgp_make_key_attachment (void)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_make_key_attachment))
return (CRYPT_MOD_CALL (PGP, pgp_make_key_attachment)) ();
return NULL;
}
/* This routine attempts to find the keyids of the recipients of a
message. It returns NULL if any of the keys can not be found.
If oppenc_mode is true, only keys that can be determined without
prompting will be used. */
char *crypt_pgp_findkeys (ADDRESS *adrlist, int oppenc_mode)
{
if (CRYPT_MOD_CALL_CHECK (PGP, findkeys))
return (CRYPT_MOD_CALL (PGP, findkeys)) (adrlist, oppenc_mode);
return NULL;
}
/* Create a new body with a PGP signed message from A. */
BODY *crypt_pgp_sign_message (BODY *a)
{
if (CRYPT_MOD_CALL_CHECK (PGP, sign_message))
return (CRYPT_MOD_CALL (PGP, sign_message)) (a);
return NULL;
}
/* Warning: A is no longer freed in this routine, you need to free it
later. This is necessary for $fcc_attach. */
BODY *crypt_pgp_encrypt_message (HEADER *msg, BODY *a, char *keylist, int sign)
{
#ifdef USE_AUTOCRYPT
BODY *result;
if (msg->security & AUTOCRYPT)
{
if (mutt_autocrypt_set_sign_as_default_key (msg))
return NULL;
set_option (OPTAUTOCRYPTGPGME);
result = pgp_gpgme_encrypt_message (a, keylist, sign);
unset_option (OPTAUTOCRYPTGPGME);
return result;
}
#endif
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_encrypt_message))
return (CRYPT_MOD_CALL (PGP, pgp_encrypt_message)) (a, keylist, sign);
return NULL;
}
/* Invoke the PGP command to import a key. */
void crypt_pgp_invoke_import (const char *fname)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_import))
(CRYPT_MOD_CALL (PGP, pgp_invoke_import)) (fname);
}
/* fixme: needs documentation */
int crypt_pgp_verify_one (BODY *sigbdy, STATE *s, const char *tempf)
{
if (CRYPT_MOD_CALL_CHECK (PGP, verify_one))
return (CRYPT_MOD_CALL (PGP, verify_one)) (sigbdy, s, tempf);
return -1;
}
void crypt_pgp_send_menu (SEND_CONTEXT *sctx)
{
if (CRYPT_MOD_CALL_CHECK (PGP, send_menu))
(CRYPT_MOD_CALL (PGP, send_menu)) (sctx);
}
/* fixme: needs documentation */
void crypt_pgp_extract_keys_from_attachment_list (FILE *fp, int tag, BODY *top)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_extract_keys_from_attachment_list))
(CRYPT_MOD_CALL (PGP, pgp_extract_keys_from_attachment_list)) (fp, tag, top);
}
void crypt_pgp_set_sender (const char *sender)
{
if (CRYPT_MOD_CALL_CHECK (PGP, set_sender))
(CRYPT_MOD_CALL (PGP, set_sender)) (sender);
}
/*
S/MIME
*/
/* Reset an SMIME passphrase */
void crypt_smime_void_passphrase (void)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, void_passphrase))
(CRYPT_MOD_CALL (SMIME, void_passphrase)) ();
}
int crypt_smime_valid_passphrase (void)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, valid_passphrase))
return (CRYPT_MOD_CALL (SMIME, valid_passphrase)) ();
return 0;
}
/* Decrypt am S/MIME message. */
int crypt_smime_decrypt_mime (FILE *a, FILE **b, BODY *c, BODY **d)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, decrypt_mime))
return (CRYPT_MOD_CALL (SMIME, decrypt_mime)) (a, b, c, d);
return -1;
}
/* MIME handler for the application/smime content-type. */
int crypt_smime_application_smime_handler (BODY *m, STATE *s)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, application_handler))
return (CRYPT_MOD_CALL (SMIME, application_handler)) (m, s);
return -1;
}
/* MIME handler for an PGP/MIME encrypted message. */
void crypt_smime_encrypted_handler (BODY *a, STATE *s)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, encrypted_handler))
(CRYPT_MOD_CALL (SMIME, encrypted_handler)) (a, s);
}
/* fixme: Needs documentation. */
void crypt_smime_getkeys (ENVELOPE *env)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, smime_getkeys))
(CRYPT_MOD_CALL (SMIME, smime_getkeys)) (env);
}
/* Check that the sender matches. */
int crypt_smime_verify_sender(HEADER *h)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, smime_verify_sender))
return (CRYPT_MOD_CALL (SMIME, smime_verify_sender)) (h);
return 1;
}
/* This routine attempts to find the keyids of the recipients of a
message. It returns NULL if any of the keys can not be found.
If oppenc_mode is true, only keys that can be determined without
prompting will be used. */
char *crypt_smime_findkeys (ADDRESS *adrlist, int oppenc_mode)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys))
return (CRYPT_MOD_CALL (SMIME, findkeys)) (adrlist, oppenc_mode);
return NULL;
}
/* fixme: Needs documentation. */
BODY *crypt_smime_sign_message (BODY *a)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, sign_message))
return (CRYPT_MOD_CALL (SMIME, sign_message)) (a);
return NULL;
}
/* fixme: needs documentation. */
BODY *crypt_smime_build_smime_entity (BODY *a, char *certlist)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, smime_build_smime_entity))
return (CRYPT_MOD_CALL (SMIME, smime_build_smime_entity)) (a, certlist);
return NULL;
}
/* Add a certificate and update index file (externally). */
void crypt_smime_invoke_import (const char *infile, const char *mailbox)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, smime_invoke_import))
(CRYPT_MOD_CALL (SMIME, smime_invoke_import)) (infile, mailbox);
}
/* fixme: needs documentation */
int crypt_smime_verify_one (BODY *sigbdy, STATE *s, const char *tempf)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, verify_one))
return (CRYPT_MOD_CALL (SMIME, verify_one)) (sigbdy, s, tempf);
return -1;
}
void crypt_smime_send_menu (SEND_CONTEXT *sctx)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, send_menu))
(CRYPT_MOD_CALL (SMIME, send_menu)) (sctx);
}
void crypt_smime_set_sender (const char *sender)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, set_sender))
(CRYPT_MOD_CALL (SMIME, set_sender)) (sender);
}
