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 - 2017 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 /* X509_STORE_set_flags */
 123 #undef a_XSSL_X509_V_ANY
 124 #ifndef X509_V_FLAG_NO_ALT_CHAINS
 125 # define X509_V_FLAG_NO_ALT_CHAINS -1
 126 #else
 127 # undef a_XSSL_X509_V_ANY
 128 # define a_XSSL_X509_V_ANY
 129 #endif
 130 #ifndef X509_V_FLAG_NO_CHECK_TIME
 131 # define X509_V_FLAG_NO_CHECK_TIME -1
 132 #else
 133 # undef a_XSSL_X509_V_ANY
 134 # define a_XSSL_X509_V_ANY
 135 #endif
 136 #ifndef X509_V_FLAG_PARTIAL_CHAIN
 137 # define X509_V_FLAG_PARTIAL_CHAIN -1
 138 #else
 139 # undef a_XSSL_X509_V_ANY
 140 # define a_XSSL_X509_V_ANY
 141 #endif
 142 #ifndef X509_V_FLAG_X509_STRICT
 143 # define X509_V_FLAG_X509_STRICT -1
 144 #else
 145 # undef a_XSSL_X509_V_ANY
 146 # define a_XSSL_X509_V_ANY
 147 #endif
 148 #ifndef X509_V_FLAG_TRUSTED_FIRST
 149 # define X509_V_FLAG_TRUSTED_FIRST -1
 150 #else
 151 # undef a_XSSL_X509_V_ANY
 152 # define a_XSSL_X509_V_ANY
 153 #endif
 154
 155 /* Some became meaningless with HAVE_XSSL_OPENSSL>=0x10100 */
 156 enum a_xssl_state{
 157    a_XSSL_S_INIT = 1<<0,
 158    a_XSSL_S_RAND_INIT = 1<<1,
 159    a_XSSL_S_EXIT_HDL = 1<<2,
 160    a_XSSL_S_CONF_LOAD = 1<<3,
 161    a_XSSL_S_ALGO_LOAD = 1<<4,
 162
 163    a_XSSL_S_VERIFY_ERROR = 1<<7
 164 };
 165
 166 /* We go for the OpenSSL v1.0.2+ SSL_CONF_CTX if available even if
 167  * the library does internally what we'd otherwise do ourselfs.
 168  * But eventually we can drop the direct use cases */
 169 enum a_xssl_conf_type{
 170    a_XSSL_CT_CERTIFICATE,
 171    a_XSSL_CT_CIPHER_STRING,
 172    a_XSSL_CT_CURVES,
 173    a_XSSL_CT_PRIVATE_KEY,
 174    a_XSSL_CT_OPTIONS,
 175    a_XSSL_CT_PROTOCOL
 176 };
 177
 178 struct ssl_method { /* TODO v15 obsolete */
 179    char const  sm_name[8];
 180    char const  sm_map[16];
 181 };
 182
 183 #ifndef HAVE_XSSL_CONF_CTX
 184 struct a_xssl_protocol{
 185    char const *sp_name;
 186    sl_i sp_flag;
 187 };
 188 #endif
 189
 190 struct a_xssl_smime_cipher{
 191    char const sc_name[8];
 192    EVP_CIPHER const *(*sc_fun)(void);
 193 };
 194
 195 struct a_xssl_smime_digest{
 196    char const sd_name[8];
 197    EVP_MD const *(*sd_fun)(void);
 198 };
 199
 200 struct a_xssl_x509_v_flags{
 201    char const xvf_name[20];
 202    si32_t xvf_flag;
 203 };
 204
 205 /* Supported SSL/TLS methods: update manual on change! */
 206
 207 static struct ssl_method const   _ssl_methods[] = { /* TODO obsolete */
 208    {"auto",    "ALL,-SSLv2"},
 209    {"ssl3",    "-ALL,SSLv3"},
 210    {"tls1",    "-ALL,TLSv1"},
 211    {"tls1.1",  "-ALL,TLSv1.1"},
 212    {"tls1.2",  "-ALL,TLSv1.2"}
 213 };
 214
 215 /* Update manual on change! */
 216 #ifndef HAVE_XSSL_CONF_CTX
 217 static struct a_xssl_protocol const a_xssl_protocols[] = {
 218    {"ALL", SSL_OP_NO_SSL_MASK},
 219    {"TLSv1.2", SSL_OP_NO_TLSv1_2},
 220    {"TLSv1.1", SSL_OP_NO_TLSv1_1},
 221    {"TLSv1", SSL_OP_NO_TLSv1},
 222    {"SSLv3", SSL_OP_NO_SSLv3},
 223    {"SSLv2", 0}
 224 };
 225 #endif
 226
 227 /* Supported S/MIME cipher algorithms */
 228 static struct a_xssl_smime_cipher const a_xssl_smime_ciphers[] = { /* Manual! */
 229 #ifndef OPENSSL_NO_AES
 230 # define a_XSSL_SMIME_DEFAULT_CIPHER EVP_aes_128_cbc /* According to RFC 5751 */
 231    {"aes128", &EVP_aes_128_cbc},
 232    {"aes256", &EVP_aes_256_cbc},
 233    {"aes192", &EVP_aes_192_cbc},
 234 #endif
 235 #ifndef OPENSSL_NO_DES
 236 # ifndef a_XSSL_SMIME_DEFAULT_CIPHER
 237 #  define a_XSSL_SMIME_DEFAULT_CIPHER EVP_des_ede3_cbc
 238 # endif
 239    {"des3", &EVP_des_ede3_cbc},
 240    {"des", &EVP_des_cbc},
 241 #endif
 242 };
 243 #ifndef a_XSSL_SMIME_DEFAULT_CIPHER
 244 # error Your OpenSSL library does not include the necessary
 245 # error cipher algorithms that are required to support S/MIME
 246 #endif
 247
 248 #ifndef OPENSSL_NO_AES
 249 /* TODO obsolete a_xssl_smime_ciphers_obs */
 250 static struct a_xssl_smime_cipher const a_xssl_smime_ciphers_obs[] = {
 251    {"aes-128", &EVP_aes_128_cbc},
 252    {"aes-256", &EVP_aes_256_cbc},
 253    {"aes-192", &EVP_aes_192_cbc}
 254 };
 255 #endif
 256
 257 /* Supported S/MIME message digest algorithms */
 258 static struct a_xssl_smime_digest const a_xssl_smime_digests[] = { /* Manual! */
 259 #define a_XSSL_SMIME_DEFAULT_DIGEST EVP_sha1 /* According to RFC 5751 */
 260 #define a_XSSL_SMIME_DEFAULT_DIGEST_S  "sha1"
 261    {"sha1", &EVP_sha1},
 262    {"sha256", &EVP_sha256},
 263    {"sha512", &EVP_sha512},
 264    {"sha384", &EVP_sha384},
 265    {"sha224", &EVP_sha224},
 266 #ifndef OPENSSL_NO_MD5
 267    {"md5", &EVP_md5},
 268 #endif
 269 };
 270
 271 /* X509_STORE_set_flags() for *{smime,ssl}-ca-flags* */
 272 static struct a_xssl_x509_v_flags const a_xssl_x509_v_flags[] = { /* Manual! */
 273    {"no-alt-chains", X509_V_FLAG_NO_ALT_CHAINS},
 274    {"no-check-time", X509_V_FLAG_NO_CHECK_TIME},
 275    {"partial-chain", X509_V_FLAG_PARTIAL_CHAIN},
 276    {"strict", X509_V_FLAG_X509_STRICT},
 277    {"trusted-first", X509_V_FLAG_TRUSTED_FIRST},
 278 };
 279
 280 static enum a_xssl_state a_xssl_state;
 281 static size_t a_xssl_msgno;
 282
 283 static bool_t a_xssl_rand_init(void);
 284 #if HAVE_XSSL_OPENSSL < 0x10100
 285 # ifdef HAVE_SSL_ALL_ALGORITHMS
 286 static void a_xssl__load_algos(void);
 287 #  define a_xssl_load_algos a_xssl__load_algos
 288 # endif
 289 # if defined HAVE_XSSL_CONFIG || defined HAVE_SSL_ALL_ALGORITHMS
 290 static void a_xssl_atexit(void);
 291 # endif
 292 #endif
 293 #ifndef a_xssl_load_algos
 294 # define a_xssl_load_algos() do{;}while(0)
 295 #endif
 296
 297 static bool_t     _ssl_parse_asn1_time(ASN1_TIME const *atp,
 298                      char *bdat, size_t blen);
 299 static int        _ssl_verify_cb(int success, X509_STORE_CTX *store);
 300
 301 /* *smime-ca-flags*, *ssl-ca-flags* */
 302 static void a_xssl_ca_flags(X509_STORE *store, char const *flags);
 303
 304 /* SSL_CTX configuration */
 305 static void *     _ssl_conf_setup(SSL_CTX *ctxp);
 306 static bool_t     _ssl_conf(void *confp, enum a_xssl_conf_type ct,
 307                      char const *value);
 308 static bool_t     _ssl_conf_finish(void **confp, bool_t error);
 309
 310 static bool_t     _ssl_load_verifications(SSL_CTX *ctxp);
 311
 312 static enum okay  ssl_check_host(struct sock *sp, struct url const *urlp);
 313
 314 static int        smime_verify(struct message *m, int n,
 315                      n_XSSL_STACKOF(X509) *chain, X509_STORE *store);
 316 static EVP_CIPHER const * _smime_cipher(char const *name);
 317 static int        ssl_password_cb(char *buf, int size, int rwflag,
 318                      void *userdata);
 319 static FILE *     smime_sign_cert(char const *xname, char const *xname2,
 320                      bool_t dowarn, char const **match);
 321 static char const * _smime_sign_include_certs(char const *name);
 322 static bool_t     _smime_sign_include_chain_creat(n_XSSL_STACKOF(X509) **chain,
 323                      char const *cfiles, char const *addr);
 324 static EVP_MD const * _smime_sign_digest(char const *name,
 325                         char const **digname);
 326 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
 327 static enum okay  load_crl1(X509_STORE *store, char const *name);
 328 #endif
 329 static enum okay  load_crls(X509_STORE *store, enum okeys fok, enum okeys dok);
 330
 331 static bool_t
 332 a_xssl_rand_init(void){
 333 #define a_XSSL_RAND_ENTROPY 32
 334    char b64buf[a_XSSL_RAND_ENTROPY * 5 +1], *randfile;
 335    char const *cp, *x;
 336    bool_t err;
 337    NYD2_ENTER;
 338
 339    err = TRU1;
 340    randfile = NULL;
 341
 342    /* Shall use some external daemon? */ /* TODO obsolete *ssl_rand_egd* */
 343    if((cp = ok_vlook(ssl_rand_egd)) != NULL){ /* TODO no one supports it now! */
 344       n_OBSOLETE(_("all *SSL libraries removed *ssl-rand-egd* support"));
 345 #ifdef HAVE_XSSL_RAND_EGD
 346       if((x = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) != NULL &&
 347             RAND_egd(cp = x) != -1){
 348          err = FAL0;
 349          goto jleave;
 350       }
 351       n_err(_("*ssl_rand_egd* daemon at %s not available\n"),
 352          n_shexp_quote_cp(cp, FAL0));
 353 #else
 354       if(n_poption & n_PO_D_VV)
 355          n_err(_("*ssl_rand_egd* (%s): unsupported by SSL library\n"),
 356             n_shexp_quote_cp(cp, FAL0));
 357 #endif
 358    }
 359
 360    /* Prefer possible user setting */
 361    if((cp = ok_vlook(ssl_rand_file)) != NULL){
 362       x = NULL;
 363       if(*cp != '\0'){
 364          if((x = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL)
 365             n_err(_("*ssl-rand-file*: expansion of %s failed "
 366                   "(using OpenSSL default)\n"),
 367                n_shexp_quote_cp(cp, FAL0));
 368       }
 369       cp = x;
 370    }
 371    if(cp == NULL){
 372       randfile = n_lofi_alloc(PATH_MAX);
 373       if((cp = RAND_file_name(randfile, PATH_MAX)) == NULL){
 374          n_err(_("*ssl-rand-file*: no SSL entropy file, can't seed PRNG\n"));
 375          goto jleave;
 376       }
 377    }
 378
 379    (void)RAND_load_file(cp, a_XSSL_RAND_LOAD_FILE_MAXBYTES);
 380
 381    /* And feed in some data, then write the updated file.
 382     * While this rather feeds the PRNG with itself in the n_RANDOM_USE_XSSL
 383     * case, let us stir the buffer a little bit.
 384     * Estimate a low but likely still too high number of entropy bytes, use
 385     * 20%: base64 uses 3 input = 4 output bytes relation, and the base64
 386     * alphabet is a 6 bit one */
 387    n_LCTAV(n_RANDOM_USE_XSSL == 0 || n_RANDOM_USE_XSSL == 1);
 388    for(x = (char*)-1;;){
 389       RAND_add(n_random_create_buf(b64buf, sizeof(b64buf) -1, NULL),
 390          sizeof(b64buf) -1, a_XSSL_RAND_ENTROPY);
 391       if((x = (char*)((uintptr_t)x >> (1 + (n_RANDOM_USE_XSSL * 3)))) == NULL){
 392          err = (RAND_status() == 0);
 393          break;
 394       }
 395 #if !n_RANDOM_USE_XSSL
 396       if(!(err = (RAND_status() == 0)))
 397          break;
 398 #endif
 399    }
 400
 401    if(!err)
 402       err = (RAND_write_file(cp) == -1);
 403
 404 jleave:
 405    if(randfile != NULL)
 406       n_lofi_free(randfile);
 407    if(err)
 408       n_panic(_("Cannot seed the *SSL PseudoRandomNumberGenerator, "
 409             "RAND_status() is 0!\n"
 410          "  Please set *ssl-rand-file* to a file with sufficient entropy.\n"
 411          "  On a machine with entropy: "
 412             "\"$ dd if=/dev/urandom of=FILE bs=1024 count=1\"\n"));
 413    NYD2_LEAVE;
 414    return err;
 415 }
 416
 417 static void
 418 a_xssl_init(void)
 419 {
 420 #ifdef HAVE_XSSL_CONFIG
 421    char const *cp;
 422 #endif
 423    NYD_ENTER;
 424
 425    if(!(a_xssl_state & a_XSSL_S_INIT)){
 426 #if HAVE_XSSL_OPENSSL >= 0x10100
 427       OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS |
 428          OPENSSL_INIT_LOAD_CRYPTO_STRINGS
 429 # ifdef HAVE_SSL_ALL_ALGORITHMS
 430             | OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS
 431 # endif
 432          , NULL);
 433 # ifdef HAVE_SSL_ALL_ALGORITHMS
 434       a_xssl_state |= a_XSSL_S_ALGO_LOAD;
 435 # endif
 436 #else
 437       SSL_load_error_strings();
 438       SSL_library_init();
 439 #endif
 440       a_xssl_state |= a_XSSL_S_INIT;
 441    }
 442
 443    /* Load openssl.cnf or whatever was given in *ssl-config-file* */
 444 #ifdef HAVE_XSSL_CONFIG
 445    if(!(a_xssl_state & a_XSSL_S_CONF_LOAD) &&
 446          (cp = ok_vlook(ssl_config_file)) != NULL){
 447       ul_i flags = CONF_MFLAGS_IGNORE_MISSING_FILE;
 448
 449       if(*cp == '\0'){
 450          cp = NULL;
 451          flags = 0;
 452       }
 453       if(CONF_modules_load_file(cp, n_uagent, flags) == 1){
 454          a_xssl_state |= a_XSSL_S_CONF_LOAD;
 455 # if HAVE_XSSL_OPENSSL < 0x10100
 456          if(!(a_xssl_state & a_XSSL_S_EXIT_HDL)){
 457             a_xssl_state |= a_XSSL_S_EXIT_HDL;
 458             atexit(&a_xssl_atexit); /* TODO generic program-wide event mech. */
 459          }
 460 # endif
 461       }else
 462          ssl_gen_err(_("Ignoring CONF_modules_load_file() load error"));
 463    }
 464 #endif
 465
 466    if(!(a_xssl_state & a_XSSL_S_RAND_INIT) && a_xssl_rand_init())
 467       a_xssl_state |= a_XSSL_S_RAND_INIT;
 468    NYD_LEAVE;
 469 }
 470
 471 #if HAVE_XSSL_OPENSSL < 0x10100
 472 # ifdef HAVE_SSL_ALL_ALGORITHMS
 473 static void
 474 a_xssl__load_algos(void){
 475    NYD2_ENTER;
 476    if(!(a_xssl_state & a_XSSL_S_ALGO_LOAD)){
 477       a_xssl_state |= a_XSSL_S_ALGO_LOAD;
 478       OpenSSL_add_all_algorithms();
 479
 480       if(!(a_xssl_state & a_XSSL_S_EXIT_HDL)){
 481          a_xssl_state |= a_XSSL_S_EXIT_HDL;
 482          atexit(&a_xssl_atexit); /* TODO generic program-wide event mech. */
 483       }
 484    }
 485    NYD2_LEAVE;
 486 }
 487 # endif
 488
 489 # if defined HAVE_XSSL_CONFIG || defined HAVE_SSL_ALL_ALGORITHMS
 490 static void
 491 a_xssl_atexit(void){
 492    NYD2_ENTER;
 493 #  ifdef HAVE_XSSL_CONFIG
 494    if(a_xssl_state & a_XSSL_S_CONF_LOAD)
 495       CONF_modules_free();
 496 #  endif
 497
 498 #  ifdef HAVE_SSL_ALL_ALGORITHMS
 499    if(a_xssl_state & a_XSSL_S_ALGO_LOAD)
 500       EVP_cleanup();
 501 #  endif
 502    NYD2_LEAVE;
 503 }
 504 # endif
 505 #endif /* HAVE_XSSL_OPENSSL < 0x10100 */
 506
 507 static bool_t
 508 _ssl_parse_asn1_time(ASN1_TIME const *atp, char *bdat, size_t blen)
 509 {
 510    BIO *mbp;
 511    char *mcp;
 512    long l;
 513    NYD_ENTER;
 514
 515    mbp = BIO_new(BIO_s_mem());
 516
 517    if (ASN1_TIME_print(mbp, atp) && (l = BIO_get_mem_data(mbp, &mcp)) > 0)
 518       snprintf(bdat, blen, "%.*s", (int)l, mcp);
 519    else {
 520       snprintf(bdat, blen, _("Bogus certificate date: %.*s"),
 521          /*is (int)*/atp->length, (char const*)atp->data);
 522       mcp = NULL;
 523    }
 524
 525    BIO_free(mbp);
 526    NYD_LEAVE;
 527    return (mcp != NULL);
 528 }
 529
 530 static int
 531 _ssl_verify_cb(int success, X509_STORE_CTX *store)
 532 {
 533    char data[256];
 534    X509 *cert;
 535    int rv = TRU1;
 536    NYD_ENTER;
 537
 538    if (success && !(n_poption & n_PO_D_V))
 539       goto jleave;
 540
 541    if (a_xssl_msgno != 0) {
 542       n_err(_("Message %lu:\n"), (ul_i)a_xssl_msgno);
 543       a_xssl_msgno = 0;
 544    }
 545    n_err(_(" Certificate depth %d %s\n"),
 546       X509_STORE_CTX_get_error_depth(store), (success ? n_empty : V_(n_error)));
 547
 548    if ((cert = X509_STORE_CTX_get_current_cert(store)) != NULL) {
 549       X509_NAME_oneline(X509_get_subject_name(cert), data, sizeof data);
 550       n_err(_("  subject = %s\n"), data);
 551
 552       _ssl_parse_asn1_time(a_xssl_X509_get_notBefore(cert), data, sizeof data);
 553       n_err(_("  notBefore = %s\n"), data);
 554
 555       _ssl_parse_asn1_time(a_xssl_X509_get_notAfter(cert), data, sizeof data);
 556       n_err(_("  notAfter = %s\n"), data);
 557
 558       X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof data);
 559       n_err(_("  issuer = %s\n"), data);
 560    }
 561
 562    if (!success) {
 563       int err = X509_STORE_CTX_get_error(store);
 564
 565       n_err(_("  err %i: %s\n"), err, X509_verify_cert_error_string(err));
 566       a_xssl_state |= a_XSSL_S_VERIFY_ERROR;
 567    }
 568
 569    if (!success && ssl_verify_decide() != OKAY)
 570       rv = FAL0;
 571 jleave:
 572    NYD_LEAVE;
 573    return rv;
 574 }
 575
 576 static void
 577 a_xssl_ca_flags(X509_STORE *store, char const *flags){
 578    NYD2_ENTER;
 579    if(flags != NULL){
 580       char *iolist, *cp;
 581
 582       iolist = savestr(flags);
 583 jouter:
 584       while((cp = n_strsep(&iolist, ',', TRU1)) != NULL){
 585          struct a_xssl_x509_v_flags const *xvfp;
 586
 587          for(xvfp = &a_xssl_x509_v_flags[0];
 588                xvfp < &a_xssl_x509_v_flags[n_NELEM(a_xssl_x509_v_flags)];
 589                ++xvfp)
 590             if(!asccasecmp(cp, xvfp->xvf_name)){
 591                if(xvfp->xvf_flag != -1){
 592 #ifdef a_XSSL_X509_V_ANY
 593                   X509_STORE_set_flags(store, xvfp->xvf_flag);
 594 #endif
 595                }else if(n_poption & n_PO_D_V)
 596                   n_err(_("*{smime,ssl}-ca-flags*: "
 597                      "directive not supported: %s\n"), cp);
 598                goto jouter;
 599             }
 600          n_err(_("*{smime,ssl}-ca-flags*: invalid directive: %s\n"), cp);
 601       }
 602    }
 603    NYD2_LEAVE;
 604 }
 605
 606 #ifdef HAVE_XSSL_CONF_CTX
 607 static void *
 608 _ssl_conf_setup(SSL_CTX *ctxp)
 609 {
 610    SSL_CONF_CTX *sccp;
 611    NYD_ENTER;
 612
 613    if ((sccp = SSL_CONF_CTX_new()) != NULL) {
 614       SSL_CONF_CTX_set_flags(sccp,
 615          SSL_CONF_FLAG_FILE | SSL_CONF_FLAG_CLIENT |
 616          SSL_CONF_FLAG_CERTIFICATE | SSL_CONF_FLAG_SHOW_ERRORS);
 617
 618       SSL_CONF_CTX_set_ssl_ctx(sccp, ctxp);
 619    } else
 620       ssl_gen_err(_("SSL_CONF_CTX_new() failed"));
 621
 622    NYD_LEAVE;
 623    return sccp;
 624 }
 625
 626 static bool_t
 627 _ssl_conf(void *confp, enum a_xssl_conf_type ct, char const *value)
 628 {
 629    int rv;
 630    char const *cmsg;
 631    SSL_CONF_CTX *sccp = (SSL_CONF_CTX*)confp;
 632    NYD_ENTER;
 633
 634    switch (ct) {
 635    case a_XSSL_CT_CERTIFICATE:
 636       cmsg = "ssl-cert";
 637       rv = SSL_CONF_cmd(sccp, "Certificate", value);
 638       break;
 639    case a_XSSL_CT_CIPHER_STRING:
 640       cmsg = "ssl-cipher-list";
 641       rv = SSL_CONF_cmd(sccp, "CipherString", value);
 642       break;
 643    case a_XSSL_CT_PRIVATE_KEY:
 644       cmsg = "ssl-key";
 645       rv = SSL_CONF_cmd(sccp, "PrivateKey", value);
 646       break;
 647    default:
 648    case a_XSSL_CT_OPTIONS:
 649       cmsg = "ssl-options";
 650       rv = SSL_CONF_cmd(sccp, "Options", "Bugs");
 651       break;
 652    case a_XSSL_CT_PROTOCOL:
 653       cmsg = "ssl-protocol";
 654       rv = SSL_CONF_cmd(sccp, "Protocol", value);
 655       break;
 656    case a_XSSL_CT_CURVES:
 657       cmsg = "ssl-curves";
 658       rv = SSL_CONF_cmd(sccp, "Curves", value);
 659       break;
 660    }
 661
 662    if (rv == 2)
 663       rv = 0;
 664    else {
 665       if (rv == 0)
 666          ssl_gen_err(_("SSL_CONF_CTX_cmd() failed for *%s*"), cmsg);
 667       else
 668          n_err(_("%s: *%s* implementation error, please report this\n"),
 669             n_uagent, cmsg);
 670       rv = 1;
 671    }
 672
 673    NYD_LEAVE;
 674    return (rv == 0);
 675 }
 676
 677 static bool_t
 678 _ssl_conf_finish(void **confp, bool_t error)
 679 {
 680    SSL_CONF_CTX **sccp = (SSL_CONF_CTX**)confp;
 681    bool_t rv;
 682    NYD_ENTER;
 683
 684    if (!(rv = error))
 685       rv = (SSL_CONF_CTX_finish(*sccp) != 0);
 686
 687    SSL_CONF_CTX_free(*sccp);
 688
 689    *sccp = NULL;
 690    NYD_LEAVE;
 691    return rv;
 692 }
 693
 694 #else /* HAVE_XSSL_CONF_CTX */
 695 static void *
 696 _ssl_conf_setup(SSL_CTX* ctxp)
 697 {
 698    return ctxp;
 699 }
 700
 701 static bool_t
 702 _ssl_conf(void *confp, enum a_xssl_conf_type ct, char const *value){
 703    SSL_CTX *ctxp;
 704    NYD2_ENTER;
 705
 706    ctxp = confp;
 707
 708    switch(ct){
 709    case a_XSSL_CT_CERTIFICATE:
 710       if(SSL_CTX_use_certificate_chain_file(ctxp, value) != 1){
 711          ssl_gen_err(_("Can't load certificate from file %s\n"),
 712             n_shexp_quote_cp(value, FAL0));
 713          confp = NULL;
 714       }
 715       break;
 716    case a_XSSL_CT_CIPHER_STRING:
 717       if(SSL_CTX_set_cipher_list(ctxp, value) != 1){
 718          ssl_gen_err(_("Invalid cipher string: %s\n"), value);
 719          confp = NULL;
 720       }
 721       break;
 722    case a_XSSL_CT_CURVES:
 723 #ifdef SSL_CTRL_SET_CURVES_LIST
 724       if(SSL_CTX_set1_curves_list(ctxp, value) != 1){
 725          ssl_gen_err(_("Invalid curves string: %s\n"), value);
 726          confp = NULL;
 727       }
 728 #else
 729       n_err(_("*ssl-curves*: as such not supported\n"));
 730       confp = NULL;
 731 #endif
 732       break;
 733    case a_XSSL_CT_PRIVATE_KEY:
 734       if(SSL_CTX_use_PrivateKey_file(ctxp, value, SSL_FILETYPE_PEM) != 1){
 735          ssl_gen_err(_("Can't load private key from file %s\n"),
 736             n_shexp_quote_cp(value, FAL0));
 737          confp = NULL;
 738       }
 739       break;
 740    case a_XSSL_CT_OPTIONS:
 741       /* "Options"="Bugs" TODO *ssl-options* */
 742       SSL_CTX_set_options(ctxp, SSL_OP_ALL);
 743       break;
 744    case a_XSSL_CT_PROTOCOL:{
 745       char *iolist, *cp, addin;
 746       size_t i;
 747       sl_i opts = 0;
 748
 749       confp = NULL;
 750       for(iolist = cp = savestr(value);
 751             (cp = n_strsep(&iolist, ',', FAL0)) != NULL;){
 752          if(*cp == '\0'){
 753             n_err(_("*ssl-protocol*: empty arguments are not supported\n"));
 754             goto jleave;
 755          }
 756
 757          addin = TRU1;
 758          switch(cp[0]){
 759          case '-': addin = FAL0; /* FALLTHRU */
 760          case '+': ++cp; /* FALLTHRU */
 761          default : break;
 762          }
 763
 764          for(i = 0;;){
 765             if(!asccasecmp(cp, a_xssl_protocols[i].sp_name)){
 766                /* We need to inverse the meaning of the _NO_s */
 767                if(!addin)
 768                   opts |= a_xssl_protocols[i].sp_flag;
 769                else
 770                   opts &= ~a_xssl_protocols[i].sp_flag;
 771                break;
 772             }
 773             if(++i < n_NELEM(a_xssl_protocols))
 774                continue;
 775             n_err(_("*ssl-protocol*: unsupported value: %s\n"), cp);
 776             goto jleave;
 777          }
 778       }
 779       confp = ctxp;
 780       SSL_CTX_set_options(ctxp, opts);
 781    }  break;
 782    }
 783 jleave:
 784    NYD2_LEAVE;
 785    return (confp != NULL);
 786 }
 787
 788 static bool_t
 789 _ssl_conf_finish(void **confp, bool_t error)
 790 {
 791    n_UNUSED(confp);
 792    n_UNUSED(error);
 793    return TRU1;
 794 }
 795 #endif /* !HAVE_XSSL_CONF_CTX */
 796
 797 static bool_t
 798 _ssl_load_verifications(SSL_CTX *ctxp)
 799 {
 800    char *ca_dir, *ca_file;
 801    X509_STORE *store;
 802    bool_t rv = FAL0;
 803    NYD_ENTER;
 804
 805    if (ssl_verify_level == SSL_VERIFY_IGNORE) {
 806       rv = TRU1;
 807       goto jleave;
 808    }
 809
 810    if ((ca_dir = ok_vlook(ssl_ca_dir)) != NULL)
 811       ca_dir = fexpand(ca_dir, FEXP_LOCAL | FEXP_NOPROTO);
 812    if ((ca_file = ok_vlook(ssl_ca_file)) != NULL)
 813       ca_file = fexpand(ca_file, FEXP_LOCAL | FEXP_NOPROTO);
 814
 815    if ((ca_dir != NULL || ca_file != NULL) &&
 816          SSL_CTX_load_verify_locations(ctxp, ca_file, ca_dir) != 1) {
 817       char const *m1, *m2, *m3;
 818
 819       if (ca_dir != NULL) {
 820          m1 = ca_dir;
 821          m2 = (ca_file != NULL) ? _(" or ") : n_empty;
 822       } else
 823          m1 = m2 = n_empty;
 824       m3 = (ca_file != NULL) ? ca_file : n_empty;
 825       ssl_gen_err(_("Error loading %s%s%s\n"), m1, m2, m3);
 826       goto jleave;
 827    }
 828
 829    /* C99 */{
 830       bool_t xv15;
 831
 832       if((xv15 = ok_blook(ssl_no_default_ca)))
 833          n_OBSOLETE(_("please use *ssl-ca-no-defaults*, "
 834             "not *ssl-no-default-ca*"));
 835       if(!ok_blook(ssl_ca_no_defaults) && !xv15 &&
 836             SSL_CTX_set_default_verify_paths(ctxp) != 1) {
 837          ssl_gen_err(_("Error loading built-in default CA locations\n"));
 838          goto jleave;
 839       }
 840    }
 841
 842    a_xssl_state &= ~a_XSSL_S_VERIFY_ERROR;
 843    a_xssl_msgno = 0;
 844    SSL_CTX_set_verify(ctxp, SSL_VERIFY_PEER, &_ssl_verify_cb);
 845    store = SSL_CTX_get_cert_store(ctxp);
 846    load_crls(store, ok_v_ssl_crl_file, ok_v_ssl_crl_dir);
 847    a_xssl_ca_flags(store, ok_vlook(ssl_ca_flags));
 848
 849    rv = TRU1;
 850 jleave:
 851    NYD_LEAVE;
 852    return rv;
 853 }
 854
 855 static enum okay
 856 ssl_check_host(struct sock *sp, struct url const *urlp)
 857 {
 858    char data[256];
 859    X509 *cert;
 860    n_XSSL_STACKOF(GENERAL_NAME) *gens;
 861    GENERAL_NAME *gen;
 862    X509_NAME *subj;
 863    enum okay rv = STOP;
 864    NYD_ENTER;
 865
 866    if ((cert = SSL_get_peer_certificate(sp->s_ssl)) == NULL) {
 867       n_err(_("No certificate from: %s\n"), urlp->url_h_p.s);
 868       goto jleave;
 869    }
 870
 871    gens = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
 872    if (gens != NULL) {
 873       int i;
 874
 875       for (i = 0; i < sk_GENERAL_NAME_num(gens); ++i) {
 876          gen = sk_GENERAL_NAME_value(gens, i);
 877          if (gen->type == GEN_DNS) {
 878             if (n_poption & n_PO_D_V)
 879                n_err(_("Comparing subject_alt_name: need<%s> is<%s>\n"),
 880                   urlp->url_host.s, (char*)gen->d.ia5->data);
 881             rv = rfc2595_hostname_match(urlp->url_host.s,
 882                   (char*)gen->d.ia5->data);
 883             if (rv == OKAY)
 884                goto jdone;
 885          }
 886       }
 887    }
 888
 889    if ((subj = X509_get_subject_name(cert)) != NULL &&
 890          X509_NAME_get_text_by_NID(subj, NID_commonName, data, sizeof data)
 891             > 0) {
 892       data[sizeof data - 1] = '\0';
 893       if (n_poption & n_PO_D_V)
 894          n_err(_("Comparing commonName: need<%s> is<%s>\n"),
 895             urlp->url_host.s, data);
 896       rv = rfc2595_hostname_match(urlp->url_host.s, data);
 897    }
 898
 899 jdone:
 900    X509_free(cert);
 901 jleave:
 902    NYD_LEAVE;
 903    return rv;
 904 }
 905
 906 static int
 907 smime_verify(struct message *m, int n, n_XSSL_STACKOF(X509) *chain,
 908    X509_STORE *store)
 909 {
 910    char data[LINESIZE], *sender, *to, *cc, *cnttype;
 911    int rv, c, i, j;
 912    struct message *x;
 913    FILE *fp, *ip;
 914    off_t size;
 915    BIO *fb, *pb;
 916    PKCS7 *pkcs7;
 917    n_XSSL_STACKOF(X509) *certs;
 918    n_XSSL_STACKOF(GENERAL_NAME) *gens;
 919    X509 *cert;
 920    X509_NAME *subj;
 921    GENERAL_NAME *gen;
 922    NYD_ENTER;
 923
 924    rv = 1;
 925    fp = NULL;
 926    fb = pb = NULL;
 927    pkcs7 = NULL;
 928    certs = NULL;
 929    a_xssl_state &= ~a_XSSL_S_VERIFY_ERROR;
 930    a_xssl_msgno = (size_t)n;
 931
 932    for (;;) {
 933       sender = getsender(m);
 934       to = hfield1("to", m);
 935       cc = hfield1("cc", m);
 936       cnttype = hfield1("content-type", m);
 937
 938 #undef _X
 939 #undef _Y
 940 #define _X     (sizeof("application/") -1)
 941 #define _Y(X)  X, sizeof(X) -1
 942       if (cnttype && is_asccaseprefix("application/", cnttype) &&
 943             (!ascncasecmp(cnttype + _X, _Y("pkcs7-mime")) ||
 944              !ascncasecmp(cnttype + _X, _Y("x-pkcs7-mime")))) {
 945 #undef _Y
 946 #undef _X
 947          if ((x = smime_decrypt(m, to, cc, 1)) == NULL)
 948             goto jleave;
 949          if (x != (struct message*)-1) {
 950             m = x;
 951             continue;
 952          }
 953       }
 954
 955       if ((ip = setinput(&mb, m, NEED_BODY)) == NULL)
 956          goto jleave;
 957       size = m->m_size;
 958       break;
 959    }
 960
 961    if ((fp = Ftmp(NULL, "smimever", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
 962          NULL) {
 963       n_perr(_("tempfile"), 0);
 964       goto jleave;
 965    }
 966    while (size-- > 0) {
 967       c = getc(ip);
 968       putc(c, fp);
 969    }
 970    fflush_rewind(fp);
 971
 972    if ((fb = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
 973       ssl_gen_err(_(
 974          "Error creating BIO verification object for message %d"), n);
 975       goto jleave;
 976    }
 977
 978    if ((pkcs7 = SMIME_read_PKCS7(fb, &pb)) == NULL) {
 979       ssl_gen_err(_("Error reading PKCS#7 object for message %d"), n);
 980       goto jleave;
 981    }
 982    if (PKCS7_verify(pkcs7, chain, store, pb, NULL, 0) != 1) {
 983       ssl_gen_err(_("Error verifying message %d"), n);
 984       goto jleave;
 985    }
 986
 987    if (sender == NULL) {
 988       n_err(_("Warning: Message %d has no sender\n"), n);
 989       rv = 0;
 990       goto jleave;
 991    }
 992
 993    certs = PKCS7_get0_signers(pkcs7, chain, 0);
 994    if (certs == NULL) {
 995       n_err(_("No certificates found in message %d\n"), n);
 996       goto jleave;
 997    }
 998
 999    for (i = 0; i < sk_X509_num(certs); ++i) {
1000       cert = sk_X509_value(certs, i);
1001       gens = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
1002       if (gens != NULL) {
1003          for (j = 0; j < sk_GENERAL_NAME_num(gens); ++j) {
1004             gen = sk_GENERAL_NAME_value(gens, j);
1005             if (gen->type == GEN_EMAIL) {
1006                if (n_poption & n_PO_D_V)
1007                   n_err(_("Comparing subject_alt_name: need<%s> is<%s>)\n"),
1008                      sender, (char*)gen->d.ia5->data);
1009                if (!asccasecmp((char*)gen->d.ia5->data, sender))
1010                   goto jfound;
1011             }
1012          }
1013       }
1014
1015       if ((subj = X509_get_subject_name(cert)) != NULL &&
1016             X509_NAME_get_text_by_NID(subj, NID_pkcs9_emailAddress,
1017                data, sizeof data) > 0) {
1018          data[sizeof data -1] = '\0';
1019          if (n_poption & n_PO_D_V)
1020             n_err(_("Comparing emailAddress: need<%s> is<%s>\n"),
1021                sender, data);
1022          if (!asccasecmp(data, sender))
1023             goto jfound;
1024       }
1025    }
1026    n_err(_("Message %d: certificate does not match <%s>\n"), n, sender);
1027    goto jleave;
1028 jfound:
1029    rv = ((a_xssl_state & a_XSSL_S_VERIFY_ERROR) != 0);
1030    if (!rv)
1031       fprintf(n_stdout, _("Message %d was verified successfully\n"), n);
1032 jleave:
1033    if (certs != NULL)
1034       sk_X509_free(certs);
1035    if (pb != NULL)
1036       BIO_free(pb);
1037    if (fb != NULL)
1038       BIO_free(fb);
1039    if (pkcs7 != NULL)
1040       PKCS7_free(pkcs7);
1041    if (fp != NULL)
1042       Fclose(fp);
1043    NYD_LEAVE;
1044    return rv;
1045 }
1046
1047 static EVP_CIPHER const *
1048 _smime_cipher(char const *name)
1049 {
1050    EVP_CIPHER const *cipher;
1051    char *vn;
1052    char const *cp;
1053    size_t i;
1054    NYD_ENTER;
1055
1056    vn = ac_alloc(i = strlen(name) + sizeof("smime-cipher-") -1 +1);
1057    snprintf(vn, (int)i, "smime-cipher-%s", name);
1058    cp = n_var_vlook(vn, FAL0);
1059    ac_free(vn);
1060
1061    if (cp == NULL && (cp = ok_vlook(smime_cipher)) == NULL) {
1062       cipher = a_XSSL_SMIME_DEFAULT_CIPHER();
1063       goto jleave;
1064    }
1065    cipher = NULL;
1066
1067    for (i = 0; i < n_NELEM(a_xssl_smime_ciphers); ++i)
1068       if (!asccasecmp(a_xssl_smime_ciphers[i].sc_name, cp)) {
1069          cipher = (*a_xssl_smime_ciphers[i].sc_fun)();
1070          goto jleave;
1071       }
1072 #ifndef OPENSSL_NO_AES
1073    for (i = 0; i < n_NELEM(a_xssl_smime_ciphers_obs); ++i) /* TODO obsolete */
1074       if (!asccasecmp(a_xssl_smime_ciphers_obs[i].sc_name, cp)) {
1075          n_OBSOLETE2(_("*smime-cipher* names with hyphens will vanish"), cp);
1076          cipher = (*a_xssl_smime_ciphers_obs[i].sc_fun)();
1077          goto jleave;
1078       }
1079 #endif
1080
1081    /* Not a built-in algorithm, but we may have dynamic support for more */
1082 #ifdef HAVE_SSL_ALL_ALGORITHMS
1083    a_xssl_load_algos();
1084    if((cipher = EVP_get_cipherbyname(cp)) != NULL)
1085       goto jleave;
1086 #endif
1087
1088    n_err(_("Invalid S/MIME cipher(s): %s\n"), cp);
1089 jleave:
1090    NYD_LEAVE;
1091    return cipher;
1092 }
1093
1094 static int
1095 ssl_password_cb(char *buf, int size, int rwflag, void *userdata)
1096 {
1097    char *pass;
1098    size_t len;
1099    NYD_ENTER;
1100    n_UNUSED(rwflag);
1101    n_UNUSED(userdata);
1102
1103    /* New-style */
1104    if(userdata != NULL){
1105       struct url url;
1106       struct ccred cred;
1107
1108       if(url_parse(&url, CPROTO_CCRED, userdata)){
1109          if(ccred_lookup(&cred, &url)){
1110             ssize_t slen;
1111
1112             if((slen = n_strscpy(buf, cred.cc_pass.s, size)) >= 0){
1113                size = (int)slen;
1114                goto jleave;
1115             }
1116          }
1117          size = 0;
1118          goto jleave;
1119       }
1120    }
1121
1122    /* Old-style */
1123    if ((pass = getpassword("PEM pass phrase:")) != NULL) {
1124       len = strlen(pass);
1125       if (UICMP(z, len, >=, size))
1126          len = size -1;
1127       memcpy(buf, pass, len);
1128       buf[len] = '\0';
1129       size = (int)len;
1130    } else
1131       size = 0;
1132 jleave:
1133    NYD_LEAVE;
1134    return size;
1135 }
1136
1137 static FILE *
1138 smime_sign_cert(char const *xname, char const *xname2, bool_t dowarn,
1139    char const **match)
1140 {
1141    char *vn;
1142    int vs;
1143    struct name *np;
1144    char const *name = xname, *name2 = xname2, *cp;
1145    FILE *fp = NULL;
1146    NYD_ENTER;
1147
1148 jloop:
1149    if (name) {
1150       np = lextract(name, GTO | GSKIN);
1151       while (np != NULL) {
1152          /* This needs to be more intelligent since it will currently take the
1153           * first name for which a private key is available regardless of
1154           * whether it is the right one for the message */
1155          vn = ac_alloc(vs = strlen(np->n_name) + 30);
1156          snprintf(vn, vs, "smime-sign-cert-%s", np->n_name);
1157          cp = n_var_vlook(vn, FAL0);
1158          ac_free(vn);
1159          if (cp != NULL) {
1160             if (match != NULL)
1161                *match = np->n_name;
1162             goto jopen;
1163          }
1164          np = np->n_flink;
1165       }
1166       if (name2 != NULL) {
1167          name = name2;
1168          name2 = NULL;
1169          goto jloop;
1170       }
1171    }
1172
1173    if ((cp = ok_vlook(smime_sign_cert)) == NULL)
1174       goto jerr;
1175    if(match != NULL)
1176       *match = NULL;
1177 jopen:
1178    if ((cp = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL)
1179       goto jleave;
1180    if ((fp = Fopen(cp, "r")) == NULL)
1181       n_perr(cp, 0);
1182 jleave:
1183    NYD_LEAVE;
1184    return fp;
1185 jerr:
1186    if (dowarn)
1187       n_err(_("Could not find a certificate for %s%s%s\n"),
1188          xname, (xname2 != NULL ? _("or ") : n_empty),
1189          (xname2 != NULL ? xname2 : n_empty));
1190    goto jleave;
1191 }
1192
1193 static char const *
1194 _smime_sign_include_certs(char const *name)
1195 {
1196    char const *rv;
1197    NYD_ENTER;
1198
1199    /* See comments in smime_sign_cert() for algorithm pitfalls */
1200    if (name != NULL) {
1201       struct name *np;
1202
1203       for (np = lextract(name, GTO | GSKIN); np != NULL; np = np->n_flink) {
1204          int vs;
1205          char *vn;
1206
1207          vn = ac_alloc(vs = strlen(np->n_name) + 30);
1208          snprintf(vn, vs, "smime-sign-include-certs-%s", np->n_name);
1209          rv = n_var_vlook(vn, FAL0);
1210          ac_free(vn);
1211          if (rv != NULL)
1212             goto jleave;
1213       }
1214    }
1215    rv = ok_vlook(smime_sign_include_certs);
1216 jleave:
1217    NYD_LEAVE;
1218    return rv;
1219 }
1220
1221 static bool_t
1222 _smime_sign_include_chain_creat(n_XSSL_STACKOF(X509) **chain,
1223    char const *cfiles, char const *addr)
1224 {
1225    X509 *tmp;
1226    FILE *fp;
1227    char *nfield, *cfield, *x;
1228    NYD_ENTER;
1229
1230    *chain = sk_X509_new_null();
1231
1232    for (nfield = savestr(cfiles);
1233          (cfield = n_strsep(&nfield, ',', TRU1)) != NULL;) {
1234       if ((x = fexpand(cfield, FEXP_LOCAL | FEXP_NOPROTO)) == NULL ||
1235             (fp = Fopen(cfield = x, "r")) == NULL) {
1236          n_perr(cfiles, 0);
1237          goto jerr;
1238       }
1239       if ((tmp = PEM_read_X509(fp, NULL, &ssl_password_cb, n_UNCONST(addr))
1240             ) == NULL) {
1241          ssl_gen_err(_("Error reading certificate from %s"),
1242             n_shexp_quote_cp(cfield, FAL0));
1243          Fclose(fp);
1244          goto jerr;
1245       }
1246       sk_X509_push(*chain, tmp);
1247       Fclose(fp);
1248    }
1249
1250    if (sk_X509_num(*chain) == 0) {
1251       n_err(_("*smime-sign-include-certs* defined but empty\n"));
1252       goto jerr;
1253    }
1254 jleave:
1255    NYD_LEAVE;
1256    return (*chain != NULL);
1257 jerr:
1258    sk_X509_pop_free(*chain, X509_free);
1259    *chain = NULL;
1260    goto jleave;
1261 }
1262
1263 static EVP_MD const *
1264 _smime_sign_digest(char const *name, char const **digname)
1265 {
1266    EVP_MD const *digest;
1267    char const *cp;
1268    size_t i;
1269    NYD_ENTER;
1270
1271    /* See comments in smime_sign_cert() for algorithm pitfalls */
1272    if (name != NULL) {
1273       struct name *np;
1274
1275       for (np = lextract(name, GTO | GSKIN); np != NULL; np = np->n_flink) {
1276          int vs;
1277          char *vn = ac_alloc(vs = strlen(np->n_name) + 30);
1278          snprintf(vn, vs, "smime-sign-message-digest-%s", np->n_name);
1279          cp = n_var_vlook(vn, FAL0);
1280          ac_free(vn);
1281          if (cp != NULL)
1282             goto jhave_name;
1283       }
1284    }
1285
1286    if ((cp = ok_vlook(smime_sign_message_digest)) == NULL) {
1287       digest = a_XSSL_SMIME_DEFAULT_DIGEST();
1288       *digname = a_XSSL_SMIME_DEFAULT_DIGEST_S;
1289       goto jleave;
1290    }
1291
1292 jhave_name:
1293    i = strlen(cp);
1294    {  char *x = salloc(i +1);
1295       i_strcpy(x, cp, i +1);
1296       cp = x;
1297    }
1298    *digname = cp;
1299
1300    for (i = 0; i < n_NELEM(a_xssl_smime_digests); ++i)
1301       if (!asccasecmp(a_xssl_smime_digests[i].sd_name, cp)) {
1302          digest = (*a_xssl_smime_digests[i].sd_fun)();
1303          goto jleave;
1304       }
1305
1306    /* Not a built-in algorithm, but we may have dynamic support for more */
1307 #ifdef HAVE_SSL_ALL_ALGORITHMS
1308    a_xssl_load_algos();
1309    if((digest = EVP_get_digestbyname(cp)) != NULL)
1310       goto jleave;
1311 #endif
1312
1313    n_err(_("Invalid message digest: %s\n"), cp);
1314    digest = NULL;
1315 jleave:
1316    NYD_LEAVE;
1317    return digest;
1318 }
1319
1320 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1321 static enum okay
1322 load_crl1(X509_STORE *store, char const *name)
1323 {
1324    X509_LOOKUP *lookup;
1325    enum okay rv = STOP;
1326    NYD_ENTER;
1327
1328    if (n_poption & n_PO_D_V)
1329       n_err(_("Loading CRL from %s\n"), n_shexp_quote_cp(name, FAL0));
1330    if ((lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file())) == NULL) {
1331       ssl_gen_err(_("Error creating X509 lookup object"));
1332       goto jleave;
1333    }
1334    if (X509_load_crl_file(lookup, name, X509_FILETYPE_PEM) != 1) {
1335       ssl_gen_err(_("Error loading CRL from %s"), n_shexp_quote_cp(name, FAL0));
1336       goto jleave;
1337    }
1338    rv = OKAY;
1339 jleave:
1340    NYD_LEAVE;
1341    return rv;
1342 }
1343 #endif /* new OpenSSL */
1344
1345 static enum okay
1346 load_crls(X509_STORE *store, enum okeys fok, enum okeys dok)
1347 {
1348    char *crl_file, *crl_dir;
1349 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1350    DIR *dirp;
1351    struct dirent *dp;
1352    char *fn = NULL;
1353    int fs = 0, ds, es;
1354 #endif
1355    enum okay rv = STOP;
1356    NYD_ENTER;
1357
1358    if ((crl_file = n_var_oklook(fok)) != NULL) {
1359 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1360       if ((crl_file = fexpand(crl_file, FEXP_LOCAL | FEXP_NOPROTO)) == NULL ||
1361             load_crl1(store, crl_file) != OKAY)
1362          goto jleave;
1363 #else
1364       n_err(_("This OpenSSL version is too old to use CRLs\n"));
1365       goto jleave;
1366 #endif
1367    }
1368
1369    if ((crl_dir = n_var_oklook(dok)) != NULL) {
1370 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1371       char *x;
1372       if ((x = fexpand(crl_dir, FEXP_LOCAL | FEXP_NOPROTO)) == NULL ||
1373             (dirp = opendir(crl_dir = x)) == NULL) {
1374          n_perr(crl_dir, 0);
1375          goto jleave;
1376       }
1377
1378       ds = strlen(crl_dir);
1379       fn = smalloc(fs = ds + 20);
1380       memcpy(fn, crl_dir, ds);
1381       fn[ds] = '/';
1382       while ((dp = readdir(dirp)) != NULL) {
1383          if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
1384                (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
1385             continue;
1386          if (dp->d_name[0] == '.')
1387             continue;
1388          if (ds + (es = strlen(dp->d_name)) + 2 < fs)
1389             fn = srealloc(fn, fs = ds + es + 20);
1390          memcpy(fn + ds + 1, dp->d_name, es + 1);
1391          if (load_crl1(store, fn) != OKAY) {
1392             closedir(dirp);
1393             free(fn);
1394             goto jleave;
1395          }
1396       }
1397       closedir(dirp);
1398       free(fn);
1399 #else /* old OpenSSL */
1400       n_err(_("This OpenSSL version is too old to use CRLs\n"));
1401       goto jleave;
1402 #endif
1403    }
1404 #if defined X509_V_FLAG_CRL_CHECK && defined X509_V_FLAG_CRL_CHECK_ALL
1405    if (crl_file || crl_dir)
1406       X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK |
1407          X509_V_FLAG_CRL_CHECK_ALL);
1408 #endif
1409    rv = OKAY;
1410 jleave:
1411    NYD_LEAVE;
1412    return rv;
1413 }
1414
1415 #if n_RANDOM_USE_XSSL
1416 FL void
1417 ssl_rand_bytes(void *buf, size_t blen){
1418    NYD_ENTER;
1419
1420    if(!(a_xssl_state & a_XSSL_S_RAND_INIT) && a_xssl_rand_init())
1421       a_xssl_state |= a_XSSL_S_RAND_INIT;
1422
1423    while(blen > 0){
1424       si32_t i;
1425
1426       i = n_MIN(SI32_MAX, blen);
1427       blen -= i;
1428       RAND_bytes(buf, i);
1429       buf = (ui8_t*)buf + i;
1430    }
1431    NYD_LEAVE;
1432 }
1433 #endif
1434
1435 FL enum okay
1436 ssl_open(struct url const *urlp, struct sock *sp)
1437 {
1438    SSL_CTX *ctxp;
1439    void *confp;
1440    char const *cp, *cp_base;
1441    size_t i;
1442    enum okay rv = STOP;
1443    NYD_ENTER;
1444
1445    a_xssl_init();
1446
1447    ssl_set_verify_level(urlp);
1448
1449    if ((ctxp = SSL_CTX_new(n_XSSL_CLIENT_METHOD())) == NULL) {
1450       ssl_gen_err(_("SSL_CTX_new() failed"));
1451       goto jleave;
1452    }
1453
1454    /* Available with OpenSSL 0.9.6 or later */
1455 #ifdef SSL_MODE_AUTO_RETRY
1456    SSL_CTX_set_mode(ctxp, SSL_MODE_AUTO_RETRY);
1457 #endif
1458
1459    if ((confp = _ssl_conf_setup(ctxp)) == NULL)
1460       goto jerr0;
1461
1462    /* TODO obsolete Check for *ssl-method*, warp to a *ssl-protocol* value */
1463    if ((cp = xok_vlook(ssl_method, urlp, OXM_ALL)) != NULL) {
1464       n_OBSOLETE(_("please use *ssl-protocol* instead of *ssl-method*"));
1465       if (n_poption & n_PO_D_V)
1466          n_err(_("*ssl-method*: %s\n"), cp);
1467       for (i = 0;;) {
1468          if (!asccasecmp(_ssl_methods[i].sm_name, cp)) {
1469             cp = _ssl_methods[i].sm_map;
1470             break;
1471          }
1472          if (++i == n_NELEM(_ssl_methods)) {
1473             n_err(_("Unsupported TLS/SSL method: %s\n"), cp);
1474             goto jerr1;
1475          }
1476       }
1477    }
1478    /* *ssl-protocol* */
1479    if ((cp_base = xok_vlook(ssl_protocol, urlp, OXM_ALL)) != NULL) {
1480       if (n_poption & n_PO_D_V)
1481          n_err(_("*ssl-protocol*: %s\n"), cp_base);
1482       cp = cp_base;
1483    }
1484    cp = (cp != NULL ? savecatsep(cp, ',', n_XSSL_DISABLED_PROTOCOLS)
1485          : n_XSSL_DISABLED_PROTOCOLS);
1486    if (!_ssl_conf(confp, a_XSSL_CT_PROTOCOL, cp))
1487       goto jerr1;
1488
1489    /* *ssl-cert* */
1490    if ((cp = xok_vlook(ssl_cert, urlp, OXM_ALL)) != NULL) {
1491       if (n_poption & n_PO_D_V)
1492          n_err(_("*ssl-cert* %s\n"), n_shexp_quote_cp(cp, FAL0));
1493       if ((cp_base = fexpand(cp, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
1494          n_err(_("*ssl-cert* value expansion failed: %s\n"),
1495             n_shexp_quote_cp(cp, FAL0));
1496          goto jerr1;
1497       }
1498       cp = cp_base;
1499       if (!_ssl_conf(confp, a_XSSL_CT_CERTIFICATE, cp))
1500          goto jerr1;
1501
1502       /* *ssl-key* */
1503       if ((cp_base = xok_vlook(ssl_key, urlp, OXM_ALL)) != NULL) {
1504          if (n_poption & n_PO_D_V)
1505             n_err(_("*ssl-key* %s\n"), n_shexp_quote_cp(cp_base, FAL0));
1506          if ((cp = fexpand(cp_base, FEXP_LOCAL | FEXP_NOPROTO)) == NULL) {
1507             n_err(_("*ssl-key* value expansion failed: %s\n"),
1508                n_shexp_quote_cp(cp_base, FAL0));
1509             goto jerr1;
1510          }
1511       }
1512       if (!_ssl_conf(confp, a_XSSL_CT_PRIVATE_KEY, cp))
1513          goto jerr1;
1514    }
1515
1516    if ((cp = xok_vlook(ssl_cipher_list, urlp, OXM_ALL)) != NULL &&
1517          !_ssl_conf(confp, a_XSSL_CT_CIPHER_STRING, cp))
1518       goto jerr1;
1519    if ((cp = xok_vlook(ssl_curves, urlp, OXM_ALL)) != NULL &&
1520          !_ssl_conf(confp, a_XSSL_CT_CURVES, cp))
1521       goto jerr1;
1522
1523    if (!_ssl_load_verifications(ctxp))
1524       goto jerr1;
1525
1526    if (!_ssl_conf(confp, a_XSSL_CT_OPTIONS, NULL)) /* TODO *ssl-options* */
1527       goto jerr1;
1528
1529    /* Done with context setup, create our new per-connection structure */
1530    if (!_ssl_conf_finish(&confp, FAL0))
1531       goto jerr0;
1532
1533    if ((sp->s_ssl = SSL_new(ctxp)) == NULL) {
1534       ssl_gen_err(_("SSL_new() failed"));
1535       goto jerr0;
1536    }
1537
1538    /* Try establish SNI extension; even though this is a TLS extension the
1539     * protocol isn't checked once the host name is set, and therefore i've
1540     * refrained from changing so much code just to check out whether we are
1541     * using SSLv3, which should become rarer and rarer */
1542 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1543    if((urlp->url_flags & n_URL_TLS_MASK) &&
1544          (urlp->url_flags & n_URL_HOST_IS_NAME)){
1545       if(!SSL_set_tlsext_host_name(sp->s_ssl, urlp->url_host.s) &&
1546             (n_poption & n_PO_D_V))
1547          n_err(_("Hostname cannot be used with ServerNameIndication "
1548                "TLS extension: %s\n"),
1549             n_shexp_quote_cp(urlp->url_host.s, FAL0));
1550    }
1551 #endif
1552
1553    SSL_set_fd(sp->s_ssl, sp->s_fd);
1554
1555    if (SSL_connect(sp->s_ssl) < 0) {
1556       ssl_gen_err(_("could not initiate SSL/TLS connection"));
1557       goto jerr2;
1558    }
1559
1560    if (ssl_verify_level != SSL_VERIFY_IGNORE) {
1561       if (ssl_check_host(sp, urlp) != OKAY) {
1562          n_err(_("Host certificate does not match: %s\n"), urlp->url_h_p.s);
1563          if (ssl_verify_decide() != OKAY)
1564             goto jerr2;
1565       }
1566    }
1567
1568    /* We're fully setup: since we don't reuse the SSL_CTX (pooh) keep it local
1569     * and free it right now -- it is reference counted by sp->s_ssl.. */
1570    SSL_CTX_free(ctxp);
1571    sp->s_use_ssl = 1;
1572    rv = OKAY;
1573 jleave:
1574    NYD_LEAVE;
1575    return rv;
1576 jerr2:
1577    SSL_free(sp->s_ssl);
1578    sp->s_ssl = NULL;
1579 jerr1:
1580    if (confp != NULL)
1581       _ssl_conf_finish(&confp, TRU1);
1582 jerr0:
1583    SSL_CTX_free(ctxp);
1584    goto jleave;
1585 }
1586
1587 FL void
1588 ssl_gen_err(char const *fmt, ...)
1589 {
1590    va_list ap;
1591    NYD_ENTER;
1592
1593    va_start(ap, fmt);
1594    n_verr(fmt, ap);
1595    va_end(ap);
1596
1597    n_err(_(": %s\n"), ERR_error_string(ERR_get_error(), NULL));
1598    NYD_LEAVE;
1599 }
1600
1601 FL int
1602 c_verify(void *vp)
1603 {
1604    int *msgvec = vp, *ip, ec = 0, rv = 1;
1605    X509_STORE *store = NULL;
1606    char *ca_dir, *ca_file;
1607    NYD_ENTER;
1608
1609    a_xssl_init();
1610
1611    ssl_verify_level = SSL_VERIFY_STRICT;
1612    if ((store = X509_STORE_new()) == NULL) {
1613       ssl_gen_err(_("Error creating X509 store"));
1614       goto jleave;
1615    }
1616    X509_STORE_set_verify_cb_func(store, &_ssl_verify_cb);
1617
1618    if ((ca_dir = ok_vlook(smime_ca_dir)) != NULL)
1619       ca_dir = fexpand(ca_dir, FEXP_LOCAL | FEXP_NOPROTO);
1620    if ((ca_file = ok_vlook(smime_ca_file)) != NULL)
1621       ca_file = fexpand(ca_file, FEXP_LOCAL | FEXP_NOPROTO);
1622
1623    if (ca_dir != NULL || ca_file != NULL) {
1624       if (X509_STORE_load_locations(store, ca_file, ca_dir) != 1) {
1625          ssl_gen_err(_("Error loading %s"),
1626             (ca_file != NULL) ? ca_file : ca_dir);
1627          goto jleave;
1628       }
1629    }
1630
1631    /* C99 */{
1632       bool_t xv15;
1633
1634       if((xv15 = ok_blook(smime_no_default_ca)))
1635          n_OBSOLETE(_("please use *smime-ca-no-defaults*, "
1636             "not *smime-no-default-ca*"));
1637       if(!ok_blook(smime_ca_no_defaults) && !xv15 &&
1638             X509_STORE_set_default_paths(store) != 1) {
1639          ssl_gen_err(_("Error loading built-in default CA locations\n"));
1640          goto jleave;
1641       }
1642    }
1643
1644    if (load_crls(store, ok_v_smime_crl_file, ok_v_smime_crl_dir) != OKAY)
1645       goto jleave;
1646
1647    a_xssl_ca_flags(store, ok_vlook(smime_ca_flags));
1648
1649    srelax_hold();
1650    for (ip = msgvec; *ip != 0; ++ip) {
1651       struct message *mp = message + *ip - 1;
1652       setdot(mp);
1653       ec |= smime_verify(mp, *ip, NULL, store);
1654       srelax();
1655    }
1656    srelax_rele();
1657
1658    if ((rv = ec) != 0)
1659       n_exit_status |= n_EXIT_ERR;
1660 jleave:
1661    if (store != NULL)
1662       X509_STORE_free(store);
1663    NYD_LEAVE;
1664    return rv;
1665 }
1666
1667 FL FILE *
1668 smime_sign(FILE *ip, char const *addr)
1669 {
1670    FILE *rv, *sp, *fp, *bp, *hp;
1671    X509 *cert = NULL;
1672    n_XSSL_STACKOF(X509) *chain = NULL;
1673    EVP_PKEY *pkey = NULL;
1674    BIO *bb, *sb;
1675    PKCS7 *pkcs7;
1676    EVP_MD const *md;
1677    char const *name;
1678    bool_t bail = FAL0;
1679    NYD_ENTER;
1680
1681    assert(addr != NULL);
1682    rv = sp = fp = bp = hp = NULL;
1683
1684    a_xssl_init();
1685
1686    if (addr == NULL) {
1687       n_err(_("No *from* address for signing specified\n"));
1688       goto jleave;
1689    }
1690    if ((fp = smime_sign_cert(addr, NULL, 1, NULL)) == NULL)
1691       goto jleave;
1692
1693    if ((pkey = PEM_read_PrivateKey(fp, NULL, &ssl_password_cb,
1694          savecat(addr, ".smime-cert-key"))) == NULL) {
1695       ssl_gen_err(_("Error reading private key from"));
1696       goto jleave;
1697    }
1698
1699    rewind(fp);
1700    if ((cert = PEM_read_X509(fp, NULL, &ssl_password_cb,
1701          savecat(addr, ".smime-cert-cert"))) == NULL) {
1702       ssl_gen_err(_("Error reading signer certificate from"));
1703       goto jleave;
1704    }
1705    Fclose(fp);
1706    fp = NULL;
1707
1708    if ((name = _smime_sign_include_certs(addr)) != NULL &&
1709          !_smime_sign_include_chain_creat(&chain, name,
1710             savecat(addr, ".smime-include-certs")))
1711       goto jleave;
1712
1713    name = NULL;
1714    if ((md = _smime_sign_digest(addr, &name)) == NULL)
1715       goto jleave;
1716
1717    if ((sp = Ftmp(NULL, "smimesign", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1718          NULL) {
1719       n_perr(_("tempfile"), 0);
1720       goto jleave;
1721    }
1722
1723    rewind(ip);
1724    if (smime_split(ip, &hp, &bp, -1, 0) == STOP)
1725       goto jleave;
1726
1727    sb = NULL;
1728    pkcs7 = NULL;
1729
1730    if ((bb = BIO_new_fp(bp, BIO_NOCLOSE)) == NULL ||
1731          (sb = BIO_new_fp(sp, BIO_NOCLOSE)) == NULL) {
1732       ssl_gen_err(_("Error creating BIO signing objects"));
1733       bail = TRU1;
1734       goto jerr;
1735    }
1736
1737 #undef _X
1738 #define _X  PKCS7_DETACHED | PKCS7_PARTIAL
1739    if ((pkcs7 = PKCS7_sign(NULL, NULL, chain, bb, _X)) == NULL) {
1740       ssl_gen_err(_("Error creating the PKCS#7 signing object"));
1741       bail = TRU1;
1742       goto jerr;
1743    }
1744    if (PKCS7_sign_add_signer(pkcs7, cert, pkey, md, _X) == NULL) {
1745       ssl_gen_err(_("Error setting PKCS#7 signing object signer"));
1746       bail = TRU1;
1747       goto jerr;
1748    }
1749    if (!PKCS7_final(pkcs7, bb, _X)) {
1750       ssl_gen_err(_("Error finalizing the PKCS#7 signing object"));
1751       bail = TRU1;
1752       goto jerr;
1753    }
1754 #undef _X
1755
1756    if (PEM_write_bio_PKCS7(sb, pkcs7) == 0) {
1757       ssl_gen_err(_("Error writing signed S/MIME data"));
1758       bail = TRU1;
1759       /*goto jerr*/
1760    }
1761 jerr:
1762    if (pkcs7 != NULL)
1763       PKCS7_free(pkcs7);
1764    if (sb != NULL)
1765       BIO_free(sb);
1766    if (bb != NULL)
1767       BIO_free(bb);
1768    if (!bail) {
1769       rewind(bp);
1770       fflush_rewind(sp);
1771       rv = smime_sign_assemble(hp, bp, sp, name);
1772       hp = bp = sp = NULL;
1773    }
1774
1775 jleave:
1776    if (chain != NULL)
1777       sk_X509_pop_free(chain, X509_free);
1778    if (cert != NULL)
1779       X509_free(cert);
1780    if (pkey != NULL)
1781       EVP_PKEY_free(pkey);
1782    if (fp != NULL)
1783       Fclose(fp);
1784    if (hp != NULL)
1785       Fclose(hp);
1786    if (bp != NULL)
1787       Fclose(bp);
1788    if (sp != NULL)
1789       Fclose(sp);
1790    NYD_LEAVE;
1791    return rv;
1792 }
1793
1794 FL FILE *
1795 smime_encrypt(FILE *ip, char const *xcertfile, char const *to)
1796 {
1797    FILE *rv, *yp, *fp, *bp, *hp;
1798    X509 *cert;
1799    PKCS7 *pkcs7;
1800    BIO *bb, *yb;
1801    n_XSSL_STACKOF(X509) *certs;
1802    EVP_CIPHER const *cipher;
1803    char *certfile;
1804    bool_t bail;
1805    NYD_ENTER;
1806
1807    bail = FAL0;
1808    rv = yp = fp = bp = hp = NULL;
1809
1810    if ((certfile = fexpand(xcertfile, FEXP_LOCAL | FEXP_NOPROTO)) == NULL)
1811       goto jleave;
1812
1813    a_xssl_init();
1814
1815    if ((cipher = _smime_cipher(to)) == NULL)
1816       goto jleave;
1817
1818    if ((fp = Fopen(certfile, "r")) == NULL) {
1819       n_perr(certfile, 0);
1820       goto jleave;
1821    }
1822    if ((cert = PEM_read_X509(fp, NULL, &ssl_password_cb, NULL)) == NULL) {
1823       ssl_gen_err(_("Error reading encryption certificate from %s"),
1824          n_shexp_quote_cp(certfile, FAL0));
1825       bail = TRU1;
1826    }
1827    if (bail)
1828       goto jleave;
1829    Fclose(fp);
1830    fp = NULL;
1831    bail = FAL0;
1832
1833    certs = sk_X509_new_null();
1834    sk_X509_push(certs, cert);
1835
1836    if ((yp = Ftmp(NULL, "smimeenc", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1837          NULL) {
1838       n_perr(_("tempfile"), 0);
1839       goto jerr1;
1840    }
1841
1842    rewind(ip);
1843    if (smime_split(ip, &hp, &bp, -1, 0) == STOP)
1844       goto jerr1;
1845
1846    yb = NULL;
1847    if ((bb = BIO_new_fp(bp, BIO_NOCLOSE)) == NULL ||
1848          (yb = BIO_new_fp(yp, BIO_NOCLOSE)) == NULL) {
1849       ssl_gen_err(_("Error creating BIO encryption objects"));
1850       bail = TRU1;
1851       goto jerr2;
1852    }
1853    if ((pkcs7 = PKCS7_encrypt(certs, bb, cipher, 0)) == NULL) {
1854       ssl_gen_err(_("Error creating the PKCS#7 encryption object"));
1855       bail = TRU1;
1856       goto jerr2;
1857    }
1858    if (PEM_write_bio_PKCS7(yb, pkcs7) == 0) {
1859       ssl_gen_err(_("Error writing encrypted S/MIME data"));
1860       bail = TRU1;
1861       /* goto jerr2 */
1862    }
1863    PKCS7_free(pkcs7);
1864
1865 jerr2:
1866    if (bb != NULL)
1867       BIO_free(bb);
1868    if (yb != NULL)
1869       BIO_free(yb);
1870    Fclose(bp);
1871    bp = NULL;
1872    if (!bail) {
1873       fflush_rewind(yp);
1874       rv = smime_encrypt_assemble(hp, yp);
1875       hp = yp = NULL;
1876    }
1877 jerr1:
1878    sk_X509_pop_free(certs, X509_free);
1879 jleave:
1880    if(yp != NULL)
1881       Fclose(yp);
1882    if(fp != NULL)
1883       Fclose(fp);
1884    if(bp != NULL)
1885       Fclose(bp);
1886    if(hp != NULL)
1887       Fclose(hp);
1888    NYD_LEAVE;
1889    return rv;
1890 }
1891
1892 FL struct message *
1893 smime_decrypt(struct message *m, char const *to, char const *cc,
1894    bool_t signcall)
1895 {
1896    char const *myaddr;
1897    long size;
1898    struct message *rv;
1899    FILE *bp, *hp, *op;
1900    PKCS7 *pkcs7;
1901    BIO *ob, *bb, *pb;
1902    X509 *cert;
1903    EVP_PKEY *pkey;
1904    FILE *yp;
1905    NYD_ENTER;
1906
1907    pkey = NULL;
1908    cert = NULL;
1909    ob = bb = pb = NULL;
1910    pkcs7 = NULL;
1911    bp = hp = op = NULL;
1912    rv = NULL;
1913    size = m->m_size;
1914
1915    if((yp = setinput(&mb, m, NEED_BODY)) == NULL)
1916       goto jleave;
1917
1918    a_xssl_init();
1919
1920    if((op = smime_sign_cert(to, cc, 0, &myaddr)) != NULL){
1921       pkey = PEM_read_PrivateKey(op, NULL, &ssl_password_cb,
1922             savecat(myaddr, ".smime-cert-key"));
1923       if(pkey == NULL){
1924          ssl_gen_err(_("Error reading private key"));
1925          goto jleave;
1926       }
1927
1928       rewind(op);
1929       if((cert = PEM_read_X509(op, NULL, &ssl_password_cb,
1930             savecat(myaddr, ".smime-cert-cert"))) == NULL){
1931          ssl_gen_err(_("Error reading decryption certificate"));
1932          goto jleave;
1933       }
1934
1935       Fclose(op);
1936       op = NULL;
1937    }
1938
1939    if((op = Ftmp(NULL, "smimedec", OF_RDWR | OF_UNLINK | OF_REGISTER)) == NULL){
1940       n_perr(_("tempfile"), 0);
1941       goto jleave;
1942    }
1943
1944    if(smime_split(yp, &hp, &bp, size, 1) == STOP)
1945       goto jleave;
1946
1947    if((ob = BIO_new_fp(op, BIO_NOCLOSE)) == NULL ||
1948          (bb = BIO_new_fp(bp, BIO_NOCLOSE)) == NULL){
1949       ssl_gen_err(_("Error creating BIO decryption objects"));
1950       goto jleave;
1951    }
1952
1953    if((pkcs7 = SMIME_read_PKCS7(bb, &pb)) == NULL){
1954       ssl_gen_err(_("Error reading PKCS#7 object"));
1955       goto jleave;
1956    }
1957
1958    if(PKCS7_type_is_signed(pkcs7)){
1959       if(signcall){
1960          setinput(&mb, m, NEED_BODY);
1961          rv = (struct message*)-1;
1962          goto jleave;
1963       }
1964       if(PKCS7_verify(pkcs7, NULL, NULL, NULL, ob,
1965             PKCS7_NOVERIFY | PKCS7_NOSIGS) != 1)
1966          goto jerr;
1967       fseek(hp, 0L, SEEK_END);
1968       fprintf(hp, "X-Encryption-Cipher: none\n");
1969       fflush_rewind(hp);
1970    }else if(pkey == NULL){
1971       n_err(_("No appropriate private key found\n"));
1972       goto jleave;
1973    }else if(cert == NULL){
1974       n_err(_("No appropriate certificate found\n"));
1975       goto jleave;
1976    }else if(PKCS7_decrypt(pkcs7, pkey, cert, ob, 0) != 1){
1977 jerr:
1978       ssl_gen_err(_("Error decrypting PKCS#7 object"));
1979       goto jleave;
1980    }
1981    fflush_rewind(op);
1982    Fclose(bp);
1983    bp = NULL;
1984
1985    rv = smime_decrypt_assemble(m, hp, op);
1986    hp = op = NULL; /* xxx closed by decrypt_assemble */
1987 jleave:
1988    if(op != NULL)
1989       Fclose(op);
1990    if(hp != NULL)
1991       Fclose(hp);
1992    if(bp != NULL)
1993       Fclose(bp);
1994    if(bb != NULL)
1995       BIO_free(bb);
1996    if(ob != NULL)
1997       BIO_free(ob);
1998    if(pkcs7 != NULL)
1999       PKCS7_free(pkcs7);
2000    if(cert != NULL)
2001       X509_free(cert);
2002    if(pkey != NULL)
2003       EVP_PKEY_free(pkey);
2004    NYD_LEAVE;
2005    return rv;
2006 }
2007
2008 FL enum okay
2009 smime_certsave(struct message *m, int n, FILE *op)
2010 {
2011    struct message *x;
2012    char *to, *cc, *cnttype;
2013    int c, i;
2014    FILE *fp, *ip;
2015    off_t size;
2016    BIO *fb, *pb;
2017    PKCS7 *pkcs7;
2018    n_XSSL_STACKOF(X509) *certs, *chain = NULL;
2019    X509 *cert;
2020    enum okay rv = STOP;
2021    NYD_ENTER;
2022
2023    pkcs7 = NULL;
2024
2025    a_xssl_msgno = (size_t)n;
2026 jloop:
2027    to = hfield1("to", m);
2028    cc = hfield1("cc", m);
2029    cnttype = hfield1("content-type", m);
2030
2031    if ((ip = setinput(&mb, m, NEED_BODY)) == NULL)
2032       goto jleave;
2033
2034 #undef _X
2035 #undef _Y
2036 #define _X     (sizeof("application/") -1)
2037 #define _Y(X)  X, sizeof(X) -1
2038    if (cnttype && is_asccaseprefix("application/", cnttype) &&
2039          (!ascncasecmp(cnttype + _X, _Y("pkcs7-mime")) ||
2040           !ascncasecmp(cnttype + _X, _Y("x-pkcs7-mime")))) {
2041 #undef _Y
2042 #undef _X
2043       if ((x = smime_decrypt(m, to, cc, 1)) == NULL)
2044          goto jleave;
2045       if (x != (struct message*)-1) {
2046          m = x;
2047          goto jloop;
2048       }
2049    }
2050    size = m->m_size;
2051
2052    if ((fp = Ftmp(NULL, "smimecert", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
2053          NULL) {
2054       n_perr(_("tempfile"), 0);
2055       goto jleave;
2056    }
2057
2058    while (size-- > 0) {
2059       c = getc(ip);
2060       putc(c, fp);
2061    }
2062    fflush(fp);
2063
2064    rewind(fp);
2065    if ((fb = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
2066       ssl_gen_err("Error creating BIO object for message %d", n);
2067       Fclose(fp);
2068       goto jleave;
2069    }
2070
2071    if ((pkcs7 = SMIME_read_PKCS7(fb, &pb)) == NULL) {
2072       ssl_gen_err(_("Error reading PKCS#7 object for message %d"), n);
2073       BIO_free(fb);
2074       Fclose(fp);
2075       goto jleave;
2076    }
2077    BIO_free(fb);
2078    Fclose(fp);
2079
2080    certs = PKCS7_get0_signers(pkcs7, chain, 0);
2081    if (certs == NULL) {
2082       n_err(_("No certificates found in message %d\n"), n);
2083       goto jleave;
2084    }
2085
2086    for (i = 0; i < sk_X509_num(certs); ++i) {
2087       cert = sk_X509_value(certs, i);
2088       if (X509_print_fp(op, cert) == 0 || PEM_write_X509(op, cert) == 0) {
2089          ssl_gen_err(_("Error writing certificate %d from message %d"),
2090             i, n);
2091          goto jleave;
2092       }
2093    }
2094    rv = OKAY;
2095 jleave:
2096    if(pkcs7 != NULL)
2097       PKCS7_free(pkcs7);
2098    NYD_LEAVE;
2099    return rv;
2100 }
2101 #endif /* HAVE_XSSL */
2102
2103 /* s-it-mode */