xssl.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ TLS/SSL functions. TODO this needs an overhaul -- there _are_ stack leaks!?
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   6  */
   7 /*
   8  * Copyright (c) 2002
   9  * Gunnar Ritter.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *    This product includes software developed by Gunnar Ritter
  22  *    and his contributors.
  23  * 4. Neither the name of Gunnar Ritter nor the names of his contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY GUNNAR RITTER AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL GUNNAR RITTER OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39 #undef n_FILE
  40 #define n_FILE xssl
  41
  42 #ifndef HAVE_AMALGAMATION
  43 # include "nail.h"
  44 #endif
  45
  46 EMPTY_FILE()
  47 #ifdef HAVE_XSSL
  48 #include <sys/socket.h>
  49
  50 #include <openssl/crypto.h>
  51 #include <openssl/err.h>
  52 #include <openssl/evp.h>
  53 #include <openssl/opensslv.h>
  54 #include <openssl/pem.h>
  55 #include <openssl/rand.h>
  56 #include <openssl/ssl.h>
  57 #include <openssl/x509v3.h>
  58 #include <openssl/x509.h>
  59
  60 #ifdef HAVE_XSSL_CONFIG
  61 # include <openssl/conf.h>
  62 #endif
  63
  64 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
  65 # include <dirent.h>
  66 #endif
  67
  68 /*
  69  * OpenSSL client implementation according to: John Viega, Matt Messier,
  70  * Pravir Chandra: Network Security with OpenSSL. Sebastopol, CA 2002.
  71  */
  72
  73 /* Update manual on changes (for all those)! */
  74 #define n_XSSL_DISABLED_PROTOCOLS "-SSLv2"
  75
  76 #ifndef HAVE_XSSL_CONF_CTX
  77 # ifndef SSL_OP_NO_SSLv2
  78 #  define SSL_OP_NO_SSLv2 0
  79 # endif
  80 # ifndef SSL_OP_NO_SSLv3
  81 #  define SSL_OP_NO_SSLv3 0
  82 # endif
  83 # ifndef SSL_OP_NO_TLSv1
  84 #  define SSL_OP_NO_TLSv1 0
  85 # endif
  86 # ifndef SSL_OP_NO_TLSv1_1
  87 #  define SSL_OP_NO_TLSv1_1 0
  88 # endif
  89 # ifndef SSL_OP_NO_TLSv1_2
  90 #  define SSL_OP_NO_TLSv1_2 0
  91 # endif
  92
  93   /* SSL_CONF_CTX and _OP_NO_SSL_MASK were both introduced with 1.0.2!?! */
  94 # ifndef SSL_OP_NO_SSL_MASK
  95 #  define SSL_OP_NO_SSL_MASK \
  96    (SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 |\
  97    SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2)
  98 # endif
  99 #endif
 100
 101 #ifdef HAVE_XSSL_STACK_OF
 102 # define n_XSSL_STACKOF(X) STACK_OF(X)
 103 #else
 104 # define n_XSSL_STACKOF(X) /*X*/STACK
 105 #endif
 106
 107 #if OPENSSL_VERSION_NUMBER + 0 >= 0x0090581fL
 108 # define a_XSSL_RAND_LOAD_FILE_MAXBYTES -1
 109 #else
 110 # define a_XSSL_RAND_LOAD_FILE_MAXBYTES 1024
 111 #endif
 112
 113 /* Compatibility sighs (that sigh is _really_ a cute one) */
 114 #if HAVE_XSSL_OPENSSL >= 0x10100
 115 # define a_xssl_X509_get_notBefore X509_get0_notBefore
 116 # define a_xssl_X509_get_notAfter X509_get0_notAfter
 117 #else
 118 # define a_xssl_X509_get_notBefore X509_get_notBefore
 119 # define a_xssl_X509_get_notAfter X509_get_notAfter
 120 #endif
 121
 122 /* Some became meaningless with HAVE_XSSL_OPENSSL>=0x10100 */
 123 enum a_xssl_state{
 124    a_XSSL_S_INIT = 1<<0,
 125    a_XSSL_S_RAND_INIT = 1<<1,
 126    a_XSSL_S_EXIT_HDL = 1<<2,
 127    a_XSSL_S_CONF_LOAD = 1<<3,
 128    a_XSSL_S_ALGO_LOAD = 1<<4,
 129
 130    a_XSSL_S_VERIFY_ERROR = 1<<7
 131 };
 132
 133 /* We go for the OpenSSL v1.0.2+ SSL_CONF_CTX if available even if
 134  * the library does internally what we'd otherwise do ourselfs.
 135  * But eventually we can drop the direct use cases */
 136 enum a_xssl_conf_type{
 137    a_XSSL_CT_CERTIFICATE,
 138    a_XSSL_CT_CIPHER_STRING,
 139    a_XSSL_CT_PRIVATE_KEY,
 140    a_XSSL_CT_OPTIONS,
 141    a_XSSL_CT_PROTOCOL
 142 };
 143
 144 struct ssl_method { /* TODO v15 obsolete */
 145    char const  sm_name[8];
 146    char const  sm_map[16];
 147 };
 148
 149 #ifndef HAVE_XSSL_CONF_CTX
 150 struct a_xssl_protocol{
 151    char const *sp_name;
 152    sl_i sp_flag;
 153 };
 154 #endif
 155
 156 struct a_xssl_smime_cipher{
 157    char const sc_name[8];
 158    EVP_CIPHER const *(*sc_fun)(void);
 159 };
 160
 161 struct a_xssl_smime_digest{
 162    char const sd_name[8];
 163    EVP_MD const *(*sd_fun)(void);
 164 };
 165
 166 /* Supported SSL/TLS methods: update manual on change! */
 167
 168 static struct ssl_method const   _ssl_methods[] = { /* TODO obsolete */
 169    {"auto",    "ALL,-SSLv2"},
 170    {"ssl3",    "-ALL,SSLv3"},
 171    {"tls1",    "-ALL,TLSv1"},
 172    {"tls1.1",  "-ALL,TLSv1.1"},
 173    {"tls1.2",  "-ALL,TLSv1.2"}
 174 };
 175
 176 /* Update manual on change! */
 177 #ifndef HAVE_XSSL_CONF_CTX
 178 static struct a_xssl_protocol const a_xssl_protocols[] = {
 179    {"ALL", SSL_OP_NO_SSL_MASK},
 180    {"TLSv1.2", SSL_OP_NO_TLSv1_2},
 181    {"TLSv1.1", SSL_OP_NO_TLSv1_1},
 182    {"TLSv1", SSL_OP_NO_TLSv1},
 183    {"SSLv3", SSL_OP_NO_SSLv3},
 184    {"SSLv2", 0}
 185 };
 186 #endif
 187
 188 /* Supported S/MIME cipher algorithms */
 189 static struct a_xssl_smime_cipher const a_xssl_smime_ciphers[] = { /* Manual! */
 190 #ifndef OPENSSL_NO_AES
 191 # define a_XSSL_SMIME_DEFAULT_CIPHER EVP_aes_128_cbc /* According to RFC 5751 */
 192    {"aes128", &EVP_aes_128_cbc},
 193    {"aes256", &EVP_aes_256_cbc},
 194    {"aes192", &EVP_aes_192_cbc},
 195 #endif
 196 #ifndef OPENSSL_NO_DES
 197 # ifndef a_XSSL_SMIME_DEFAULT_CIPHER
 198 #  define a_XSSL_SMIME_DEFAULT_CIPHER EVP_des_ede3_cbc
 199 # endif
 200    {"des3", &EVP_des_ede3_cbc},
 201    {"des", &EVP_des_cbc},
 202 #endif
 203 };
 204 #ifndef a_XSSL_SMIME_DEFAULT_CIPHER
 205 # error Your OpenSSL library does not include the necessary
 206 # error cipher algorithms that are required to support S/MIME
 207 #endif
 208
 209 #ifndef OPENSSL_NO_AES
 210 /* TODO obsolete a_xssl_smime_ciphers_obs */
 211 static struct a_xssl_smime_cipher const a_xssl_smime_ciphers_obs[] = {
 212    {"aes-128", &EVP_aes_128_cbc},
 213    {"aes-256", &EVP_aes_256_cbc},
 214    {"aes-192", &EVP_aes_192_cbc}
 215 };
 216 #endif
 217
 218 /* Supported S/MIME message digest algorithms */
 219 static struct a_xssl_smime_digest const a_xssl_smime_digests[] = { /* Manual! */
 220 #define a_XSSL_SMIME_DEFAULT_DIGEST EVP_sha1 /* According to RFC 5751 */
 221 #define a_XSSL_SMIME_DEFAULT_DIGEST_S  "sha1"
 222    {"sha1", &EVP_sha1},
 223    {"sha256", &EVP_sha256},
 224    {"sha512", &EVP_sha512},
 225    {"sha384", &EVP_sha384},
 226    {"sha224", &EVP_sha224},
 227 #ifndef OPENSSL_NO_MD5
 228    {"md5", &EVP_md5},
 229 #endif
 230 };
 231
 232 static enum a_xssl_state a_xssl_state;
 233 static size_t a_xssl_msgno;
 234
 235 static bool_t a_xssl_rand_init(void);
 236 #if HAVE_XSSL_OPENSSL < 0x10100
 237 # ifdef HAVE_SSL_ALL_ALGORITHMS
 238 static void a_xssl__load_algos(void);
 239 #  define a_xssl_load_algos a_xssl__load_algos
 240 # endif
 241 # if defined HAVE_XSSL_CONFIG || defined HAVE_SSL_ALL_ALGORITHMS
 242 static void a_xssl_atexit(void);
 243 # endif
 244 #endif
 245 #ifndef a_xssl_load_algos
 246 # define a_xssl_load_algos() do{;}while(0)
 247 #endif
 248
 249 static bool_t     _ssl_parse_asn1_time(ASN1_TIME const *atp,
 250                      char *bdat, size_t blen);
 251 static int        _ssl_verify_cb(int success, X509_STORE_CTX *store);
 252
 253 /* SSL_CTX configuration */
 254 static void *     _ssl_conf_setup(SSL_CTX *ctxp);
 255 static bool_t     _ssl_conf(void *confp, enum a_xssl_conf_type ct,
 256                      char const *value);
 257 static bool_t     _ssl_conf_finish(void **confp, bool_t error);
 258
 259 static bool_t     _ssl_load_verifications(SSL_CTX *ctxp);
 260
 261 static enum okay  ssl_check_host(struct sock *sp, struct url const *urlp);
 262
 263 static int        smime_verify(struct message *m, int n,
 264                      n_XSSL_STACKOF(X509) *chain, X509_STORE *store);
 265 static EVP_CIPHER const * _smime_cipher(char const *name);
 266 static int        ssl_password_cb(char *buf, int size, int rwflag,
 267                      void *userdata);
 268 static FILE *     smime_sign_cert(char const *xname, char const *xname2,
 269                      bool_t dowarn);
 270 static char *     _smime_sign_include_certs(char const *name);
 271 static bool_t     _smime_sign_include_chain_creat(n_XSSL_STACKOF(X509) **chain,
 272                      char const *cfiles);
 273 static EVP_MD const * _smime_sign_digest(char const *name,
 274                         char const **digname);
 275 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
 276 static enum okay  load_crl1(X509_STORE *store, char const *name);
 277 #endif
 278 static enum okay  load_crls(X509_STORE *store, enum okeys fok, enum okeys dok);
 279
 280 static bool_t
 281 a_xssl_rand_init(void){
 282    char const *cp, *x;
 283    bool_t rv;
 284    NYD_ENTER;
 285
 286    rv = FAL0;
 287
 288    /* Shall use some external daemon? */ /* TODO obsolete *ssl_rand_egd* */
 289    if((cp = ok_vlook(ssl_rand_egd)) != NULL){ /* TODO no one supports it now! */
 290       OBSOLETE(_("all *SSL libraries dropped support of *ssl-rand-egd*, thus"));
 291 #ifdef HAVE_XSSL_RAND_EGD
 292       if((x = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) != NULL &&
 293             RAND_egd(cp = x) != -1){
 294          rv = TRU1;
 295          goto jleave;
 296       }
 297       n_err(_("*ssl_rand_egd* daemon at %s not available\n"),
 298          n_shexp_quote_cp(cp, FAL0));
 299 #else
 300       if(options & OPT_D_VV)
 301          n_err(_("*ssl_rand_egd* (%s): unsupported by SSL library\n"),
 302             n_shexp_quote_cp(cp, FAL0));
 303 #endif
 304    }
 305
 306    /* Prefer possible user setting */
 307    if((cp = ok_vlook(ssl_rand_file)) != NULL){
 308       x = NULL;
 309       if(*cp != '\0'){
 310          if((x = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL)
 311             n_err(_("*ssl-rand-file*: filename expansion of %s failed\n"),
 312                n_shexp_quote_cp(cp, FAL0));
 313       }
 314       cp = x;
 315    }
 316
 317    /* If the SSL PRNG is initialized don't put any more effort in this if the
 318     * user defined entropy isn't usable */
 319    if(cp == NULL){
 320       if(RAND_status()){
 321          rv = TRU1;
 322          goto jleave;
 323       }
 324
 325       if((cp = RAND_file_name(salloc(PATH_MAX), PATH_MAX)) == NULL){
 326          n_err(_("*ssl-rand-file*: no SSL entropy file, can't seed PRNG\n"));
 327          goto jleave;
 328       }
 329    }
 330
 331    if(RAND_load_file(cp, a_XSSL_RAND_LOAD_FILE_MAXBYTES) != -1){
 332       for(x = (char*)-1;;){
 333          RAND_seed(getrandstring(32), 32);
 334          if((rv = (RAND_status() != 0)))
 335             break;
 336          if((x = (char*)((uintptr_t)x >> 1)) == NULL){
 337             n_err(_("*ssl-rand-file*: can't seed SSL PRNG with entropy\n"));
 338             goto jleave;
 339          }
 340       }
 341
 342       if(RAND_write_file(cp) == -1)
 343          n_err(_("*ssl-rand-file*: writing entropy to %s failed\n"),
 344             n_shexp_quote_cp(cp, FAL0));
 345    }else
 346       n_err(_("*ssl-rand-file*: %s cannot be loaded\n"),
 347          n_shexp_quote_cp(cp, FAL0));
 348 jleave:
 349    NYD_LEAVE;
 350    return rv;
 351 }
 352
 353 static void
 354 a_xssl_init(void)
 355 {
 356 #ifdef HAVE_XSSL_CONFIG
 357    char const *cp;
 358 #endif
 359    NYD_ENTER;
 360
 361    if(!(a_xssl_state & a_XSSL_S_INIT)){
 362 #if HAVE_XSSL_OPENSSL >= 0x10100
 363       OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS |
 364          OPENSSL_INIT_LOAD_CRYPTO_STRINGS
 365 # ifdef HAVE_SSL_ALL_ALGORITHMS
 366             | OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS
 367 # endif
 368          , NULL);
 369 # ifdef HAVE_SSL_ALL_ALGORITHMS
 370       a_xssl_state |= a_XSSL_S_ALGO_LOAD;
 371 # endif
 372 #else
 373       SSL_load_error_strings();
 374       SSL_library_init();
 375 #endif
 376       a_xssl_state |= a_XSSL_S_INIT;
 377    }
 378
 379    /* Load openssl.cnf or whatever was given in *ssl-config-file* */
 380 #ifdef HAVE_XSSL_CONFIG
 381    if(!(a_xssl_state & a_XSSL_S_CONF_LOAD) &&
 382          (cp = ok_vlook(ssl_config_file)) != NULL){
 383       ul_i flags = CONF_MFLAGS_IGNORE_MISSING_FILE;
 384
 385       if(*cp == '\0'){
 386          cp = NULL;
 387          flags = 0;
 388       }
 389       if(CONF_modules_load_file(cp, uagent, flags) == 1){
 390          a_xssl_state |= a_XSSL_S_CONF_LOAD;
 391 # if HAVE_XSSL_OPENSSL < 0x10100
 392          if(!(a_xssl_state & a_XSSL_S_EXIT_HDL)){
 393             a_xssl_state |= a_XSSL_S_EXIT_HDL;
 394             atexit(&a_xssl_atexit); /* TODO generic program-wide event mech. */
 395          }
 396 # endif
 397       }else
 398          ssl_gen_err(_("Ignoring CONF_modules_load_file() load error"));
 399    }
 400 #endif
 401
 402    if(!(a_xssl_state & a_XSSL_S_RAND_INIT) && a_xssl_rand_init())
 403       a_xssl_state |= a_XSSL_S_RAND_INIT;
 404    NYD_LEAVE;
 405 }
 406
 407 #if HAVE_XSSL_OPENSSL < 0x10100
 408 # ifdef HAVE_SSL_ALL_ALGORITHMS
 409 static void
 410 a_xssl__load_algos(void){
 411    NYD2_ENTER;
 412    if(!(a_xssl_state & a_XSSL_S_ALGO_LOAD)){
 413       a_xssl_state |= a_XSSL_S_ALGO_LOAD;
 414       OpenSSL_add_all_algorithms();
 415
 416       if(!(a_xssl_state & a_XSSL_S_EXIT_HDL)){
 417          a_xssl_state |= a_XSSL_S_EXIT_HDL;
 418          atexit(&a_xssl_atexit); /* TODO generic program-wide event mech. */
 419       }
 420    }
 421    NYD2_LEAVE;
 422 }
 423 # endif
 424
 425 # if defined HAVE_XSSL_CONFIG || defined HAVE_SSL_ALL_ALGORITHMS
 426 static void
 427 a_xssl_atexit(void){
 428    NYD2_ENTER;
 429 #  ifdef HAVE_XSSL_CONFIG
 430    if(a_xssl_state & a_XSSL_S_CONF_LOAD)
 431       CONF_modules_free();
 432 #  endif
 433
 434 #  ifdef HAVE_SSL_ALL_ALGORITHMS
 435    if(a_xssl_state & a_XSSL_S_ALGO_LOAD)
 436       EVP_cleanup();
 437 #  endif
 438    NYD2_LEAVE;
 439 }
 440 # endif
 441 #endif /* HAVE_XSSL_OPENSSL < 0x10100 */
 442
 443 static bool_t
 444 _ssl_parse_asn1_time(ASN1_TIME const *atp, char *bdat, size_t blen)
 445 {
 446    BIO *mbp;
 447    char *mcp;
 448    long l;
 449    NYD_ENTER;
 450
 451    mbp = BIO_new(BIO_s_mem());
 452
 453    if (ASN1_TIME_print(mbp, atp) && (l = BIO_get_mem_data(mbp, &mcp)) > 0)
 454       snprintf(bdat, blen, "%.*s", (int)l, mcp);
 455    else {
 456       snprintf(bdat, blen, _("Bogus certificate date: %.*s"),
 457          /*is (int)*/atp->length, (char const*)atp->data);
 458       mcp = NULL;
 459    }
 460
 461    BIO_free(mbp);
 462    NYD_LEAVE;
 463    return (mcp != NULL);
 464 }
 465
 466 static int
 467 _ssl_verify_cb(int success, X509_STORE_CTX *store)
 468 {
 469    char data[256];
 470    X509 *cert;
 471    int rv = TRU1;
 472    NYD_ENTER;
 473
 474    if (success && !(options & OPT_VERB))
 475       goto jleave;
 476
 477    if (a_xssl_msgno != 0) {
 478       n_err(_("Message %lu:\n"), (ul_i)a_xssl_msgno);
 479       a_xssl_msgno = 0;
 480    }
 481    n_err(_(" Certificate depth %d %s\n"),
 482       X509_STORE_CTX_get_error_depth(store), (success ? n_empty : V_(n_error)));
 483
 484    if ((cert = X509_STORE_CTX_get_current_cert(store)) != NULL) {
 485       X509_NAME_oneline(X509_get_subject_name(cert), data, sizeof data);
 486       n_err(_("  subject = %s\n"), data);
 487
 488       _ssl_parse_asn1_time(a_xssl_X509_get_notBefore(cert), data, sizeof data);
 489       n_err(_("  notBefore = %s\n"), data);
 490
 491       _ssl_parse_asn1_time(a_xssl_X509_get_notAfter(cert), data, sizeof data);
 492       n_err(_("  notAfter = %s\n"), data);
 493
 494       X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof data);
 495       n_err(_("  issuer = %s\n"), data);
 496    }
 497
 498    if (!success) {
 499       int err = X509_STORE_CTX_get_error(store);
 500
 501       n_err(_("  err %i: %s\n"), err, X509_verify_cert_error_string(err));
 502       a_xssl_state |= a_XSSL_S_VERIFY_ERROR;
 503    }
 504
 505    if (!success && ssl_verify_decide() != OKAY)
 506       rv = FAL0;
 507 jleave:
 508    NYD_LEAVE;
 509    return rv;
 510 }
 511
 512 #ifdef HAVE_XSSL_CONF_CTX
 513 static void *
 514 _ssl_conf_setup(SSL_CTX *ctxp)
 515 {
 516    SSL_CONF_CTX *sccp;
 517    NYD_ENTER;
 518
 519    if ((sccp = SSL_CONF_CTX_new()) != NULL) {
 520       SSL_CONF_CTX_set_flags(sccp,
 521          SSL_CONF_FLAG_FILE | SSL_CONF_FLAG_CLIENT |
 522          SSL_CONF_FLAG_CERTIFICATE | SSL_CONF_FLAG_SHOW_ERRORS);
 523
 524       SSL_CONF_CTX_set_ssl_ctx(sccp, ctxp);
 525    } else
 526       ssl_gen_err(_("SSL_CONF_CTX_new() failed"));
 527
 528    NYD_LEAVE;
 529    return sccp;
 530 }
 531
 532 static bool_t
 533 _ssl_conf(void *confp, enum a_xssl_conf_type ct, char const *value)
 534 {
 535    int rv;
 536    char const *cmsg;
 537    SSL_CONF_CTX *sccp = (SSL_CONF_CTX*)confp;
 538    NYD_ENTER;
 539
 540    switch (ct) {
 541    case a_XSSL_CT_CERTIFICATE:
 542       cmsg = "ssl-cert";
 543       rv = SSL_CONF_cmd(sccp, "Certificate", value);
 544       break;
 545    case a_XSSL_CT_CIPHER_STRING:
 546       cmsg = "ssl-cipher-list";
 547       rv = SSL_CONF_cmd(sccp, "CipherString", value);
 548       break;
 549    case a_XSSL_CT_PRIVATE_KEY:
 550       cmsg = "ssl-key";
 551       rv = SSL_CONF_cmd(sccp, "PrivateKey", value);
 552       break;
 553    default:
 554    case a_XSSL_CT_OPTIONS:
 555       cmsg = "ssl-options";
 556       rv = SSL_CONF_cmd(sccp, "Options", "Bugs");
 557       break;
 558    case a_XSSL_CT_PROTOCOL:
 559       cmsg = "ssl-protocol";
 560       rv = SSL_CONF_cmd(sccp, "Protocol", value);
 561       break;
 562    }
 563
 564    if (rv == 2)
 565       rv = 0;
 566    else {
 567       if (rv == 0)
 568          ssl_gen_err(_("SSL_CONF_CTX_cmd() failed for *%s*"), cmsg);
 569       else
 570          n_err(_("%s: *%s* implementation error, please report this\n"),
 571             uagent, cmsg);
 572       rv = 1;
 573    }
 574
 575    NYD_LEAVE;
 576    return (rv == 0);
 577 }
 578
 579 static bool_t
 580 _ssl_conf_finish(void **confp, bool_t error)
 581 {
 582    SSL_CONF_CTX **sccp = (SSL_CONF_CTX**)confp;
 583    bool_t rv;
 584    NYD_ENTER;
 585
 586    if (!(rv = error))
 587       rv = (SSL_CONF_CTX_finish(*sccp) != 0);
 588
 589    SSL_CONF_CTX_free(*sccp);
 590
 591    *sccp = NULL;
 592    NYD_LEAVE;
 593    return rv;
 594 }
 595
 596 #else /* HAVE_XSSL_CONF_CTX */
 597 static void *
 598 _ssl_conf_setup(SSL_CTX* ctxp)
 599 {
 600    return ctxp;
 601 }
 602
 603 static bool_t
 604 _ssl_conf(void *confp, enum a_xssl_conf_type ct, char const *value)
 605 {
 606    SSL_CTX *ctxp = (SSL_CTX*)confp;
 607    NYD_ENTER;
 608
 609    switch (ct) {
 610    case a_XSSL_CT_CERTIFICATE:
 611       if (SSL_CTX_use_certificate_chain_file(ctxp, value) != 1) {
 612          ssl_gen_err(_("Can't load certificate from file %s\n"),
 613             n_shexp_quote_cp(value, FAL0));
 614          confp = NULL;
 615       }
 616       break;
 617    case a_XSSL_CT_CIPHER_STRING:
 618       if (SSL_CTX_set_cipher_list(ctxp, value) != 1) {
 619          ssl_gen_err(_("Invalid cipher string: %s\n"), value);
 620          confp = NULL;
 621       }
 622       break;
 623    case a_XSSL_CT_PRIVATE_KEY:
 624       if (SSL_CTX_use_PrivateKey_file(ctxp, value, SSL_FILETYPE_PEM) != 1) {
 625          ssl_gen_err(_("Can't load private key from file %s\n"),
 626             n_shexp_quote_cp(value, FAL0));
 627          confp = NULL;
 628       }
 629       break;
 630    case a_XSSL_CT_OPTIONS:
 631       /* "Options"="Bugs" TODO *ssl-options* */
 632       SSL_CTX_set_options(ctxp, SSL_OP_ALL);
 633       break;
 634    case a_XSSL_CT_PROTOCOL: {
 635       char *iolist, *cp, addin;
 636       size_t i;
 637       sl_i opts = 0;
 638
 639       confp = NULL;
 640       for (iolist = cp = savestr(value);
 641             (cp = n_strsep(&iolist, ',', FAL0)) != NULL;) {
 642          if (*cp == '\0') {
 643             n_err(_("*ssl-protocol*: empty arguments are not supported\n"));
 644             goto jleave;
 645          }
 646
 647          addin = TRU1;
 648          switch (cp[0]) {
 649          case '-': addin = FAL0; /* FALLTHRU */
 650          case '+': ++cp; /* FALLTHRU */
 651          default : break;
 652          }
 653
 654          for (i = 0;;) {
 655             if (!asccasecmp(cp, a_xssl_protocols[i].sp_name)) {
 656                /* We need to inverse the meaning of the _NO_s */
 657                if (!addin)
 658                   opts |= a_xssl_protocols[i].sp_flag;
 659                else
 660                   opts &= ~a_xssl_protocols[i].sp_flag;
 661                break;
 662             }
 663             if (++i < n_NELEM(a_xssl_protocols))
 664                continue;
 665             n_err(_("*ssl-protocol*: unsupported value: %s\n"), cp);
 666             goto jleave;
 667          }
 668       }
 669       confp = ctxp;
 670       SSL_CTX_set_options(ctxp, opts);
 671       break;
 672    }
 673    }
 674 jleave:
 675    NYD_LEAVE;
 676    return (confp != NULL);
 677 }
 678
 679 static bool_t
 680 _ssl_conf_finish(void **confp, bool_t error)
 681 {
 682    n_UNUSED(confp);
 683    n_UNUSED(error);
 684    return TRU1;
 685 }
 686 #endif /* !HAVE_XSSL_CONF_CTX */
 687
 688 static bool_t
 689 _ssl_load_verifications(SSL_CTX *ctxp)
 690 {
 691    char *ca_dir, *ca_file;
 692    X509_STORE *store;
 693    bool_t rv = FAL0;
 694    NYD_ENTER;
 695
 696    if (ssl_verify_level == SSL_VERIFY_IGNORE) {
 697       rv = TRU1;
 698       goto jleave;
 699    }
 700
 701    if ((ca_dir = ok_vlook(ssl_ca_dir)) != NULL)
 702       ca_dir = fexpand(ca_dir, FEXP_LOCAL | FEXP_NOPROTO);
 703    if ((ca_file = ok_vlook(ssl_ca_file)) != NULL)
 704       ca_file = fexpand(ca_file, FEXP_LOCAL | FEXP_NOPROTO);
 705
 706    if ((ca_dir != NULL || ca_file != NULL) &&
 707          SSL_CTX_load_verify_locations(ctxp, ca_file, ca_dir) != 1) {
 708       char const *m1, *m2, *m3;
 709
 710       if (ca_dir != NULL) {
 711          m1 = ca_dir;
 712          m2 = (ca_file != NULL) ? _(" or ") : n_empty;
 713       } else
 714          m1 = m2 = n_empty;
 715       m3 = (ca_file != NULL) ? ca_file : n_empty;
 716       ssl_gen_err(_("Error loading %s%s%s\n"), m1, m2, m3);
 717       goto jleave;
 718    }
 719
 720    if (!ok_blook(ssl_no_default_ca) &&
 721          SSL_CTX_set_default_verify_paths(ctxp) != 1) {
 722       ssl_gen_err(_("Error loading default CA locations\n"));
 723       goto jleave;
 724    }
 725
 726    a_xssl_state &= ~a_XSSL_S_VERIFY_ERROR;
 727    a_xssl_msgno = 0;
 728    SSL_CTX_set_verify(ctxp, SSL_VERIFY_PEER, &_ssl_verify_cb);
 729    store = SSL_CTX_get_cert_store(ctxp);
 730    load_crls(store, ok_v_ssl_crl_file, ok_v_ssl_crl_dir);
 731
 732    rv = TRU1;
 733 jleave:
 734    NYD_LEAVE;
 735    return rv;
 736 }
 737
 738 static enum okay
 739 ssl_check_host(struct sock *sp, struct url const *urlp)
 740 {
 741    char data[256];
 742    X509 *cert;
 743    n_XSSL_STACKOF(GENERAL_NAME) *gens;
 744    GENERAL_NAME *gen;
 745    X509_NAME *subj;
 746    enum okay rv = STOP;
 747    NYD_ENTER;
 748
 749    if ((cert = SSL_get_peer_certificate(sp->s_ssl)) == NULL) {
 750       n_err(_("No certificate from: %s\n"), urlp->url_h_p.s);
 751       goto jleave;
 752    }
 753
 754    gens = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
 755    if (gens != NULL) {
 756       int i;
 757
 758       for (i = 0; i < sk_GENERAL_NAME_num(gens); ++i) {
 759          gen = sk_GENERAL_NAME_value(gens, i);
 760          if (gen->type == GEN_DNS) {
 761             if (options & OPT_VERB)
 762                n_err(_("Comparing subject_alt_name: need<%s> is<%s>\n"),
 763                   urlp->url_host.s, (char*)gen->d.ia5->data);
 764             rv = rfc2595_hostname_match(urlp->url_host.s,
 765                   (char*)gen->d.ia5->data);
 766             if (rv == OKAY)
 767                goto jdone;
 768          }
 769       }
 770    }
 771
 772    if ((subj = X509_get_subject_name(cert)) != NULL &&
 773          X509_NAME_get_text_by_NID(subj, NID_commonName, data, sizeof data)
 774             > 0) {
 775       data[sizeof data - 1] = '\0';
 776       if (options & OPT_VERB)
 777          n_err(_("Comparing commonName: need<%s> is<%s>\n"),
 778             urlp->url_host.s, data);
 779       rv = rfc2595_hostname_match(urlp->url_host.s, data);
 780    }
 781
 782 jdone:
 783    X509_free(cert);
 784 jleave:
 785    NYD_LEAVE;
 786    return rv;
 787 }
 788
 789 static int
 790 smime_verify(struct message *m, int n, n_XSSL_STACKOF(X509) *chain,
 791    X509_STORE *store)
 792 {
 793    char data[LINESIZE], *sender, *to, *cc, *cnttype;
 794    int rv, c, i, j;
 795    struct message *x;
 796    FILE *fp, *ip;
 797    off_t size;
 798    BIO *fb, *pb;
 799    PKCS7 *pkcs7;
 800    n_XSSL_STACKOF(X509) *certs;
 801    n_XSSL_STACKOF(GENERAL_NAME) *gens;
 802    X509 *cert;
 803    X509_NAME *subj;
 804    GENERAL_NAME *gen;
 805    NYD_ENTER;
 806
 807    rv = 1;
 808    fp = NULL;
 809    fb = NULL;
 810    a_xssl_state &= ~a_XSSL_S_VERIFY_ERROR;
 811    a_xssl_msgno = (size_t)n;
 812
 813    for (;;) {
 814       sender = getsender(m);
 815       to = hfield1("to", m);
 816       cc = hfield1("cc", m);
 817       cnttype = hfield1("content-type", m);
 818
 819 #undef _X
 820 #undef _Y
 821 #define _X     (sizeof("application/") -1)
 822 #define _Y(X)  X, sizeof(X) -1
 823       if (cnttype && is_asccaseprefix(cnttype, "application/") &&
 824             (!ascncasecmp(cnttype + _X, _Y("pkcs7-mime")) ||
 825              !ascncasecmp(cnttype + _X, _Y("x-pkcs7-mime")))) {
 826 #undef _Y
 827 #undef _X
 828          if ((x = smime_decrypt(m, to, cc, 1)) == NULL)
 829             goto jleave;
 830          if (x != (struct message*)-1) {
 831             m = x;
 832             continue;
 833          }
 834       }
 835
 836       if ((ip = setinput(&mb, m, NEED_BODY)) == NULL)
 837          goto jleave;
 838       size = m->m_size;
 839       break;
 840    }
 841
 842    if ((fp = Ftmp(NULL, "smimever", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
 843          NULL) {
 844       n_perr(_("tempfile"), 0);
 845       goto jleave;
 846    }
 847    while (size-- > 0) {
 848       c = getc(ip);
 849       putc(c, fp);
 850    }
 851    fflush_rewind(fp);
 852
 853    if ((fb = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
 854       ssl_gen_err(_(
 855          "Error creating BIO verification object for message %d"), n);
 856       goto jleave;
 857    }
 858
 859    if ((pkcs7 = SMIME_read_PKCS7(fb, &pb)) == NULL) {
 860       ssl_gen_err(_("Error reading PKCS#7 object for message %d"), n);
 861       goto jleave;
 862    }
 863    if (PKCS7_verify(pkcs7, chain, store, pb, NULL, 0) != 1) {
 864       ssl_gen_err(_("Error verifying message %d"), n);
 865       goto jleave;
 866    }
 867
 868    if (sender == NULL) {
 869       n_err(_("Warning: Message %d has no sender\n"), n);
 870       rv = 0;
 871       goto jleave;
 872    }
 873
 874    certs = PKCS7_get0_signers(pkcs7, chain, 0);
 875    if (certs == NULL) {
 876       n_err(_("No certificates found in message %d\n"), n);
 877       goto jleave;
 878    }
 879
 880    for (i = 0; i < sk_X509_num(certs); ++i) {
 881       cert = sk_X509_value(certs, i);
 882       gens = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
 883       if (gens != NULL) {
 884          for (j = 0; j < sk_GENERAL_NAME_num(gens); ++j) {
 885             gen = sk_GENERAL_NAME_value(gens, j);
 886             if (gen->type == GEN_EMAIL) {
 887                if (options & OPT_VERB)
 888                   n_err(_("Comparing subject_alt_name: need<%s> is<%s>)\n"),
 889                      sender, (char*)gen->d.ia5->data);
 890                if (!asccasecmp((char*)gen->d.ia5->data, sender))
 891                   goto jfound;
 892             }
 893          }
 894       }
 895
 896       if ((subj = X509_get_subject_name(cert)) != NULL &&
 897             X509_NAME_get_text_by_NID(subj, NID_pkcs9_emailAddress,
 898                data, sizeof data) > 0) {
 899          data[sizeof data -1] = '\0';
 900          if (options & OPT_VERB)
 901             n_err(_("Comparing emailAddress: need<%s> is<%s>\n"),
 902                sender, data);
 903          if (!asccasecmp(data, sender))
 904             goto jfound;
 905       }
 906    }
 907    n_err(_("Message %d: certificate does not match <%s>\n"), n, sender);
 908    goto jleave;
 909 jfound:
 910    rv = ((a_xssl_state & a_XSSL_S_VERIFY_ERROR) != 0);
 911    if (!rv)
 912       printf(_("Message %d was verified successfully\n"), n);
 913 jleave:
 914    if (fb != NULL)
 915       BIO_free(fb);
 916    if (fp != NULL)
 917       Fclose(fp);
 918    NYD_LEAVE;
 919    return rv;
 920 }
 921
 922 static EVP_CIPHER const *
 923 _smime_cipher(char const *name)
 924 {
 925    EVP_CIPHER const *cipher;
 926    char *vn;
 927    char const *cp;
 928    size_t i;
 929    NYD_ENTER;
 930
 931    vn = ac_alloc(i = strlen(name) + sizeof("smime-cipher-") -1 +1);
 932    snprintf(vn, (int)i, "smime-cipher-%s", name);
 933    cp = vok_vlook(vn);
 934    ac_free(vn);
 935
 936    if (cp == NULL && (cp = ok_vlook(smime_cipher)) == NULL) {
 937       cipher = a_XSSL_SMIME_DEFAULT_CIPHER();
 938       goto jleave;
 939    }
 940    cipher = NULL;
 941
 942    for (i = 0; i < n_NELEM(a_xssl_smime_ciphers); ++i)
 943       if (!asccasecmp(a_xssl_smime_ciphers[i].sc_name, cp)) {
 944          cipher = (*a_xssl_smime_ciphers[i].sc_fun)();
 945          goto jleave;
 946       }
 947 #ifndef OPENSSL_NO_AES
 948    for (i = 0; i < n_NELEM(a_xssl_smime_ciphers_obs); ++i) /* TODO obsolete */
 949       if (!asccasecmp(a_xssl_smime_ciphers_obs[i].sc_name, cp)) {
 950          OBSOLETE2(_("*smime-cipher* names with hyphens will vanish"), cp);
 951          cipher = (*a_xssl_smime_ciphers_obs[i].sc_fun)();
 952          goto jleave;
 953       }
 954 #endif
 955
 956    /* Not a builtin algorithm, but we may have dynamic support for more */
 957 #ifdef HAVE_SSL_ALL_ALGORITHMS
 958    a_xssl_load_algos();
 959    if((cipher = EVP_get_cipherbyname(cp)) != NULL)
 960       goto jleave;
 961 #endif
 962
 963    n_err(_("Invalid S/MIME cipher(s): %s\n"), cp);
 964 jleave:
 965    NYD_LEAVE;
 966    return cipher;
 967 }
 968
 969 static int
 970 ssl_password_cb(char *buf, int size, int rwflag, void *userdata)
 971 {
 972    char *pass;
 973    size_t len;
 974    NYD_ENTER;
 975    n_UNUSED(rwflag);
 976    n_UNUSED(userdata);
 977
 978    if ((pass = getpassword("PEM pass phrase:")) != NULL) {
 979       len = strlen(pass);
 980       if (UICMP(z, len, >=, size))
 981          len = size -1;
 982       memcpy(buf, pass, len);
 983       buf[len] = '\0';
 984    } else
 985       len = 0;
 986    NYD_LEAVE;
 987    return (int)len;
 988 }
 989
 990 static FILE *
 991 smime_sign_cert(char const *xname, char const *xname2, bool_t dowarn)
 992 {
 993    char *vn, *cp;
 994    int vs;
 995    struct name *np;
 996    char const *name = xname, *name2 = xname2;
 997    FILE *fp = NULL;
 998    NYD_ENTER;
 999
1000 jloop:
1001    if (name) {
1002       np = lextract(name, GTO | GSKIN);
1003       while (np != NULL) {
1004          /* This needs to be more intelligent since it will currently take the
1005           * first name for which a private key is available regardless of
1006           * whether it is the right one for the message */
1007          vn = ac_alloc(vs = strlen(np->n_name) + 30);
1008          snprintf(vn, vs, "smime-sign-cert-%s", np->n_name);
1009          cp = vok_vlook(vn);
1010          ac_free(vn);
1011          if (cp != NULL)
1012             goto jopen;
1013          np = np->n_flink;
1014       }
1015       if (name2 != NULL) {
1016          name = name2;
1017          name2 = NULL;
1018          goto jloop;
1019       }
1020    }
1021
1022    if ((cp = ok_vlook(smime_sign_cert)) == NULL)
1023       goto jerr;
1024 jopen:
1025    if ((cp = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL)
1026       goto jleave;
1027    if ((fp = Fopen(cp, "r")) == NULL)
1028       n_perr(cp, 0);
1029 jleave:
1030    NYD_LEAVE;
1031    return fp;
1032 jerr:
1033    if (dowarn)
1034       n_err(_("Could not find a certificate for %s%s%s\n"),
1035          xname, (xname2 != NULL ? _("or ") : n_empty),
1036          (xname2 != NULL ? xname2 : n_empty));
1037    goto jleave;
1038 }
1039
1040 static char *
1041 _smime_sign_include_certs(char const *name)
1042 {
1043    char *rv;
1044    NYD_ENTER;
1045
1046    /* See comments in smime_sign_cert() for algorithm pitfalls */
1047    if (name != NULL) {
1048       struct name *np;
1049
1050       for (np = lextract(name, GTO | GSKIN); np != NULL; np = np->n_flink) {
1051          int vs;
1052          char *vn = ac_alloc(vs = strlen(np->n_name) + 30);
1053          snprintf(vn, vs, "smime-sign-include-certs-%s", np->n_name);
1054          rv = vok_vlook(vn);
1055          ac_free(vn);
1056          if (rv != NULL)
1057             goto jleave;
1058       }
1059    }
1060    rv = ok_vlook(smime_sign_include_certs);
1061 jleave:
1062    NYD_LEAVE;
1063    return rv;
1064 }
1065
1066 static bool_t
1067 _smime_sign_include_chain_creat(n_XSSL_STACKOF(X509) **chain,
1068    char const *cfiles)
1069 {
1070    X509 *tmp;
1071    FILE *fp;
1072    char *nfield, *cfield, *x;
1073    NYD_ENTER;
1074
1075    *chain = sk_X509_new_null();
1076
1077    for (nfield = savestr(cfiles);
1078          (cfield = n_strsep(&nfield, ',', TRU1)) != NULL;) {
1079       if ((x = fexpand(cfield, FEXP_LOCAL | FEXP_NOPROTO)) == NULL ||
1080             (fp = Fopen(cfield = x, "r")) == NULL) {
1081          n_perr(cfiles, 0);
1082          goto jerr;
1083       }
1084       if ((tmp = PEM_read_X509(fp, NULL, &ssl_password_cb, NULL)) == NULL) {
1085          ssl_gen_err(_("Error reading certificate from %s"),
1086             n_shexp_quote_cp(cfield, FAL0));
1087          Fclose(fp);
1088          goto jerr;
1089       }
1090       sk_X509_push(*chain, tmp);
1091       Fclose(fp);
1092    }
1093
1094    if (sk_X509_num(*chain) == 0) {
1095       n_err(_("*smime-sign-include-certs* defined but empty\n"));
1096       goto jerr;
1097    }
1098 jleave:
1099    NYD_LEAVE;
1100    return (*chain != NULL);
1101 jerr:
1102    sk_X509_pop_free(*chain, X509_free);
1103    *chain = NULL;
1104    goto jleave;
1105 }
1106
1107 static EVP_MD const *
1108 _smime_sign_digest(char const *name, char const **digname)
1109 {
1110    EVP_MD const *digest;
1111    char const *cp;
1112    size_t i;
1113    NYD_ENTER;
1114
1115    /* See comments in smime_sign_cert() for algorithm pitfalls */
1116    if (name != NULL) {
1117       struct name *np;
1118
1119       for (np = lextract(name, GTO | GSKIN); np != NULL; np = np->n_flink) {
1120          int vs;
1121          char *vn = ac_alloc(vs = strlen(np->n_name) + 30);
1122          snprintf(vn, vs, "smime-sign-message-digest-%s", np->n_name);
1123          cp = vok_vlook(vn);
1124          ac_free(vn);
1125          if (cp != NULL)
1126             goto jhave_name;
1127       }
1128    }
1129
1130    if ((cp = ok_vlook(smime_sign_message_digest)) == NULL) {
1131       digest = a_XSSL_SMIME_DEFAULT_DIGEST();
1132       *digname = a_XSSL_SMIME_DEFAULT_DIGEST_S;
1133       goto jleave;
1134    }
1135
1136 jhave_name:
1137    i = strlen(cp);
1138    {  char *x = salloc(i +1);
1139       i_strcpy(x, cp, i +1);
1140       cp = x;
1141    }
1142    *digname = cp;
1143
1144    for (i = 0; i < n_NELEM(a_xssl_smime_digests); ++i)
1145       if (!strcmp(a_xssl_smime_digests[i].sd_name, cp)) {
1146          digest = (*a_xssl_smime_digests[i].sd_fun)();
1147          goto jleave;
1148       }
1149
1150    /* Not a builtin algorithm, but we may have dynamic support for more */
1151 #ifdef HAVE_SSL_ALL_ALGORITHMS
1152    a_xssl_load_algos();
1153    if((digest = EVP_get_digestbyname(cp)) != NULL)
1154       goto jleave;
1155 #endif
1156
1157    n_err(_("Invalid message digest: %s\n"), cp);
1158    digest = NULL;
1159 jleave:
1160    NYD_LEAVE;
1161    return digest;
1162 }
1163
1164 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1165 static enum okay
1166 load_crl1(X509_STORE *store, char const *name)
1167 {
1168    X509_LOOKUP *lookup;
1169    enum okay rv = STOP;
1170    NYD_ENTER;
1171
1172    if (options & OPT_VERB)
1173       n_err(_("Loading CRL from %s\n"), n_shexp_quote_cp(name, FAL0));
1174    if ((lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file())) == NULL) {
1175       ssl_gen_err(_("Error creating X509 lookup object"));
1176       goto jleave;
1177    }
1178    if (X509_load_crl_file(lookup, name, X509_FILETYPE_PEM) != 1) {
1179       ssl_gen_err(_("Error loading CRL from %s"), n_shexp_quote_cp(name, FAL0));
1180       goto jleave;
1181    }
1182    rv = OKAY;
1183 jleave:
1184    NYD_LEAVE;
1185    return rv;
1186 }
1187 #endif /* new OpenSSL */
1188
1189 static enum okay
1190 load_crls(X509_STORE *store, enum okeys fok, enum okeys dok)
1191 {
1192    char *crl_file, *crl_dir;
1193 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1194    DIR *dirp;
1195    struct dirent *dp;
1196    char *fn = NULL;
1197    int fs = 0, ds, es;
1198 #endif
1199    enum okay rv = STOP;
1200    NYD_ENTER;
1201
1202    if ((crl_file = n_var_oklook(fok)) != NULL) {
1203 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1204       if ((crl_file = fexpand(crl_file, FEXP_LOCAL | FEXP_NOPROTO)) == NULL ||
1205             load_crl1(store, crl_file) != OKAY)
1206          goto jleave;
1207 #else
1208       n_err(_("This OpenSSL version is too old to use CRLs\n"));
1209       goto jleave;
1210 #endif
1211    }
1212
1213    if ((crl_dir = n_var_oklook(dok)) != NULL) {
1214 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1215       char *x;
1216       if ((x = fexpand(crl_dir, FEXP_LOCAL | FEXP_NOPROTO)) == NULL ||
1217             (dirp = opendir(crl_dir = x)) == NULL) {
1218          n_perr(crl_dir, 0);
1219          goto jleave;
1220       }
1221
1222       ds = strlen(crl_dir);
1223       fn = smalloc(fs = ds + 20);
1224       memcpy(fn, crl_dir, ds);
1225       fn[ds] = '/';
1226       while ((dp = readdir(dirp)) != NULL) {
1227          if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
1228                (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
1229             continue;
1230          if (dp->d_name[0] == '.')
1231             continue;
1232          if (ds + (es = strlen(dp->d_name)) + 2 < fs)
1233             fn = srealloc(fn, fs = ds + es + 20);
1234          memcpy(fn + ds + 1, dp->d_name, es + 1);
1235          if (load_crl1(store, fn) != OKAY) {
1236             closedir(dirp);
1237             free(fn);
1238             goto jleave;
1239          }
1240       }
1241       closedir(dirp);
1242       free(fn);
1243 #else /* old OpenSSL */
1244       n_err(_("This OpenSSL version is too old to use CRLs\n"));
1245       goto jleave;
1246 #endif
1247    }
1248 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1249    if (crl_file || crl_dir)
1250       X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK |
1251          X509_V_FLAG_CRL_CHECK_ALL);
1252 #endif
1253    rv = OKAY;
1254 jleave:
1255    NYD_LEAVE;
1256    return rv;
1257 }
1258
1259 FL enum okay
1260 ssl_open(struct url const *urlp, struct sock *sp)
1261 {
1262    SSL_CTX *ctxp;
1263    void *confp;
1264    char const *cp, *cp_base;
1265    size_t i;
1266    enum okay rv = STOP;
1267    NYD_ENTER;
1268
1269    a_xssl_init();
1270
1271    ssl_set_verify_level(urlp);
1272
1273    if ((ctxp = SSL_CTX_new(n_XSSL_CLIENT_METHOD())) == NULL) {
1274       ssl_gen_err(_("SSL_CTX_new() failed"));
1275       goto jleave;
1276    }
1277
1278    /* Available with OpenSSL 0.9.6 or later */
1279 #ifdef SSL_MODE_AUTO_RETRY
1280    SSL_CTX_set_mode(ctxp, SSL_MODE_AUTO_RETRY);
1281 #endif
1282
1283    if ((confp = _ssl_conf_setup(ctxp)) == NULL)
1284       goto jerr0;
1285
1286    /* TODO obsolete Check for *ssl-method*, warp to a *ssl-protocol* value */
1287    if ((cp = xok_vlook(ssl_method, urlp, OXM_ALL)) != NULL) {
1288       OBSOLETE(_("please use *ssl-protocol* instead of *ssl-method*"));
1289       if (options & OPT_VERB)
1290          n_err(_("*ssl-method*: %s\n"), cp);
1291       for (i = 0;;) {
1292          if (!asccasecmp(_ssl_methods[i].sm_name, cp)) {
1293             cp = _ssl_methods[i].sm_map;
1294             break;
1295          }
1296          if (++i == n_NELEM(_ssl_methods)) {
1297             n_err(_("Unsupported TLS/SSL method: %s\n"), cp);
1298             goto jerr1;
1299          }
1300       }
1301    }
1302    /* *ssl-protocol* */
1303    if ((cp_base = xok_vlook(ssl_protocol, urlp, OXM_ALL)) != NULL) {
1304       if (options & OPT_VERB)
1305          n_err(_("*ssl-protocol*: %s\n"), cp_base);
1306       cp = cp_base;
1307    }
1308    cp = (cp != NULL ? savecatsep(cp, ',', n_XSSL_DISABLED_PROTOCOLS)
1309          : n_XSSL_DISABLED_PROTOCOLS);
1310    if (!_ssl_conf(confp, a_XSSL_CT_PROTOCOL, cp))
1311       goto jerr1;
1312
1313    /* *ssl-cert* */
1314    if ((cp = xok_vlook(ssl_cert, urlp, OXM_ALL)) != NULL) {
1315       if (options & OPT_VERB)
1316          n_err(_("*ssl-cert* %s\n"), n_shexp_quote_cp(cp, FAL0));
1317       if ((cp_base = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
1318          n_err(_("*ssl-cert* value expansion failed: %s\n"),
1319             n_shexp_quote_cp(cp, FAL0));
1320          goto jerr1;
1321       }
1322       cp = cp_base;
1323       if (!_ssl_conf(confp, a_XSSL_CT_CERTIFICATE, cp))
1324          goto jerr1;
1325
1326       /* *ssl-key* */
1327       if ((cp_base = xok_vlook(ssl_key, urlp, OXM_ALL)) != NULL) {
1328          if (options & OPT_VERB)
1329             n_err(_("*ssl-key* %s\n"), n_shexp_quote_cp(cp_base, FAL0));
1330          if ((cp = fexpand(cp_base, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
1331             n_err(_("*ssl-key* value expansion failed: %s\n"),
1332                n_shexp_quote_cp(cp_base, FAL0));
1333             goto jerr1;
1334          }
1335       }
1336       if (!_ssl_conf(confp, a_XSSL_CT_PRIVATE_KEY, cp))
1337          goto jerr1;
1338    }
1339
1340    if ((cp = xok_vlook(ssl_cipher_list, urlp, OXM_ALL)) != NULL &&
1341          !_ssl_conf(confp, a_XSSL_CT_CIPHER_STRING, cp))
1342       goto jerr1;
1343
1344    if (!_ssl_load_verifications(ctxp))
1345       goto jerr1;
1346
1347    if (!_ssl_conf(confp, a_XSSL_CT_OPTIONS, NULL)) /* TODO *ssl-options* */
1348       goto jerr1;
1349
1350    /* Done with context setup, create our new per-connection structure */
1351    if (!_ssl_conf_finish(&confp, FAL0))
1352       goto jerr0;
1353
1354    if ((sp->s_ssl = SSL_new(ctxp)) == NULL) {
1355       ssl_gen_err(_("SSL_new() failed"));
1356       goto jerr0;
1357    }
1358
1359    SSL_set_fd(sp->s_ssl, sp->s_fd);
1360
1361    if (SSL_connect(sp->s_ssl) < 0) {
1362       ssl_gen_err(_("could not initiate SSL/TLS connection"));
1363       goto jerr2;
1364    }
1365
1366    if (ssl_verify_level != SSL_VERIFY_IGNORE) {
1367       if (ssl_check_host(sp, urlp) != OKAY) {
1368          n_err(_("Host certificate does not match: %s\n"), urlp->url_h_p.s);
1369          if (ssl_verify_decide() != OKAY)
1370             goto jerr2;
1371       }
1372    }
1373
1374    /* We're fully setup: since we don't reuse the SSL_CTX (pooh) keep it local
1375     * and free it right now -- it is reference counted by sp->s_ssl.. */
1376    SSL_CTX_free(ctxp);
1377    sp->s_use_ssl = 1;
1378    rv = OKAY;
1379 jleave:
1380    NYD_LEAVE;
1381    return rv;
1382 jerr2:
1383    SSL_free(sp->s_ssl);
1384    sp->s_ssl = NULL;
1385 jerr1:
1386    if (confp != NULL)
1387       _ssl_conf_finish(&confp, TRU1);
1388 jerr0:
1389    SSL_CTX_free(ctxp);
1390    goto jleave;
1391 }
1392
1393 FL void
1394 ssl_gen_err(char const *fmt, ...)
1395 {
1396    va_list ap;
1397    NYD_ENTER;
1398
1399    va_start(ap, fmt);
1400    n_verr(fmt, ap);
1401    va_end(ap);
1402
1403    n_err(_(": %s\n"), ERR_error_string(ERR_get_error(), NULL));
1404    NYD_LEAVE;
1405 }
1406
1407 FL int
1408 c_verify(void *vp)
1409 {
1410    int *msgvec = vp, *ip, ec = 0, rv = 1;
1411    n_XSSL_STACKOF(X509) *chain = NULL;
1412    X509_STORE *store = NULL;
1413    char *ca_dir, *ca_file;
1414    NYD_ENTER;
1415
1416    a_xssl_init();
1417
1418    ssl_verify_level = SSL_VERIFY_STRICT;
1419    if ((store = X509_STORE_new()) == NULL) {
1420       ssl_gen_err(_("Error creating X509 store"));
1421       goto jleave;
1422    }
1423    X509_STORE_set_verify_cb_func(store, &_ssl_verify_cb);
1424
1425    if ((ca_dir = ok_vlook(smime_ca_dir)) != NULL)
1426       ca_dir = fexpand(ca_dir, FEXP_LOCAL | FEXP_NOPROTO);
1427    if ((ca_file = ok_vlook(smime_ca_file)) != NULL)
1428       ca_file = fexpand(ca_file, FEXP_LOCAL | FEXP_NOPROTO);
1429
1430    if (ca_dir != NULL || ca_file != NULL) {
1431       if (X509_STORE_load_locations(store, ca_file, ca_dir) != 1) {
1432          ssl_gen_err(_("Error loading %s"),
1433             (ca_file != NULL) ? ca_file : ca_dir);
1434          goto jleave;
1435       }
1436    }
1437    if (!ok_blook(smime_no_default_ca)) {
1438       if (X509_STORE_set_default_paths(store) != 1) {
1439          ssl_gen_err(_("Error loading default CA locations"));
1440          goto jleave;
1441       }
1442    }
1443
1444    if (load_crls(store, ok_v_smime_crl_file, ok_v_smime_crl_dir) != OKAY)
1445       goto jleave;
1446
1447    srelax_hold();
1448    for (ip = msgvec; *ip != 0; ++ip) {
1449       struct message *mp = message + *ip - 1;
1450       setdot(mp);
1451       ec |= smime_verify(mp, *ip, chain, store);
1452       srelax();
1453    }
1454    srelax_rele();
1455
1456    if ((rv = ec) != 0)
1457       exit_status |= EXIT_ERR;
1458 jleave:
1459    if (store != NULL)
1460       X509_STORE_free(store);
1461    NYD_LEAVE;
1462    return rv;
1463 }
1464
1465 FL FILE *
1466 smime_sign(FILE *ip, char const *addr)
1467 {
1468    FILE *rv = NULL, *sp = NULL, *fp = NULL, *bp, *hp;
1469    X509 *cert = NULL;
1470    n_XSSL_STACKOF(X509) *chain = NULL;
1471    EVP_PKEY *pkey = NULL;
1472    BIO *bb, *sb;
1473    PKCS7 *pkcs7;
1474    EVP_MD const *md;
1475    char const *name;
1476    bool_t bail = FAL0;
1477    NYD_ENTER;
1478
1479    assert(addr != NULL);
1480
1481    a_xssl_init();
1482
1483    if (addr == NULL) {
1484       n_err(_("No *from* address for signing specified\n"));
1485       goto jleave;
1486    }
1487    if ((fp = smime_sign_cert(addr, NULL, 1)) == NULL)
1488       goto jleave;
1489
1490    if ((pkey = PEM_read_PrivateKey(fp, NULL, &ssl_password_cb, NULL)) == NULL) {
1491       ssl_gen_err(_("Error reading private key from"));
1492       goto jleave;
1493    }
1494
1495    rewind(fp);
1496    if ((cert = PEM_read_X509(fp, NULL, &ssl_password_cb, NULL)) == NULL) {
1497       ssl_gen_err(_("Error reading signer certificate from"));
1498       goto jleave;
1499    }
1500    Fclose(fp);
1501    fp = NULL;
1502
1503    if ((name = _smime_sign_include_certs(addr)) != NULL &&
1504          !_smime_sign_include_chain_creat(&chain, name))
1505       goto jleave;
1506
1507    name = NULL;
1508    if ((md = _smime_sign_digest(addr, &name)) == NULL)
1509       goto jleave;
1510
1511    if ((sp = Ftmp(NULL, "smimesign", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1512          NULL) {
1513       n_perr(_("tempfile"), 0);
1514       goto jleave;
1515    }
1516
1517    rewind(ip);
1518    if (smime_split(ip, &hp, &bp, -1, 0) == STOP)
1519       goto jerr1;
1520
1521    sb = NULL;
1522    pkcs7 = NULL;
1523
1524    if ((bb = BIO_new_fp(bp, BIO_NOCLOSE)) == NULL ||
1525          (sb = BIO_new_fp(sp, BIO_NOCLOSE)) == NULL) {
1526       ssl_gen_err(_("Error creating BIO signing objects"));
1527       bail = TRU1;
1528       goto jerr;
1529    }
1530
1531 #undef _X
1532 #define _X  PKCS7_DETACHED | PKCS7_PARTIAL
1533    if ((pkcs7 = PKCS7_sign(NULL, NULL, chain, bb, _X)) == NULL) {
1534       ssl_gen_err(_("Error creating the PKCS#7 signing object"));
1535       bail = TRU1;
1536       goto jerr;
1537    }
1538    if (PKCS7_sign_add_signer(pkcs7, cert, pkey, md, _X) == NULL) {
1539       ssl_gen_err(_("Error setting PKCS#7 signing object signer"));
1540       bail = TRU1;
1541       goto jerr;
1542    }
1543    if (!PKCS7_final(pkcs7, bb, _X)) {
1544       ssl_gen_err(_("Error finalizing the PKCS#7 signing object"));
1545       bail = TRU1;
1546       goto jerr;
1547    }
1548 #undef _X
1549
1550    if (PEM_write_bio_PKCS7(sb, pkcs7) == 0) {
1551       ssl_gen_err(_("Error writing signed S/MIME data"));
1552       bail = TRU1;
1553       /*goto jerr*/
1554    }
1555 jerr:
1556    if (pkcs7 != NULL)
1557       PKCS7_free(pkcs7);
1558    if (sb != NULL)
1559       BIO_free(sb);
1560    if (bb != NULL)
1561       BIO_free(bb);
1562    if (!bail) {
1563       rewind(bp);
1564       fflush_rewind(sp);
1565       rv = smime_sign_assemble(hp, bp, sp, name);
1566    } else
1567 jerr1:
1568       Fclose(sp);
1569
1570 jleave:
1571    if (chain != NULL)
1572       sk_X509_pop_free(chain, X509_free);
1573    if (cert != NULL)
1574       X509_free(cert);
1575    if (pkey != NULL)
1576       EVP_PKEY_free(pkey);
1577    if (fp != NULL)
1578       Fclose(fp);
1579    NYD_LEAVE;
1580    return rv;
1581 }
1582
1583 FL FILE *
1584 smime_encrypt(FILE *ip, char const *xcertfile, char const *to)
1585 {
1586    FILE *rv = NULL, *yp, *fp, *bp, *hp;
1587    X509 *cert;
1588    PKCS7 *pkcs7;
1589    BIO *bb, *yb;
1590    n_XSSL_STACKOF(X509) *certs;
1591    EVP_CIPHER const *cipher;
1592    char *certfile;
1593    bool_t bail = FAL0;
1594    NYD_ENTER;
1595
1596    if ((certfile = fexpand(xcertfile, FEXP_LOCAL | FEXP_NOPROTO)) == NULL)
1597       goto jleave;
1598
1599    a_xssl_init();
1600
1601    if ((cipher = _smime_cipher(to)) == NULL)
1602       goto jleave;
1603    if ((fp = Fopen(certfile, "r")) == NULL) {
1604       n_perr(certfile, 0);
1605       goto jleave;
1606    }
1607
1608    if ((cert = PEM_read_X509(fp, NULL, &ssl_password_cb, NULL)) == NULL) {
1609       ssl_gen_err(_("Error reading encryption certificate from %s"),
1610          n_shexp_quote_cp(certfile, FAL0));
1611       bail = TRU1;
1612    }
1613    Fclose(fp);
1614    if (bail)
1615       goto jleave;
1616    bail = FAL0;
1617
1618    certs = sk_X509_new_null();
1619    sk_X509_push(certs, cert);
1620
1621    if ((yp = Ftmp(NULL, "smimeenc", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1622          NULL) {
1623       n_perr(_("tempfile"), 0);
1624       goto jerr1;
1625    }
1626
1627    rewind(ip);
1628    if (smime_split(ip, &hp, &bp, -1, 0) == STOP) {
1629       Fclose(yp);
1630       goto jerr1;
1631    }
1632
1633    yb = NULL;
1634    if ((bb = BIO_new_fp(bp, BIO_NOCLOSE)) == NULL ||
1635          (yb = BIO_new_fp(yp, BIO_NOCLOSE)) == NULL) {
1636       ssl_gen_err(_("Error creating BIO encryption objects"));
1637       bail = TRU1;
1638       goto jerr2;
1639    }
1640    if ((pkcs7 = PKCS7_encrypt(certs, bb, cipher, 0)) == NULL) {
1641       ssl_gen_err(_("Error creating the PKCS#7 encryption object"));
1642       bail = TRU1;
1643       goto jerr2;
1644    }
1645    if (PEM_write_bio_PKCS7(yb, pkcs7) == 0) {
1646       ssl_gen_err(_("Error writing encrypted S/MIME data"));
1647       bail = TRU1;
1648       /* goto jerr2 */
1649    }
1650
1651 jerr2:
1652    if (bb != NULL)
1653       BIO_free(bb);
1654    if (yb != NULL)
1655       BIO_free(yb);
1656    Fclose(bp);
1657    if (bail)
1658       Fclose(yp);
1659    else {
1660       fflush_rewind(yp);
1661       rv = smime_encrypt_assemble(hp, yp);
1662    }
1663 jerr1:
1664    sk_X509_pop_free(certs, X509_free);
1665 jleave:
1666    NYD_LEAVE;
1667    return rv;
1668 }
1669
1670 FL struct message *
1671 smime_decrypt(struct message *m, char const *to, char const *cc,
1672    bool_t signcall)
1673 {
1674    struct message *rv;
1675    FILE *fp, *bp, *hp, *op;
1676    X509 *cert;
1677    PKCS7 *pkcs7;
1678    EVP_PKEY *pkey;
1679    BIO *bb, *pb, *ob;
1680    long size;
1681    FILE *yp;
1682    NYD_ENTER;
1683
1684    rv = NULL;
1685    cert = NULL;
1686    pkey = NULL;
1687    size = m->m_size;
1688
1689    if ((yp = setinput(&mb, m, NEED_BODY)) == NULL)
1690       goto jleave;
1691
1692    a_xssl_init();
1693
1694    if ((fp = smime_sign_cert(to, cc, 0)) != NULL) {
1695       pkey = PEM_read_PrivateKey(fp, NULL, &ssl_password_cb, NULL);
1696       if (pkey == NULL) {
1697          ssl_gen_err(_("Error reading private key"));
1698          Fclose(fp);
1699          goto jleave;
1700       }
1701       rewind(fp);
1702
1703       if ((cert = PEM_read_X509(fp, NULL, &ssl_password_cb, NULL)) == NULL) {
1704          ssl_gen_err(_("Error reading decryption certificate"));
1705          Fclose(fp);
1706          EVP_PKEY_free(pkey);
1707          goto jleave;
1708       }
1709       Fclose(fp);
1710    }
1711
1712    if ((op = Ftmp(NULL, "smimedec", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1713          NULL) {
1714       n_perr(_("tempfile"), 0);
1715       goto j_ferr;
1716    }
1717
1718    if (smime_split(yp, &hp, &bp, size, 1) == STOP)
1719       goto jferr;
1720
1721    if ((ob = BIO_new_fp(op, BIO_NOCLOSE)) == NULL ||
1722          (bb = BIO_new_fp(bp, BIO_NOCLOSE)) == NULL) {
1723       ssl_gen_err(_("Error creating BIO decryption objects"));
1724       goto jferr;
1725    }
1726    if ((pkcs7 = SMIME_read_PKCS7(bb, &pb)) == NULL) {
1727       ssl_gen_err(_("Error reading PKCS#7 object"));
1728 jferr:
1729       Fclose(op);
1730 j_ferr:
1731       if (cert)
1732          X509_free(cert);
1733       if (pkey)
1734          EVP_PKEY_free(pkey);
1735       goto jleave;
1736    }
1737
1738    if (PKCS7_type_is_signed(pkcs7)) {
1739       if (signcall) {
1740          setinput(&mb, m, NEED_BODY);
1741          rv = (struct message*)-1;
1742          goto jerr2;
1743       }
1744       if (PKCS7_verify(pkcs7, NULL, NULL, NULL, ob,
1745             PKCS7_NOVERIFY | PKCS7_NOSIGS) != 1)
1746          goto jerr;
1747       fseek(hp, 0L, SEEK_END);
1748       fprintf(hp, "X-Encryption-Cipher: none\n");
1749       fflush(hp);
1750       rewind(hp);
1751    } else if (pkey == NULL) {
1752       n_err(_("No appropriate private key found\n"));
1753       goto jerr2;
1754    } else if (cert == NULL) {
1755       n_err(_("No appropriate certificate found\n"));
1756       goto jerr2;
1757    } else if (PKCS7_decrypt(pkcs7, pkey, cert, ob, 0) != 1) {
1758 jerr:
1759       ssl_gen_err(_("Error decrypting PKCS#7 object"));
1760 jerr2:
1761       BIO_free(bb);
1762       BIO_free(ob);
1763       Fclose(op);
1764       Fclose(bp);
1765       Fclose(hp);
1766       if (cert != NULL)
1767          X509_free(cert);
1768       if (pkey != NULL)
1769          EVP_PKEY_free(pkey);
1770       goto jleave;
1771    }
1772    BIO_free(bb);
1773    BIO_free(ob);
1774    if (cert)
1775       X509_free(cert);
1776    if (pkey)
1777       EVP_PKEY_free(pkey);
1778    fflush_rewind(op);
1779    Fclose(bp);
1780
1781    rv = smime_decrypt_assemble(m, hp, op);
1782 jleave:
1783    NYD_LEAVE;
1784    return rv;
1785 }
1786
1787 FL enum okay
1788 smime_certsave(struct message *m, int n, FILE *op)
1789 {
1790    struct message *x;
1791    char *to, *cc, *cnttype;
1792    int c, i;
1793    FILE *fp, *ip;
1794    off_t size;
1795    BIO *fb, *pb;
1796    PKCS7 *pkcs7;
1797    n_XSSL_STACKOF(X509) *certs, *chain = NULL;
1798    X509 *cert;
1799    enum okay rv = STOP;
1800    NYD_ENTER;
1801
1802    a_xssl_msgno = (size_t)n;
1803 jloop:
1804    to = hfield1("to", m);
1805    cc = hfield1("cc", m);
1806    cnttype = hfield1("content-type", m);
1807
1808    if ((ip = setinput(&mb, m, NEED_BODY)) == NULL)
1809       goto jleave;
1810
1811 #undef _X
1812 #undef _Y
1813 #define _X     (sizeof("application/") -1)
1814 #define _Y(X)  X, sizeof(X) -1
1815    if (cnttype && is_asccaseprefix(cnttype, "application/") &&
1816          (!ascncasecmp(cnttype + _X, _Y("pkcs7-mime")) ||
1817           !ascncasecmp(cnttype + _X, _Y("x-pkcs7-mime")))) {
1818 #undef _Y
1819 #undef _X
1820       if ((x = smime_decrypt(m, to, cc, 1)) == NULL)
1821          goto jleave;
1822       if (x != (struct message*)-1) {
1823          m = x;
1824          goto jloop;
1825       }
1826    }
1827    size = m->m_size;
1828
1829    if ((fp = Ftmp(NULL, "smimecert", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1830          NULL) {
1831       n_perr(_("tempfile"), 0);
1832       goto jleave;
1833    }
1834
1835    while (size-- > 0) {
1836       c = getc(ip);
1837       putc(c, fp);
1838    }
1839    fflush(fp);
1840
1841    rewind(fp);
1842    if ((fb = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
1843       ssl_gen_err("Error creating BIO object for message %d", n);
1844       Fclose(fp);
1845       goto jleave;
1846    }
1847
1848    if ((pkcs7 = SMIME_read_PKCS7(fb, &pb)) == NULL) {
1849       ssl_gen_err(_("Error reading PKCS#7 object for message %d"), n);
1850       BIO_free(fb);
1851       Fclose(fp);
1852       goto jleave;
1853    }
1854    BIO_free(fb);
1855    Fclose(fp);
1856
1857    certs = PKCS7_get0_signers(pkcs7, chain, 0);
1858    if (certs == NULL) {
1859       n_err(_("No certificates found in message %d\n"), n);
1860       goto jleave;
1861    }
1862
1863    for (i = 0; i < sk_X509_num(certs); ++i) {
1864       cert = sk_X509_value(certs, i);
1865       if (X509_print_fp(op, cert) == 0 || PEM_write_X509(op, cert) == 0) {
1866          ssl_gen_err(_("Error writing certificate %d from message %d"),
1867             i, n);
1868          goto jleave;
1869       }
1870    }
1871    rv = OKAY;
1872 jleave:
1873    NYD_LEAVE;
1874    return rv;
1875 }
1876 #endif /* HAVE_XSSL */
1877
1878 /* s-it-mode */