X-Git-Url: http://git.madism.org/?a=blobdiff_plain;f=lib-crypt%2Fcryptglue.c;fp=lib-crypt%2Fcryptglue.c;h=151cbad867c3365b7cf78c39e23096ad7ee83649;hb=4761fa78a6dfc9437caa6e6e0aac806e50e01c83;hp=0000000000000000000000000000000000000000;hpb=b8c71f93b0296f815a6538182343ba67e88c0012;p=apps%2Fmadmutt.git diff --git a/lib-crypt/cryptglue.c b/lib-crypt/cryptglue.c new file mode 100644 index 0000000..151cbad --- /dev/null +++ b/lib-crypt/cryptglue.c @@ -0,0 +1,363 @@ +/* + * Copyright notice from original mutt: + * Copyright (C) 2003 Werner Koch + * Copyright (C) 2004 g10 Code GmbH + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ + +/* + 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 + +#include "mutt.h" +#include "crypt.h" + + +#include "crypt-mod.h" + +/* + Generic +*/ + +extern struct crypt_module_specs crypt_mod_pgp_classic; +extern struct crypt_module_specs crypt_mod_smime_classic; + +#ifdef CRYPT_BACKEND_GPGME +extern struct crypt_module_specs crypt_mod_pgp_gpgme; +extern struct crypt_module_specs crypt_mod_smime_gpgme; +#endif + +void crypt_init (void) +{ + if ( +#ifdef CRYPT_BACKEND_GPGME + (!option (OPTCRYPTUSEGPGME)) +#else + 1 +#endif + ) + crypto_module_register (&crypt_mod_pgp_classic); + + if ( +#ifdef CRYPT_BACKEND_GPGME + (!option (OPTCRYPTUSEGPGME)) +#else + 1 +#endif + ) + crypto_module_register (&crypt_mod_smime_classic); + + 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 build with GPGME support.")); + if (mutt_any_key_to_continue (NULL) == -1) + mutt_exit (1); +#endif + } + +#if defined CRYPT_BACKEND_CLASSIG_PGP || defined CRYPT_BACKEND_CLASSIG_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 +} + + +/* Show a message that a backend will be invoked. */ +void crypt_invoke_message (int type) +{ + if (type & APPLICATION_PGP) { + mutt_message _("Invoking PGP..."); + } + else if (type & APPLICATION_SMIME) { + mutt_message _("Invoking S/MIME..."); + } +} + + + +/* + + 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) +{ + 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) +{ + 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_t * 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 tagged_only) +{ + if (CRYPT_MOD_CALL_CHECK (PGP, pgp_check_traditional)) + return (CRYPT_MOD_CALL (PGP, pgp_check_traditional)) (fp, b, tagged_only); + + 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 (char *tempf) +{ + if (CRYPT_MOD_CALL_CHECK (PGP, pgp_make_key_attachment)) + return (CRYPT_MOD_CALL (PGP, pgp_make_key_attachment)) (tempf); + + 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. */ +char *crypt_pgp_findkeys (address_t * to, address_t * cc, address_t * bcc) +{ + if (CRYPT_MOD_CALL_CHECK (PGP, findkeys)) + return (CRYPT_MOD_CALL (PGP, findkeys)) (to, cc, bcc); + + 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 (BODY * a, char *keylist, int sign) +{ + 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; +} + + +int crypt_pgp_send_menu (HEADER * msg, int *redraw) +{ + if (CRYPT_MOD_CALL_CHECK (PGP, send_menu)) + return (CRYPT_MOD_CALL (PGP, send_menu)) (msg, redraw); + + return 0; +} + + +/* 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); +} + + + +/* + + 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. */ +int crypt_smime_encrypted_handler (BODY * a, STATE * s) +{ + if (CRYPT_MOD_CALL_CHECK (SMIME, encrypted_handler)) + return (CRYPT_MOD_CALL (SMIME, encrypted_handler)) (a, s); + return (-1); +} + +/* 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. */ +char *crypt_smime_findkeys (address_t * to, address_t * cc, address_t * bcc) +{ + if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys)) + return (CRYPT_MOD_CALL (SMIME, findkeys)) (to, cc, bcc); + + 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 (char *infile, 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; +} + +int crypt_smime_send_menu (HEADER * msg, int *redraw) +{ + if (CRYPT_MOD_CALL_CHECK (SMIME, send_menu)) + return (CRYPT_MOD_CALL (SMIME, send_menu)) (msg, redraw); + + return 0; +}