1
0
forked from aniani/gmnisrv
gmnisrv/src/tls.c
mbays 5783501752 set session id context
This is necessary now client certificates are supported.
Without it, an attempt to resume a session fails with
"ssl_get_prev_session:session id context uninitialized".
2021-08-27 09:48:07 +02:00

242 lines
6.0 KiB
C

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "config.h"
#include "log.h"
#include "tls.h"
#include "util.h"
static int
always_true_callback(X509_STORE_CTX *ctx, void *arg)
{
(void)(ctx);
(void)(arg);
return 1;
}
static int
tls_host_gencert(struct gmnisrv_tls *tlsconf, struct gmnisrv_host *host,
const char *crtpath, const char *keypath)
{
server_log("generating certificate for %s", host->hostname);
EVP_PKEY *pkey = EVP_PKEY_new();
assert(pkey);
EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_secp384r1);
assert(ec_key);
int r = EC_KEY_generate_key(ec_key);
assert(r == 1);
EVP_PKEY_assign_EC_KEY(pkey, ec_key);
X509 * x509 = X509_new();
assert(x509);
X509_set_version(x509, 2);
ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
X509_gmtime_adj(X509_get_notBefore(x509), 0);
X509_gmtime_adj(X509_get_notAfter(x509), INT32_MAX); // 68 years
X509_set_pubkey(x509, pkey);
char *organization = "gmnisrv";
if (tlsconf->organization != NULL) {
organization = tlsconf->organization;
}
X509_NAME *name = X509_get_subject_name(x509);
X509_NAME_add_entry_by_txt(name, "O", MBSTRING_ASC,
(unsigned char *)organization, -1, -1, 0);
X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
(unsigned char *)host->hostname, -1, -1, 0);
X509_set_issuer_name(x509, name);
X509V3_CTX ctx;
X509V3_set_ctx_nodb(&ctx);
X509V3_set_ctx(&ctx, NULL, x509, NULL, NULL, 0);
char alt_name[512];
r = snprintf(alt_name, sizeof(alt_name), "DNS:%s", host->hostname);
assert(r >= 0 && (size_t)r < sizeof(alt_name));
X509_EXTENSION* ext = X509V3_EXT_conf_nid(NULL, &ctx,
NID_subject_alt_name, alt_name);
assert(ext);
X509_add_ext(x509, ext, -1);
X509_EXTENSION_free(ext);
r = X509_sign(x509, pkey, EVP_sha256());
assert(r);
int pfd = open(keypath, O_CREAT | O_WRONLY, 0600);
if (pfd < 0) {
server_error("opening private key for writing failed: %s",
strerror(errno));
return 1;
}
FILE *pf = fdopen(pfd, "w");
assert(pf);
r = PEM_write_PrivateKey(pf, pkey, NULL, NULL, 0, NULL, NULL);
fclose(pf);
if (r != 1) {
server_error("writing private key failed");
return 1;
}
FILE *xf = fopen(crtpath, "w");
if (!xf) {
server_error("opening certificate for writing failed: %s",
strerror(errno));
return 1;
}
r = PEM_write_X509(xf, x509);
fclose(xf);
if (r != 1) {
server_error("writing private key failed");
return 1;
}
host->x509 = x509;
host->pkey = pkey;
return 0;
}
static int
tls_host_init(struct gmnisrv_tls *tlsconf, struct gmnisrv_host *host)
{
char crtpath[PATH_MAX + 1];
char keypath[PATH_MAX + 1];
snprintf(crtpath, sizeof(crtpath),
"%s/%s.crt", tlsconf->store, host->hostname);
snprintf(keypath, sizeof(keypath),
"%s/%s.key", tlsconf->store, host->hostname);
mkdirs(tlsconf->store, 0755);
FILE *xf = fopen(crtpath, "r");
if (!xf && errno != ENOENT) {
server_error("error opening %s for reading: %s",
crtpath, strerror(errno));
return 1;
} else if (!xf) {
goto generate;
}
FILE *kf = fopen(keypath, "r");
if (!kf && errno != ENOENT) {
server_error("error opening %s for reading: %s",
keypath, strerror(errno));
fclose(xf);
return 1;
} else if (!kf) {
fclose(xf);
goto generate;
}
X509 *x509 = PEM_read_X509(xf, NULL, NULL, NULL);
fclose(xf);
if (!x509) {
server_error("error loading certificate from %s", crtpath);
fclose(kf);
return 1;
}
EVP_PKEY *pkey = PEM_read_PrivateKey(kf, NULL, NULL, NULL);
fclose(kf);
if (!pkey) {
server_error("error loading private key from %s", keypath);
return 1;
}
int day, sec;
const ASN1_TIME *notAfter = X509_get0_notAfter(x509);
int r = ASN1_TIME_diff(&day, &sec, NULL, notAfter);
assert(r == 1);
if (day < 0 || sec < 0) {
server_log("%s certificate is expired", host->hostname);
goto generate;
}
host->x509 = x509;
host->pkey = pkey;
server_log("loaded certificate for %s", host->hostname);
return 0;
generate:
return tls_host_gencert(tlsconf, host, crtpath, keypath);
}
int
tls_init(struct gmnisrv_config *conf)
{
SSL_load_error_strings();
ERR_load_crypto_strings();
conf->tls.ssl_ctx = SSL_CTX_new(TLS_server_method());
assert(conf->tls.ssl_ctx);
int r = SSL_CTX_set_min_proto_version(conf->tls.ssl_ctx, TLS1_2_VERSION);
assert(r == 1);
r = SSL_CTX_set_cipher_list(conf->tls.ssl_ctx,
"ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:"
"ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:"
"ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:"
"DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:"
"TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:"
"TLS_CHACHA20_POLY1305_SHA256");
assert(r == 1);
SSL_CTX_set_tlsext_servername_callback(conf->tls.ssl_ctx, NULL);
SSL_CTX_set_session_id_context(conf->tls.ssl_ctx, (const unsigned char*)"gmnisrv", 7);
SSL_CTX_set_verify(conf->tls.ssl_ctx, SSL_VERIFY_PEER, NULL);
// use always_true_callback to ignore errors such as self-signed error
SSL_CTX_set_cert_verify_callback(conf->tls.ssl_ctx, always_true_callback, NULL);
// TLS re-negotiation is a fucking STUPID idea
// I'm gating this behind an #ifdef based on an optimistic assumption
// that someday it will be removed from OpenSSL entirely because of how
// fucking stupid this fucking godawful idea is
#ifdef SSL_OP_NO_RENEGOTIATION
SSL_CTX_set_options(conf->tls.ssl_ctx, SSL_OP_NO_RENEGOTIATION);
#endif
for (struct gmnisrv_host *host = conf->hosts; host; host = host->next) {
r = tls_host_init(&conf->tls, host);
if (r != 0) {
return r;
}
}
return 0;
}
void
tls_finish(struct gmnisrv_config *conf)
{
SSL_CTX_free(conf->tls.ssl_ctx);
for (struct gmnisrv_host *host = conf->hosts; host; host = host->next) {
X509_free(host->x509);
EVP_PKEY_free(host->pkey);
}
}
SSL *
tls_get_ssl(struct gmnisrv_config *conf)
{
return SSL_new(conf->tls.ssl_ctx);
}
void
tls_set_host(SSL *ssl, struct gmnisrv_host *host)
{
SSL_use_certificate(ssl, host->x509);
SSL_use_PrivateKey(ssl, host->pkey);
}