mirror of https://github.com/yandex/odyssey.git
444 lines
9.0 KiB
C
444 lines
9.0 KiB
C
|
|
/*
|
|
* machinarium.
|
|
*
|
|
* cooperative multitasking engine.
|
|
*/
|
|
|
|
#include <machinarium.h>
|
|
#include <machinarium_private.h>
|
|
|
|
void mm_tlsio_init(mm_tlsio_t *io, void *io_arg)
|
|
{
|
|
memset(io, 0, sizeof(*io));
|
|
io->io = io_arg;
|
|
io->time_ms = UINT32_MAX;
|
|
}
|
|
|
|
void mm_tlsio_free(mm_tlsio_t *io)
|
|
{
|
|
if (io->ctx)
|
|
SSL_CTX_free(io->ctx);
|
|
/* free io->ssl and io->bio */
|
|
if (io->ssl)
|
|
SSL_free(io->ssl);
|
|
}
|
|
|
|
void mm_tlsio_error_reset(mm_tlsio_t *io)
|
|
{
|
|
mm_errno_set(0);
|
|
io->time_ms = UINT32_MAX;
|
|
io->error = 0;
|
|
io->error_msg[0] = 0;
|
|
}
|
|
|
|
static inline void
|
|
mm_tlsio_error(mm_tlsio_t *io, int ssl_rc, char *fmt, ...)
|
|
{
|
|
unsigned int error;
|
|
io->error = 1;
|
|
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
int len = 0;
|
|
len = vsnprintf(io->error_msg, sizeof(io->error_msg), fmt, args);
|
|
va_end(args);
|
|
|
|
(void)ssl_rc;
|
|
error = SSL_get_error(io->ssl, ssl_rc);
|
|
switch (error) {
|
|
case SSL_ERROR_SYSCALL:
|
|
case SSL_ERROR_SSL:
|
|
goto set_error_message;
|
|
case SSL_ERROR_NONE:
|
|
case SSL_ERROR_ZERO_RETURN:
|
|
case SSL_ERROR_WANT_CONNECT:
|
|
case SSL_ERROR_WANT_ACCEPT:
|
|
case SSL_ERROR_WANT_READ:
|
|
case SSL_ERROR_WANT_WRITE:
|
|
case SSL_ERROR_WANT_X509_LOOKUP:
|
|
default:
|
|
break;
|
|
}
|
|
return;
|
|
|
|
set_error_message:
|
|
|
|
for (;;) {
|
|
error = ERR_get_error();
|
|
if (error == 0)
|
|
break;
|
|
char error_buf[256];
|
|
ERR_error_string_n(error, error_buf, sizeof(error_buf));
|
|
len += snprintf(io->error_msg + len, sizeof(io->error_msg) - len,
|
|
": %s", error_buf);
|
|
}
|
|
|
|
}
|
|
|
|
static int
|
|
mm_tlsio_write_cb(BIO *bio, const char *buf, int size)
|
|
{
|
|
mm_tlsio_t *io;
|
|
io = BIO_get_app_data(bio);
|
|
int rc = mm_write(io->io, (char*)buf, size, io->time_ms);
|
|
if (rc == -1)
|
|
return -1;
|
|
return size;
|
|
}
|
|
|
|
static int
|
|
mm_tlsio_read_cb(BIO *bio, char *buf, int size)
|
|
{
|
|
mm_tlsio_t *io;
|
|
io = BIO_get_app_data(bio);
|
|
int rc = mm_read(io->io, buf, size, io->time_ms);
|
|
if (rc == -1)
|
|
return -1;
|
|
return size;
|
|
}
|
|
|
|
static long
|
|
mm_tlsio_ctrl_cb(BIO *bio, int cmd, long larg, void *parg)
|
|
{
|
|
(void)parg;
|
|
long ret = 1;
|
|
switch (cmd) {
|
|
case BIO_CTRL_GET_CLOSE:
|
|
ret = bio->shutdown;
|
|
break;
|
|
case BIO_CTRL_SET_CLOSE:
|
|
bio->shutdown = larg;
|
|
break;
|
|
case BIO_CTRL_DUP:
|
|
case BIO_CTRL_FLUSH:
|
|
break;
|
|
case BIO_CTRL_INFO:
|
|
case BIO_CTRL_GET:
|
|
case BIO_CTRL_SET:
|
|
case BIO_CTRL_PUSH:
|
|
case BIO_CTRL_POP:
|
|
default:
|
|
ret = 0;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BIO_METHOD mm_tlsio_method =
|
|
{
|
|
.type = BIO_TYPE_MEM,
|
|
.name = "machinarium",
|
|
.bwrite = mm_tlsio_write_cb,
|
|
.bread = mm_tlsio_read_cb,
|
|
.ctrl = mm_tlsio_ctrl_cb
|
|
};
|
|
|
|
static int
|
|
mm_tlsio_prepare(mm_tls_t *tls, mm_tlsio_t *io, int client)
|
|
{
|
|
SSL_CTX *ctx = NULL;
|
|
SSL *ssl = NULL;
|
|
SSL_METHOD *ssl_method = NULL;;
|
|
BIO *bio = NULL;
|
|
if (client)
|
|
ssl_method = (SSL_METHOD*)SSLv23_client_method();
|
|
else
|
|
ssl_method = (SSL_METHOD*)SSLv23_server_method();
|
|
ctx = SSL_CTX_new(ssl_method);
|
|
if (ctx == NULL) {
|
|
mm_tlsio_error(io, 0, "SSL_CTX_new()");
|
|
return -1;
|
|
}
|
|
|
|
SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
|
|
SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2);
|
|
SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3);
|
|
SSL_CTX_set_options(ctx, SSL_OP_NO_TICKET);
|
|
|
|
/* verify mode */
|
|
int verify = 0;
|
|
switch (tls->verify) {
|
|
case MM_TLS_NONE:
|
|
verify = SSL_VERIFY_NONE;
|
|
break;
|
|
case MM_TLS_PEER:
|
|
verify = SSL_VERIFY_PEER;
|
|
break;
|
|
case MM_TLS_PEER_STRICT:
|
|
verify = SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
|
|
break;
|
|
}
|
|
SSL_CTX_set_verify(ctx, verify, NULL);
|
|
SSL_CTX_set_verify_depth(ctx, 6);
|
|
|
|
/* cert file */
|
|
int rc;
|
|
if (tls->cert_file) {
|
|
rc = SSL_CTX_use_certificate_chain_file(ctx, tls->cert_file);
|
|
if (! rc) {
|
|
mm_tlsio_error(io, 0, "SSL_CTX_use_certificate_chain_file()");
|
|
goto error;
|
|
}
|
|
}
|
|
/* key file */
|
|
if (tls->key_file) {
|
|
rc = SSL_CTX_use_PrivateKey_file(ctx, tls->key_file, SSL_FILETYPE_PEM);
|
|
if (rc != 1) {
|
|
mm_tlsio_error(io, 0, "SSL_CTX_use_PrivateKey_file()");
|
|
goto error;
|
|
}
|
|
}
|
|
if (tls->cert_file && tls->key_file) {
|
|
rc = SSL_CTX_check_private_key(ctx);
|
|
if(rc != 1) {
|
|
mm_tlsio_error(io, 0, "SSL_CTX_check_private_key()");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/* ca file and ca_path */
|
|
if (tls->ca_file || tls->ca_path) {
|
|
rc = SSL_CTX_load_verify_locations(ctx, tls->ca_file, tls->ca_path);
|
|
if (rc != 1) {
|
|
mm_tlsio_error(io, 0, "SSL_CTX_load_verify_locations()");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/* ocsp */
|
|
|
|
/* set ciphers */
|
|
const char cipher_list[] = "ALL:!aNULL:!eNULL";
|
|
rc = SSL_CTX_set_cipher_list(ctx, cipher_list);
|
|
if (rc != 1) {
|
|
mm_tlsio_error(io, 0, "SSL_CTX_set_cipher_list()");
|
|
goto error;
|
|
}
|
|
if (! client)
|
|
SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
|
|
|
|
ssl = SSL_new(ctx);
|
|
if (ssl == NULL) {
|
|
mm_tlsio_error(io, 0, "SSL_new()");
|
|
goto error;
|
|
}
|
|
|
|
/* set server name */
|
|
if (tls->server) {
|
|
rc = SSL_set_tlsext_host_name(ssl, tls->server);
|
|
if (rc != 1) {
|
|
mm_tlsio_error(io, 0, "SSL_set_tlsext_host_name()");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
bio = BIO_new(&mm_tlsio_method);
|
|
if (bio == NULL) {
|
|
mm_tlsio_error(io, 0, "BIO_new()");
|
|
goto error;
|
|
}
|
|
BIO_set_app_data(bio, io);
|
|
bio->init = 1;
|
|
SSL_set_bio(ssl, bio, bio);
|
|
|
|
io->ctx = ctx;
|
|
io->ssl = ssl;
|
|
io->bio = bio;
|
|
return 0;
|
|
error:
|
|
SSL_CTX_free(ctx);
|
|
if (ssl)
|
|
SSL_free(ssl);
|
|
if (bio)
|
|
BIO_free(bio);
|
|
return -1;
|
|
}
|
|
|
|
static inline int
|
|
mm_tlsio_verify_name(char *cert_name, const char *name)
|
|
{
|
|
char *cert_domain, *domain, *next_dot;
|
|
if (strcasecmp(cert_name, name) == 0)
|
|
return 0;
|
|
|
|
/* wildcard match */
|
|
if (cert_name[0] != '*')
|
|
return -1;
|
|
|
|
/*
|
|
* valid wildcards:
|
|
* - "*.domain.tld"
|
|
* - "*.sub.domain.tld"
|
|
* - etc.
|
|
* reject "*.tld".
|
|
* no attempt to prevent the use of eg. "*.co.uk".
|
|
*/
|
|
cert_domain = &cert_name[1];
|
|
/* disallow "*" */
|
|
if (cert_domain[0] == '\0')
|
|
return -1;
|
|
/* disallow "*foo" */
|
|
if (cert_domain[0] != '.')
|
|
return -1;
|
|
/* disallow "*.." */
|
|
if (cert_domain[1] == '.')
|
|
return -1;
|
|
|
|
next_dot = strchr(&cert_domain[1], '.');
|
|
/* disallow "*.bar" */
|
|
if (next_dot == NULL)
|
|
return -1;
|
|
/* disallow "*.bar.." */
|
|
if (next_dot[1] == '.')
|
|
return -1;
|
|
|
|
domain = strchr(name, '.');
|
|
/* no wildcard match against a name with no host part. */
|
|
if (name[0] == '.')
|
|
return -1;
|
|
/* no wildcard match against a name with no domain part. */
|
|
if (domain == NULL || strlen(domain) == 1)
|
|
return -1;
|
|
|
|
if (strcasecmp(cert_domain, domain) == 0)
|
|
return 0;
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
mm_tlsio_verify_server_name(mm_tlsio_t *io, mm_tls_t *tls)
|
|
{
|
|
X509 *cert = NULL;
|
|
X509_NAME *subject_name = NULL;
|
|
char *common_name = NULL;
|
|
int common_name_len = 0;
|
|
|
|
cert = SSL_get_peer_certificate(io->ssl);
|
|
if (cert == NULL) {
|
|
mm_tlsio_error(io, 0, "SSL_get_peer_certificate()");
|
|
return -1;
|
|
}
|
|
subject_name = X509_get_subject_name(cert);
|
|
if (subject_name == NULL) {
|
|
mm_tlsio_error(io, 0, "X509_get_subject_name()");
|
|
goto error;
|
|
}
|
|
common_name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName, NULL, 0);
|
|
if (common_name_len < 0) {
|
|
mm_tlsio_error(io, 0, "X509_NAME_get_text_by_NID()");
|
|
goto error;
|
|
}
|
|
common_name = calloc(common_name_len + 1, 1);
|
|
if (common_name == NULL) {
|
|
mm_tlsio_error(io, 0, "memory allocation failed");
|
|
goto error;
|
|
}
|
|
X509_NAME_get_text_by_NID(subject_name, NID_commonName,
|
|
common_name,
|
|
common_name_len + 1);
|
|
/* validate name */
|
|
if (common_name_len != (int)strlen(common_name)) {
|
|
mm_tlsio_error(io, 0, "NUL byte in Common Name field, probably a malicious "
|
|
"server certificate");
|
|
goto error;
|
|
}
|
|
if (mm_tlsio_verify_name(common_name, tls->server) == -1) {
|
|
mm_tlsio_error(io, 0, "bad server name: %s (expected %s)",
|
|
common_name, tls->server);
|
|
goto error;
|
|
}
|
|
X509_free(cert);
|
|
return 0;
|
|
|
|
error:
|
|
X509_free(cert);
|
|
if (common_name)
|
|
free(common_name);
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
mm_tlsio_verify(mm_tlsio_t *io, mm_tls_t *tls)
|
|
{
|
|
int rc;
|
|
if (tls->server) {
|
|
rc = mm_tlsio_verify_server_name(io, tls);
|
|
if (rc == -1)
|
|
return -1;
|
|
}
|
|
rc = SSL_get_verify_result(io->ssl);
|
|
if (rc != X509_V_OK) {
|
|
mm_tlsio_error(io, 0, "SSL_get_verify_result()");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int mm_tlsio_connect(mm_tlsio_t *io, mm_tls_t *tls)
|
|
{
|
|
mm_tlsio_error_reset(io);
|
|
int rc;
|
|
rc = mm_tlsio_prepare(tls, io, 1);
|
|
if (rc == -1)
|
|
return -1;
|
|
rc = SSL_connect(io->ssl);
|
|
if (rc <= 0) {
|
|
mm_tlsio_error(io, rc, "SSL_connect()");
|
|
return -1;
|
|
}
|
|
rc = mm_tlsio_verify(io, tls);
|
|
if (rc == -1)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
int mm_tlsio_accept(mm_tlsio_t *io, mm_tls_t *tls)
|
|
{
|
|
mm_tlsio_error_reset(io);
|
|
int rc;
|
|
rc = mm_tlsio_prepare(tls, io, 0);
|
|
if (rc == -1)
|
|
return -1;
|
|
rc = SSL_accept(io->ssl);
|
|
if (rc <= 0) {
|
|
mm_tlsio_error(io, rc, "SSL_accept()");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int mm_tlsio_close(mm_tlsio_t *io)
|
|
{
|
|
mm_tlsio_error_reset(io);
|
|
(void)io;
|
|
return 0;
|
|
}
|
|
|
|
int mm_tlsio_write(mm_tlsio_t *io, char *buf, int size, uint32_t time_ms)
|
|
{
|
|
mm_tlsio_error_reset(io);
|
|
io->time_ms = time_ms;
|
|
int rc;
|
|
rc = SSL_write(io->ssl, buf, size);
|
|
if (rc <= 0) {
|
|
mm_tlsio_error(io, rc, "SSL_write()");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int mm_tlsio_read(mm_tlsio_t *io, char *buf, int size, uint32_t time_ms)
|
|
{
|
|
mm_tlsio_error_reset(io);
|
|
io->time_ms = time_ms;
|
|
int rc;
|
|
rc = SSL_read(io->ssl, buf, size);
|
|
if (rc <= 0) {
|
|
mm_tlsio_error(io, rc, "SSL_read()");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|