cryptglue.c

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