/*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* For more ,please contact QQ/wechat:4108863/mail:4108863@qq.com

* http://www.hihttps.com

*/

#include "config.h"

#include <sys/socket.h>

#include <sys/time.h>

#include <sys/types.h>

#include <sys/un.h>

#include <sys/wait.h> /* WAIT_PID */

#ifdef __linux__

#include <sys/prctl.h>

#endif

#ifdef __sun

#include <sys/filio.h>

#endif

#include <net/if.h>

#include <netinet/in.h>

#include <netinet/tcp.h> /* TCP_NODELAY */

#include <ctype.h>

#include <errno.h>

#include <getopt.h>

#include <grp.h>

#include <libgen.h>

#include <limits.h>

#include <netdb.h>

#include <pwd.h>

#include <sched.h>

#include <signal.h>

#include <stdarg.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <time.h>

#include <unistd.h>

#include "configuration.h"

#include "aihttps.h"

#include "hssl_locks.h"

#include "logging.h"

#include "ocsp.h"

#include "shctx.h"

#include "foreign/vpf.h"

#include "foreign/uthash.h"

#include "foreign/vsa.h"

#include "waf/rules.h"

#include "waf/cc_ddos.h"

#include "waf/atklog.h"

#ifndef MSG_NOSIGNAL

# define MSG_NOSIGNAL 0

#endif

#ifndef AI_ADDRCONFIG

# define AI_ADDRCONFIG 0

#endif

/* For Mac OS X */

#ifndef TCP_KEEPIDLE

# ifdef TCP_KEEPALIVE

# define TCP_KEEPIDLE TCP_KEEPALIVE

# endif

#endif

#ifndef SOL_TCP

# define SOL_TCP IPPROTO_TCP

#endif

/* Do we have SNI support? */

#ifndef OPENSSL_NO_TLSEXT

#ifndef SSL_CTRL_SET_TLSEXT_HOSTNAME

#define OPENSSL_NO_TLSEXT

#endif

#endif

/* logging.c */

extern FILE *logfile;

extern struct stat logf_st;

extern time_t logf_check_t;

/* Globals */

struct ev_loop *loop;

aihttps_config *CONFIG;

/* Worker proc's read side of mgt->worker pipe(2) */

static ev_io mgt_rd;

struct backend {

unsigned magic;

#define BACKEND_MAGIC 0x41c09397

struct suckaddr *backaddr;

int ref;

};

static struct backend *backaddr;

static pid_t master_pid;

static pid_t ocsp_proc_pid;

static int core_id;

static SSL_SESSION *client_session;

/* The current number of active client connections. */

static uint64_t n_conns;

/* Current generation of worker processes. after a sighup prior

* to launching new children. */

static unsigned worker_gen;

static volatile unsigned n_sighup;

static volatile unsigned n_sigchld;

enum worker_state_e {

WORKER_ACTIVE,

WORKER_EXITING

};

static enum worker_state_e worker_state;

struct worker_proc {

unsigned magic;

#define WORKER_PROC_MAGIC 0xbc7fe9e6

/* Writer end of pipe(2) for mgt -> worker ipc */

int pfd;

pid_t pid;

unsigned gen;

int core_id;

VTAILQ_ENTRY(worker_proc) list;

};

VTAILQ_HEAD(worker_proc_head, worker_proc);

static struct worker_proc_head worker_procs;

struct sslctx_s;

struct sni_name_s;

struct listen_sock {

unsigned magic;

#define LISTEN_SOCK_MAGIC 0xda96b2f6

int sock;

char *name;

ev_io listener;

struct sockaddr_storage addr;

VTAILQ_ENTRY(listen_sock) list;

};

VTAILQ_HEAD(listen_sock_head, listen_sock);

struct frontend {

unsigned magic;

#define FRONTEND_MAGIC 0x5b04e577

int match_global_certs;

int sni_nomatch_abort;

struct sni_name_s *sni_names;

struct sslctx_s *ssl_ctxs;

struct sslctx_s *default_ctx;

char *pspec;

struct listen_sock_head socks;

VTAILQ_ENTRY(frontend) list;

};

VTAILQ_HEAD(frontend_head, frontend);

static struct frontend_head frontends;

#ifdef USE_SHARED_CACHE

static ev_io shcupd_listener;

static int shcupd_socket;

struct addrinfo *shcupd_peers[MAX_SHCUPD_PEERS+1];

static unsigned char shared_secret[SHA_DIGEST_LENGTH];

#endif /*USE_SHARED_CACHE*/

int create_workers;

static struct vpf_fh *pfh = NULL;

static char tcp_proxy_line[128] = "";

/* What agent/state requests the shutdown--for proper half-closed

* handling */

typedef enum _SHUTDOWN_REQUESTOR {

SHUTDOWN_HARD,

SHUTDOWN_CLEAR,

SHUTDOWN_SSL

} SHUTDOWN_REQUESTOR;

static const char *SHUTDOWN_STR[] = {

[SHUTDOWN_HARD] = "SHUTDOWN_HARD",

[SHUTDOWN_CLEAR] = "SHUTDOWN_CLEAR",

[SHUTDOWN_SSL] = "SHUTDOWN_SSL",

};

#ifndef OPENSSL_NO_TLSEXT

sni_name *sni_names;

static sslctx *ssl_ctxs;

static sslctx *default_ctx;

static void insert_sni_names(sslctx *sc, sni_name **sn_tab);

static int load_cert_ctx(sslctx *so);

#endif /* OPENSSL_NO_TLSEXT */

union ha_proxy_v2_addr {

struct { /* for TCP/UDP over IPv4, len = 12 */

uint32_t src_addr;

uint32_t dst_addr;

uint16_t src_port;

uint16_t dst_port;

} ipv4;

struct { /* for TCP/UDP over IPv6, len = 36 */

uint8_t src_addr[16];

uint8_t dst_addr[16];

uint16_t src_port;

uint16_t dst_port;

} ipv6;

struct { /* for AF_UNIX sockets, len = 216 */

uint8_t src_addr[108];

uint8_t dst_addr[108];

} local;

};

struct ha_proxy_v2_hdr {

uint8_t sig[12];

uint8_t ver_cmd;

uint8_t fam;

uint16_t len; /* number of following bytes

* part of the header */

union ha_proxy_v2_addr addr;

};

enum worker_update_type {

WORKER_GEN,

BACKEND_REFRESH

};

union worker_update_payload {

unsigned gen;

struct sockaddr_storage addr;

};

struct worker_update {

enum worker_update_type type;

union worker_update_payload payload;

};

/* set a file descriptor (socket) to non-blocking mode */

static int

setnonblocking(int fd)

{

int flag = 1;

if (ioctl(fd, FIONBIO, &flag) < 0) {

assert (errno == ECONNRESET || errno == ENOTCONN);

return (-1);

}

return (0);

}

/* set a tcp socket to use TCP Keepalive */

static void

settcpkeepalive(int fd)

{

int optval = 1;

socklen_t optlen = sizeof(optval);

if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen) < 0) {

SOCKERR("Error activating SO_KEEPALIVE on client socket");

}

#ifdef TCP_KEEPIDLE

optval = CONFIG->TCP_KEEPALIVE_TIME;

optlen = sizeof(optval);

if (setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, &optval, optlen) < 0) {

SOCKERR("Error setting TCP_KEEPIDLE on client socket");

}

#endif

}

#ifndef OPENSSL_NO_DH

static int

init_dh(SSL_CTX *ctx, const char *cert)

{

DH *dh;

BIO *bio;

AN(cert);

bio = BIO_new_file(cert, "r");

if (!bio) {

log_ssl_error(NULL, "{core} BIO_new_file");

return (-1);

}

dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);

BIO_free(bio);

if (!dh) {

LOG("{core} Note: no DH parameters found in %s\n", cert);

return (-1);

}

LOG("{core} Using DH parameters from %s\n", cert);

if (!SSL_CTX_set_tmp_dh(ctx, dh)) {

log_ssl_error(NULL, "{core} Error setting temp DH params");

return (-1);

}

LOG("{core} DH initialized with %d bit key\n", 8*DH_size(dh));

DH_free(dh);

return (0);

}

static int init_ecdh(SSL_CTX *ctx) {

#ifndef OPENSSL_NO_EC

#ifdef NID_X9_62_prime256v1

EC_KEY *ecdh = NULL;

ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);

SSL_CTX_set_tmp_ecdh(ctx, ecdh);

EC_KEY_free(ecdh);

LOG("{core} ECDH Initialized with NIST P-256\n");

#endif /* NID_X9_62_prime256v1 */

#endif /* OPENSSL_NO_EC */

return 0;

}

#endif /* OPENSSL_NO_DH */

/* This callback function is executed while OpenSSL processes the SSL

* handshake and does SSL record layer stuff. It's used to trap

* client-initiated renegotiations.

*/

static void

info_callback(const SSL *ssl, int where, int ret)

{

proxystate *ps;

(void)ret;

if (where & SSL_CB_HANDSHAKE_START) {

CAST_OBJ_NOTNULL(ps, SSL_get_app_data(ssl), PROXYSTATE_MAGIC);

if (ps->handshaked) {

ps->renegotiation = 1;

LOG("{core} SSL renegotiation asked by client\n");

}

}

}

#ifdef OPENSSL_WITH_NPN

static int npn_select_cb(SSL *ssl, const unsigned char **out,

unsigned *outlen, void *arg) {

proxystate *ps;

(void)arg;

CAST_OBJ_NOTNULL(ps, SSL_get_app_data(ssl), PROXYSTATE_MAGIC);

ps->npn_alpn_tried = 1;

LOG("{npn} Got NPN callback\n");

*out = (unsigned char *) CONFIG->ALPN_PROTOS_LV;

*outlen = CONFIG->ALPN_PROTOS_LV_LEN;

return SSL_TLSEXT_ERR_OK;

}

#endif

#ifdef OPENSSL_WITH_ALPN

static int alpn_select_cb(SSL *ssl,

const unsigned char **out,

unsigned char *outlen,

const unsigned char *in,

unsigned int inlen,

void *arg)

{

int selected;

proxystate *ps;

(void)arg;

CAST_OBJ_NOTNULL(ps, SSL_get_app_data(ssl), PROXYSTATE_MAGIC);

ps->npn_alpn_tried = 1;

selected = SSL_select_next_proto((unsigned char **)out, outlen,

CONFIG->ALPN_PROTOS_LV, CONFIG->ALPN_PROTOS_LV_LEN, in, inlen);

if (selected == OPENSSL_NPN_NEGOTIATED)

return SSL_TLSEXT_ERR_OK;

else {

assert(selected == OPENSSL_NPN_NO_OVERLAP);

LOGPROXY(ps, "ALPN: no overlap in protocols.\n");

/* Here it is possible to add logging of which protocols

the client wanted */

return SSL_TLSEXT_ERR_NOACK;

}

return SSL_TLSEXT_ERR_NOACK;

}

#endif

#ifdef USE_SHARED_CACHE

/* Handle incoming message updates */

static void

handle_shcupd(struct ev_loop *loop, ev_io *w, int revents)

{

(void)revents;

unsigned char msg[SHSESS_MAX_ENCODED_LEN], hash[EVP_MAX_MD_SIZE];

ssize_t r;

unsigned int hash_len;

uint32_t encdate;

long now = (time_t)ev_now(loop);

while ((r = recv(w->fd, msg, sizeof(msg), 0)) > 0) {

/* msg len must be greater than 1 Byte of data + sig length */

if (r < (int)(1+sizeof(shared_secret)))

continue;

/* compute sig */

r -= sizeof(shared_secret);

HMAC(EVP_sha1(), shared_secret, sizeof(shared_secret), msg,

r, hash, &hash_len);

if (hash_len != sizeof(shared_secret)) /* should never happen */

continue;

/* check sign */

if (memcmp(msg+r, hash, hash_len))

continue;

/* msg len must be greater than 1 Byte of data +

* encdate length */

if (r < (int)(1+sizeof(uint32_t)))

continue;

/* drop too unsync updates */

r -= sizeof(uint32_t);

encdate = *((uint32_t *)&msg[r]);

if (!(abs((int)(int32_t)now - ntohl(encdate))

< SSL_CTX_get_timeout(default_ctx->ctx)))

continue;

shctx_sess_add(msg, r, now);

}

}

/* Send remote updates messages callback */

void

shcupd_session_new(unsigned char *msg, unsigned int len, long cdate)

{

unsigned int hash_len;

struct addrinfo **pai = shcupd_peers;

uint32_t ncdate;

/* add session creation encoded date to footer */

ncdate = htonl((uint32_t)cdate);

memcpy(msg+len, &ncdate, sizeof(ncdate));

len += sizeof(ncdate);

/* add msg sign */

HMAC(EVP_sha1(), shared_secret, sizeof(shared_secret),

msg, len, msg+len, &hash_len);

len += hash_len;

/* send msg to peers */

while (*pai) {

sendto(shcupd_socket, msg, len, 0, (*pai)->ai_addr,

(*pai)->ai_addrlen);

pai++;

}

}

/* Compute a sha1 secret from an ASN1 rsa private key */

static int

compute_secret(RSA *rsa, unsigned char *secret)

{

unsigned char *buf, *p;

unsigned int length;

length = i2d_RSAPrivateKey(rsa, NULL);

if (length <= 0)

return -1;

p = buf = (unsigned char *)malloc(length*sizeof(unsigned char));

if (!buf)

return -1;

i2d_RSAPrivateKey(rsa,&p);

SHA1(buf, length, secret);

free(buf);

return 0;

}

/* Create udp socket to receive and send updates */

static int

create_shcupd_socket()

{

struct addrinfo *ai, hints;

struct addrinfo **pai = shcupd_peers;

memset(&hints, 0, sizeof hints);

hints.ai_family = AF_UNSPEC;

hints.ai_socktype = SOCK_DGRAM;

hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;

const int gai_err = getaddrinfo(CONFIG->SHCUPD_IP,

CONFIG->SHCUPD_PORT, &hints, &ai);

if (gai_err != 0) {

ERR("{getaddrinfo}: %s\n", gai_strerror(gai_err));

exit(1);

}

/* check if peers inet family addresses match */

while (*pai) {

if ((*pai)->ai_family != ai->ai_family) {

ERR("Share host and peers inet family differs\n");

exit(1);

}

pai++;

}

int s = socket(ai->ai_family, SOCK_DGRAM, IPPROTO_UDP);

if (s == -1)

fail("{socket: shared cache updates}");

int t = 1;

(void)setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &t, sizeof(int));

#ifdef SO_REUSEPORT_WORKS

(void)setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &t, sizeof(int));

#endif

if (setnonblocking(s) < 0)

fail("{shared cache: setnonblocking}");

if (ai->ai_addr->sa_family == AF_INET) {

struct ip_mreqn mreqn;

memset(&mreqn, 0, sizeof(mreqn));

mreqn.imr_multiaddr.s_addr =

((struct sockaddr_in *)ai->ai_addr)->sin_addr.s_addr;

if (CONFIG->SHCUPD_MCASTIF) {

if (isalpha(*CONFIG->SHCUPD_MCASTIF)) {

/* appears to be an iface name */

struct ifreq ifr;

memset(&ifr, 0, sizeof(ifr));

if (strlen(CONFIG->SHCUPD_MCASTIF) > IFNAMSIZ) {

ERR("Error iface name is too "

"long [%s]\n",

CONFIG->SHCUPD_MCASTIF);

exit(1);

}

memcpy(ifr.ifr_name, CONFIG->SHCUPD_MCASTIF,

strlen(CONFIG->SHCUPD_MCASTIF));

if (ioctl(s, SIOCGIFINDEX, &ifr)) {

fail("{ioctl: SIOCGIFINDEX}");

}

mreqn.imr_ifindex = ifr.ifr_ifindex;

} else if (strchr(CONFIG->SHCUPD_MCASTIF,'.')) {

/* appears to be an ipv4 address */

mreqn.imr_address.s_addr =

inet_addr(CONFIG->SHCUPD_MCASTIF);

} else {

/* appears to be an iface index */

mreqn.imr_ifindex =

atoi(CONFIG->SHCUPD_MCASTIF);

}

}

if (setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,

&mreqn, sizeof(mreqn)) < 0) {

if (errno != EINVAL) {

/* EINVAL if it is not a multicast address,

* not an error we consider unicast */

fail("{setsockopt: IP_ADD_MEMBERSIP}");

}

} else { /* this is a multicast address */

unsigned char loop = 0;

if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP,

&loop, sizeof(loop)) < 0) {

fail("{setsockopt: IP_MULTICAST_LOOP}");

}

}

/* optional set sockopts for sending to multicast msg */

if (CONFIG->SHCUPD_MCASTIF &&

setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF,

&mreqn, sizeof(mreqn)) < 0) {

fail("{setsockopt: IP_MULTICAST_IF}");

}

if (CONFIG->SHCUPD_MCASTTTL) {

unsigned char ttl;

ttl = (unsigned char)atoi(CONFIG->SHCUPD_MCASTTTL);

if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL,

&ttl, sizeof(ttl)) < 0) {

fail("{setsockopt: IP_MULTICAST_TTL}");

}

}

}

#ifdef IPV6_ADD_MEMBERSHIP

else if (ai->ai_addr->sa_family == AF_INET6) {

struct ipv6_mreq mreq;

memset(&mreq, 0, sizeof(mreq));

memcpy(&mreq.ipv6mr_multiaddr,

&((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr,

sizeof(mreq.ipv6mr_multiaddr));

if (CONFIG->SHCUPD_MCASTIF) {

if (isalpha(*CONFIG->SHCUPD_MCASTIF)) {

/* appears to be an iface name */

struct ifreq ifr;

memset(&ifr, 0, sizeof(ifr));

if (strlen(CONFIG->SHCUPD_MCASTIF) > IFNAMSIZ) {

ERR("Error iface name is too "

"long [%s]\n",

CONFIG->SHCUPD_MCASTIF);

exit(1);

}

memcpy(ifr.ifr_name, CONFIG->SHCUPD_MCASTIF,

strlen(CONFIG->SHCUPD_MCASTIF));

if (ioctl(s, SIOCGIFINDEX, &ifr))

fail("{ioctl: SIOCGIFINDEX}");

mreq.ipv6mr_interface = ifr.ifr_ifindex;

} else { /* option appears to be an iface index */

mreq.ipv6mr_interface =

atoi(CONFIG->SHCUPD_MCASTIF);

}

}

if (setsockopt(s, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,

&mreq, sizeof(mreq)) < 0) {

if (errno != EINVAL) {

/* EINVAL if it is not a multicast address,

* not an error we consider unicast */

fail("{setsockopt: IPV6_ADD_MEMBERSIP}");

}

} else { /* this is a multicast address */

unsigned int loop = 0;

if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,

&loop, sizeof(loop)) < 0) {

fail("{setsockopt: IPV6_MULTICAST_LOOP}");

}

}

/* optional set sockopts for sending to multicast msg */

if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_IF,

&mreq.ipv6mr_interface,

sizeof(mreq.ipv6mr_interface)) < 0) {

fail("{setsockopt: IPV6_MULTICAST_IF}");

}

if (CONFIG->SHCUPD_MCASTTTL) {

int hops;

hops = atoi(CONFIG->SHCUPD_MCASTTTL);

if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,

&hops, sizeof(hops)) < 0) {

fail("{setsockopt: IPV6_MULTICAST_HOPS}");

}

}

}

#endif /* IPV6_ADD_MEMBERSHIP */

if (bind(s, ai->ai_addr, ai->ai_addrlen)) {

fail("{bind-socket}");

}

freeaddrinfo(ai);

return s;

}

#endif /*USE_SHARED_CACHE */

EVP_PKEY *

load_privatekey(SSL_CTX *ctx, const char *file)

{

BIO *bio;

EVP_PKEY *pkey;

bio = BIO_new_file(file, "r");

if (!bio) {

log_ssl_error(NULL, "{core} BIO_new_file");

return NULL;

}

#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)

#define SSL_CTX_get_default_passwd_cb(ctx) (ctx->default_passwd_callback)

#define SSL_CTX_get_default_passwd_cb_userdata(ctx) (ctx->default_passwd_callback_userdata)

#endif

pkey = PEM_read_bio_PrivateKey(bio, NULL,

SSL_CTX_get_default_passwd_cb(ctx),

SSL_CTX_get_default_passwd_cb_userdata(ctx));

BIO_free(bio);

if (!pkey) {

log_ssl_error(NULL, "{core} PEM_read_bio_PrivateKey");

return NULL;

}

return (pkey);

}

#ifndef OPENSSL_NO_TLSEXT

static int

sni_match(const sni_name *sn, const char *srvname)

{

if (!sn->is_wildcard)

return (strcasecmp(srvname, sn->servername) == 0);

else {

char *s = strchr(srvname, '.');

if (s == NULL)

return (0);

return (strcasecmp(s, sn->servername + 1) == 0);

}

}

static sslctx *

sni_lookup(const char *servername, const sni_name *sn_tab)

{

const sni_name *sn;

HASH_FIND_STR(sn_tab, servername, sn);

if (sn == NULL) {

char *s;

/* attempt another lookup for wildcard matches */

s = strchr(servername, '.');

if (s != NULL) {

HASH_FIND_STR(sn_tab, s, sn);

}

}

if (sn != NULL) {

CHECK_OBJ_NOTNULL(sn, SNI_NAME_MAGIC);

if (sni_match(sn, servername))

return (sn->sctx);

}

return (NULL);

}

/*

* Switch the context of the current SSL object to the most appropriate one

* based on the SNI header

*/

static int

sni_switch_ctx(SSL *ssl, int *al, void *data)

{

const char *servername;

sslctx *sc;

const struct frontend *fr = NULL;

int lookup_global = 1;

int sni_nomatch_abort = CONFIG->SNI_NOMATCH_ABORT;

(void)al;

if (data != NULL)

CAST_OBJ_NOTNULL(fr, data, FRONTEND_MAGIC);

servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);

if (!servername)

return (SSL_TLSEXT_ERR_NOACK);

#define TRY_SNI_MATCH(sn_tab) \

do { \

sc = sni_lookup(servername, (sn_tab)); \

if (sc != NULL) { \

CHECK_OBJ_NOTNULL(sc, SSLCTX_MAGIC); \

SSL_set_SSL_CTX(ssl, sc->ctx); \

return (SSL_TLSEXT_ERR_OK); \

} \

} while (0)

if (fr != NULL) {

TRY_SNI_MATCH(fr->sni_names);

lookup_global = fr->match_global_certs;

if (fr->sni_nomatch_abort != -1)

sni_nomatch_abort = fr->sni_nomatch_abort;

}

if (lookup_global)

TRY_SNI_MATCH(sni_names);

/* No matching certs */

if (sni_nomatch_abort)

return (SSL_TLSEXT_ERR_ALERT_FATAL);

else

return (SSL_TLSEXT_ERR_NOACK);

}

#endif /* OPENSSL_NO_TLSEXT */

static void

sctx_free(sslctx *sc, sni_name **sn_tab)

{

sni_name *sn, *sntmp;

if (sc == NULL)

return;

HOCSP_free(&sc->staple);

if (sn_tab != NULL)

CHECK_OBJ_NOTNULL(*sn_tab, SNI_NAME_MAGIC);

CHECK_OBJ_NOTNULL(sc, SSLCTX_MAGIC);

VTAILQ_FOREACH_SAFE(sn, &sc->sni_list, list, sntmp) {

CHECK_OBJ_NOTNULL(sn, SNI_NAME_MAGIC);

VTAILQ_REMOVE(&sc->sni_list, sn, list);

if (sn_tab != NULL)

HASH_DEL(*sn_tab, sn);

free(sn->servername);

FREE_OBJ(sn);

}

free(sc->filename);

SSL_CTX_free(sc->ctx);

FREE_OBJ(sc);

}

X509 *

Find_issuer(X509 *subj, STACK_OF(X509) *chain)

{

int i;

X509 *x;

AN(subj);

for (i = 0; i < sk_X509_num(chain); i++) {

x = sk_X509_value(chain, i);

if (X509_check_issued(x, subj) == X509_V_OK)

return (x);

}

/* todo: look in cert store? */

return (NULL);

}

/* Initialize an SSL context */

static sslctx *

make_ctx_fr(const struct cfg_cert_file *cf, const struct frontend *fr,

const struct front_arg *fa)

{

SSL_CTX *ctx;

sslctx *sc;

EVP_PKEY *pkey;

int selected_protos = CONFIG->SELECTED_TLS_PROTOS;

char *ciphers = CONFIG->CIPHER_SUITE;

int pref_srv_ciphers = CONFIG->PREFER_SERVER_CIPHERS;

if (fa != NULL) {

CHECK_OBJ_NOTNULL(fa, FRONT_ARG_MAGIC);

if (fa->selected_protos != 0)

selected_protos = fa->selected_protos;

if (fa->ciphers != NULL)

ciphers = fa->ciphers;

if (fa->prefer_server_ciphers != -1)

pref_srv_ciphers = fa->prefer_server_ciphers;

}

long ssloptions = SSL_OP_NO_SSLv2 | SSL_OP_ALL |

SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;

#ifdef SSL_OP_NO_COMPRESSION

ssloptions |= SSL_OP_NO_COMPRESSION;

#endif

#ifdef SSL_OP_SINGLE_DH_USE

ssloptions |= SSL_OP_SINGLE_DH_USE;

#endif

#ifdef SSL_OP_SINGLE_ECDH_USE

ssloptions |= SSL_OP_SINGLE_ECDH_USE;

#endif

if (!(selected_protos & SSLv3_PROTO))

ssloptions |= SSL_OP_NO_SSLv3;

if (!(selected_protos & TLSv1_0_PROTO))

ssloptions |= SSL_OP_NO_TLSv1;

if (!(selected_protos & TLSv1_1_PROTO))

ssloptions |= SSL_OP_NO_TLSv1_1;

if (!(selected_protos & TLSv1_2_PROTO))

ssloptions |= SSL_OP_NO_TLSv1_2;

#ifdef SSL_OP_NO_TLSv1_3

if (!(selected_protos & TLSv1_3_PROTO))

ssloptions |= SSL_OP_NO_TLSv1_3;

#endif

ctx = SSL_CTX_new((CONFIG->PMODE == SSL_CLIENT) ?

SSLv23_client_method() : SSLv23_server_method());

SSL_CTX_set_options(ctx, ssloptions);

SSL_CTX_set_info_callback(ctx, info_callback);

#ifdef OPENSSL_WITH_ALPN

if (CONFIG->ALPN_PROTOS != NULL)

SSL_CTX_set_alpn_select_cb(ctx, alpn_select_cb, NULL);

#endif

#ifdef OPENSSL_WITH_NPN

if (CONFIG->ALPN_PROTOS != NULL)

SSL_CTX_set_next_protos_advertised_cb(ctx, npn_select_cb, NULL);

#endif

if (ciphers != NULL) {

if (SSL_CTX_set_cipher_list(ctx, ciphers) != 1) {

log_ssl_error(NULL, "{core} SSL_CTX_set_cipher_list");

return (NULL);

}

}

if (pref_srv_ciphers)

SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);

ALLOC_OBJ(sc, SSLCTX_MAGIC);

AN(sc);

sc->filename = strdup(cf->filename);

sc->mtim = cf->mtim;

sc->ctx = ctx;

sc->staple_vfy = cf->ocsp_vfy;

VTAILQ_INIT(&sc->sni_list);

if (sc->staple_vfy > 0 ||

(sc-> staple_vfy < 0 && CONFIG->OCSP_VFY))

AN(SSL_CTX_set_default_verify_paths(ctx));

if (CONFIG->PMODE == SSL_CLIENT)

return (sc);

/* SSL_SERVER Mode stuff */

if (SSL_CTX_use_certificate_chain_file(ctx, cf->filename) <= 0) {

log_ssl_error(NULL,

"Error loading certificate file %s\n", cf->filename);

sctx_free(sc, NULL);

return (NULL);

}

pkey = 0;

if (cf->priv_key_filename != 0) {

pkey = load_privatekey(ctx, cf->priv_key_filename);

if (!pkey) {

ERR("Error loading private key (%s)\n",

cf->priv_key_filename);

sctx_free(sc, NULL);

return (NULL);

}

}

if (!pkey) {

pkey = load_privatekey(ctx, cf->filename);

if (!pkey) {

ERR("Error loading private key (%s)\n", cf->filename);

sctx_free(sc, NULL);

return (NULL);

}

}

if (SSL_CTX_use_PrivateKey(ctx, pkey) <= 0) {

log_ssl_error(NULL, "SSL_CTX_use_PrivateKey: %s",

cf->filename);

EVP_PKEY_free(pkey);

sctx_free(sc, NULL);

return (NULL);

}

#ifndef OPENSSL_NO_DH

init_dh(ctx, cf->filename);

init_ecdh(ctx);

#endif /* OPENSSL_NO_DH */

#ifndef OPENSSL_NO_TLSEXT

if (!SSL_CTX_set_tlsext_servername_callback(ctx, sni_switch_ctx)) {

ERR("Error setting up SNI support.\n");

}

CHECK_OBJ_ORNULL(fr, FRONTEND_MAGIC);

if (!SSL_CTX_set_tlsext_servername_arg(ctx, (void *)fr)) {

ERR("Error setting SNI servername arg.\n");

}

if (load_cert_ctx(sc) != 0) {

EVP_PKEY_free(pkey);

sctx_free(sc, NULL);

return (NULL);

}

if (CONFIG->OCSP_DIR) {

char *fn = HOCSP_fn(sc->filename);

/* attempt loading of cached ocsp staple */

if (fn != NULL && HOCSP_init_file(fn, sc, 1) == 0) {

LOG("{core} Loaded cached OCSP staple for cert '%s'\n",

sc->filename);