cryptglue.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 2003  Werner Koch <wk@gnupg.org>
   4  * Copyright (C) 2004 g10 Code GmbH
   5  *
   6  * This file is part of mutt-ng, see http://www.muttng.org/.
   7  * It's licensed under the GNU General Public License,
   8  * please see the file GPL in the top level source directory.
   9  */
  10
  11 /*
  12    This file dispatches the generic crypto functions to the
  13    implemented backend or provides dummy stubs.  Note, that some
  14    generic functions are handled in crypt.c.
  15 */
  16
  17 /* Note: This file has been changed to make use of the new module
  18    system.  Consequently there's a 1:1 mapping between the functions
  19    contained in this file and the functions implemented by the crypto
  20    modules.  */
  21
  22 #if HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include "mutt.h"
  27 #include "mutt_crypt.h"
  28
  29 #include "lib/intl.h"
  30
  31 #include "crypt-mod.h"
  32
  33 /*
  34
  35     Generic
  36
  37 */
  38
  39 #ifdef CRYPT_BACKEND_CLASSIC_PGP
  40 extern struct crypt_module_specs crypt_mod_pgp_classic;
  41 #endif
  42
  43 #ifdef CRYPT_BACKEND_CLASSIC_SMIME
  44 extern struct crypt_module_specs crypt_mod_smime_classic;
  45 #endif
  46
  47 #ifdef CRYPT_BACKEND_GPGME
  48 extern struct crypt_module_specs crypt_mod_pgp_gpgme;
  49 extern struct crypt_module_specs crypt_mod_smime_gpgme;
  50 #endif
  51
  52 void crypt_init (void)
  53 {
  54 #ifdef CRYPT_BACKEND_CLASSIC_PGP
  55   if (
  56 #ifdef CRYPT_BACKEND_GPGME
  57        (!option (OPTCRYPTUSEGPGME))
  58 #else
  59        1
  60 #endif
  61     )
  62     crypto_module_register (&crypt_mod_pgp_classic);
  63 #endif
  64
  65 #ifdef CRYPT_BACKEND_CLASSIC_SMIME
  66   if (
  67 #ifdef CRYPT_BACKEND_GPGME
  68        (!option (OPTCRYPTUSEGPGME))
  69 #else
  70        1
  71 #endif
  72     )
  73     crypto_module_register (&crypt_mod_smime_classic);
  74 #endif
  75
  76   if (option (OPTCRYPTUSEGPGME)) {
  77 #ifdef CRYPT_BACKEND_GPGME
  78     crypto_module_register (&crypt_mod_pgp_gpgme);
  79     crypto_module_register (&crypt_mod_smime_gpgme);
  80 #else
  81     mutt_message (_("\"crypt_use_gpgme\" set"
  82                     " but not build with GPGME support."));
  83     if (mutt_any_key_to_continue (NULL) == -1)
  84       mutt_exit (1);
  85 #endif
  86   }
  87
  88 #if defined CRYPT_BACKEND_CLASSIG_PGP || defined CRYPT_BACKEND_CLASSIG_SMIME || defined CRYPT_BACKEND_GPGME
  89   if (CRYPT_MOD_CALL_CHECK (PGP, init))
  90     (CRYPT_MOD_CALL (PGP, init)) ();
  91
  92   if (CRYPT_MOD_CALL_CHECK (SMIME, init))
  93     (CRYPT_MOD_CALL (SMIME, init)) ();
  94 #endif
  95 }
  96
  97
  98 /* Show a message that a backend will be invoked. */
  99 void crypt_invoke_message (int type)
 100 {
 101   if ((WithCrypto & APPLICATION_PGP) && (type & APPLICATION_PGP)) {
 102     mutt_message _("Invoking PGP...");
 103   }
 104   else if ((WithCrypto & APPLICATION_SMIME) && (type & APPLICATION_SMIME)) {
 105     mutt_message _("Invoking SMIME...");
 106   }
 107 }
 108 \f
 109
 110
 111 /*
 112
 113     PGP
 114
 115 */
 116
 117
 118 /* Reset a PGP passphrase */
 119 void crypt_pgp_void_passphrase (void)
 120 {
 121   if (CRYPT_MOD_CALL_CHECK (PGP, void_passphrase))
 122     (CRYPT_MOD_CALL (PGP, void_passphrase)) ();
 123 }
 124
 125 int crypt_pgp_valid_passphrase (void)
 126 {
 127   if (CRYPT_MOD_CALL_CHECK (PGP, valid_passphrase))
 128     return (CRYPT_MOD_CALL (PGP, valid_passphrase)) ();
 129
 130   return 0;
 131 }
 132
 133
 134 /* Decrypt a PGP/MIME message. */
 135 int crypt_pgp_decrypt_mime (FILE * a, FILE ** b, BODY * c, BODY ** d)
 136 {
 137   if (CRYPT_MOD_CALL_CHECK (PGP, decrypt_mime))
 138     return (CRYPT_MOD_CALL (PGP, decrypt_mime)) (a, b, c, d);
 139
 140   return -1;
 141 }
 142
 143 /* MIME handler for the application/pgp content-type. */
 144 int crypt_pgp_application_pgp_handler (BODY * m, STATE * s)
 145 {
 146   if (CRYPT_MOD_CALL_CHECK (PGP, application_handler))
 147     return (CRYPT_MOD_CALL (PGP, application_handler)) (m, s);
 148   return (-1);
 149 }
 150
 151 /* MIME handler for an PGP/MIME encrypted message. */
 152 int crypt_pgp_encrypted_handler (BODY * a, STATE * s)
 153 {
 154   if (CRYPT_MOD_CALL_CHECK (PGP, encrypted_handler))
 155     return (CRYPT_MOD_CALL (PGP, encrypted_handler)) (a, s);
 156   return (-1);
 157 }
 158
 159 /* fixme: needs documentation. */
 160 void crypt_pgp_invoke_getkeys (ADDRESS * addr)
 161 {
 162   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_getkeys))
 163     (CRYPT_MOD_CALL (PGP, pgp_invoke_getkeys)) (addr);
 164 }
 165
 166 /* Check for a traditional PGP message in body B. */
 167 int crypt_pgp_check_traditional (FILE * fp, BODY * b, int tagged_only)
 168 {
 169   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_check_traditional))
 170     return (CRYPT_MOD_CALL (PGP, pgp_check_traditional)) (fp, b, tagged_only);
 171
 172   return 0;
 173 }
 174
 175 /* fixme: needs documentation. */
 176 BODY *crypt_pgp_traditional_encryptsign (BODY * a, int flags, char *keylist)
 177 {
 178   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_traditional_encryptsign))
 179     return (CRYPT_MOD_CALL (PGP, pgp_traditional_encryptsign)) (a, flags,
 180                                                                 keylist);
 181
 182   return NULL;
 183 }
 184
 185 /* Generate a PGP public key attachment. */
 186 BODY *crypt_pgp_make_key_attachment (char *tempf)
 187 {
 188   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_make_key_attachment))
 189     return (CRYPT_MOD_CALL (PGP, pgp_make_key_attachment)) (tempf);
 190
 191   return NULL;
 192 }
 193
 194 /* This routine attempts to find the keyids of the recipients of a
 195    message.  It returns NULL if any of the keys can not be found.  */
 196 char *crypt_pgp_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
 197 {
 198   if (CRYPT_MOD_CALL_CHECK (PGP, findkeys))
 199     return (CRYPT_MOD_CALL (PGP, findkeys)) (to, cc, bcc);
 200
 201   return NULL;
 202 }
 203
 204 /* Create a new body with a PGP signed message from A. */
 205 BODY *crypt_pgp_sign_message (BODY * a)
 206 {
 207   if (CRYPT_MOD_CALL_CHECK (PGP, sign_message))
 208     return (CRYPT_MOD_CALL (PGP, sign_message)) (a);
 209
 210   return NULL;
 211 }
 212
 213 /* Warning: A is no longer freed in this routine, you need to free it
 214    later.  This is necessary for $fcc_attach. */
 215 BODY *crypt_pgp_encrypt_message (BODY * a, char *keylist, int sign)
 216 {
 217   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_encrypt_message))
 218     return (CRYPT_MOD_CALL (PGP, pgp_encrypt_message)) (a, keylist, sign);
 219
 220   return NULL;
 221 }
 222
 223 /* Invoke the PGP command to import a key. */
 224 void crypt_pgp_invoke_import (const char *fname)
 225 {
 226   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_import))
 227     (CRYPT_MOD_CALL (PGP, pgp_invoke_import)) (fname);
 228 }
 229
 230 /* fixme: needs documentation */
 231 int crypt_pgp_verify_one (BODY * sigbdy, STATE * s, const char *tempf)
 232 {
 233   if (CRYPT_MOD_CALL_CHECK (PGP, verify_one))
 234     return (CRYPT_MOD_CALL (PGP, verify_one)) (sigbdy, s, tempf);
 235
 236   return -1;
 237 }
 238
 239
 240 int crypt_pgp_send_menu (HEADER * msg, int *redraw)
 241 {
 242   if (CRYPT_MOD_CALL_CHECK (PGP, send_menu))
 243     return (CRYPT_MOD_CALL (PGP, send_menu)) (msg, redraw);
 244
 245   return 0;
 246 }
 247
 248
 249 /* fixme: needs documentation */
 250 void crypt_pgp_extract_keys_from_attachment_list (FILE * fp, int tag,
 251                                                   BODY * top)
 252 {
 253   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_extract_keys_from_attachment_list))
 254     (CRYPT_MOD_CALL (PGP, pgp_extract_keys_from_attachment_list)) (fp, tag,
 255                                                                    top);
 256 }
 257 \f
 258
 259
 260 /*
 261
 262    S/MIME
 263
 264 */
 265
 266
 267 /* Reset an SMIME passphrase */
 268 void crypt_smime_void_passphrase (void)
 269 {
 270   if (CRYPT_MOD_CALL_CHECK (SMIME, void_passphrase))
 271     (CRYPT_MOD_CALL (SMIME, void_passphrase)) ();
 272 }
 273
 274 int crypt_smime_valid_passphrase (void)
 275 {
 276   if (CRYPT_MOD_CALL_CHECK (SMIME, valid_passphrase))
 277     return (CRYPT_MOD_CALL (SMIME, valid_passphrase)) ();
 278
 279   return 0;
 280 }
 281
 282 /* Decrypt am S/MIME message. */
 283 int crypt_smime_decrypt_mime (FILE * a, FILE ** b, BODY * c, BODY ** d)
 284 {
 285   if (CRYPT_MOD_CALL_CHECK (SMIME, decrypt_mime))
 286     return (CRYPT_MOD_CALL (SMIME, decrypt_mime)) (a, b, c, d);
 287
 288   return -1;
 289 }
 290
 291 /* MIME handler for the application/smime content-type. */
 292 int crypt_smime_application_smime_handler (BODY * m, STATE * s)
 293 {
 294   if (CRYPT_MOD_CALL_CHECK (SMIME, application_handler))
 295     return (CRYPT_MOD_CALL (SMIME, application_handler)) (m, s);
 296   return (-1);
 297 }
 298
 299 /* MIME handler for an PGP/MIME encrypted message. */
 300 int crypt_smime_encrypted_handler (BODY * a, STATE * s)
 301 {
 302   if (CRYPT_MOD_CALL_CHECK (SMIME, encrypted_handler))
 303     return (CRYPT_MOD_CALL (SMIME, encrypted_handler)) (a, s);
 304   return (-1);
 305 }
 306
 307 /* fixme: Needs documentation. */
 308 void crypt_smime_getkeys (ENVELOPE * env)
 309 {
 310   if (CRYPT_MOD_CALL_CHECK (SMIME, smime_getkeys))
 311     (CRYPT_MOD_CALL (SMIME, smime_getkeys)) (env);
 312 }
 313
 314 /* Check that the sender matches. */
 315 int crypt_smime_verify_sender (HEADER * h)
 316 {
 317   if (CRYPT_MOD_CALL_CHECK (SMIME, smime_verify_sender))
 318     return (CRYPT_MOD_CALL (SMIME, smime_verify_sender)) (h);
 319
 320   return 1;
 321 }
 322
 323 /* This routine attempts to find the keyids of the recipients of a
 324    message.  It returns NULL if any of the keys can not be found.  */
 325 char *crypt_smime_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
 326 {
 327   if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys))
 328     return (CRYPT_MOD_CALL (SMIME, findkeys)) (to, cc, bcc);
 329
 330   return NULL;
 331 }
 332
 333 /* fixme: Needs documentation. */
 334 BODY *crypt_smime_sign_message (BODY * a)
 335 {
 336   if (CRYPT_MOD_CALL_CHECK (SMIME, sign_message))
 337     return (CRYPT_MOD_CALL (SMIME, sign_message)) (a);
 338
 339   return NULL;
 340 }
 341
 342 /* fixme: needs documentation. */
 343 BODY *crypt_smime_build_smime_entity (BODY * a, char *certlist)
 344 {
 345   if (CRYPT_MOD_CALL_CHECK (SMIME, smime_build_smime_entity))
 346     return (CRYPT_MOD_CALL (SMIME, smime_build_smime_entity)) (a, certlist);
 347
 348   return NULL;
 349 }
 350
 351 /* Add a certificate and update index file (externally). */
 352 void crypt_smime_invoke_import (char *infile, char *mailbox)
 353 {
 354   if (CRYPT_MOD_CALL_CHECK (SMIME, smime_invoke_import))
 355     (CRYPT_MOD_CALL (SMIME, smime_invoke_import)) (infile, mailbox);
 356 }
 357
 358 /* fixme: needs documentation */
 359 int crypt_smime_verify_one (BODY * sigbdy, STATE * s, const char *tempf)
 360 {
 361   if (CRYPT_MOD_CALL_CHECK (SMIME, verify_one))
 362     return (CRYPT_MOD_CALL (SMIME, verify_one)) (sigbdy, s, tempf);
 363
 364   return -1;
 365 }
 366
 367 int crypt_smime_send_menu (HEADER * msg, int *redraw)
 368 {
 369   if (CRYPT_MOD_CALL_CHECK (SMIME, send_menu))
 370     return (CRYPT_MOD_CALL (SMIME, send_menu)) (msg, redraw);
 371
 372   return 0;
 373 }