team-fte
/
fteqw
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fteqw/plugins/net_ssl_openssl.c

1200 lines
31 KiB
C
Raw Permalink Blame History

#include "plugin.h"
#include "netinc.h"
static plugfsfuncs_t *fsfuncs;
static plugnetfuncs_t *netfuncs;
static cvar_t *pdtls_psk_hint, *pdtls_psk_user, *pdtls_psk_key;
#undef SHA1
#undef HMAC
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"
#include "openssl/conf.h"
#define assert(c) do{if (!(c)) Con_Printf("assert failed: "STRINGIFY(c)"\n");}while(0)
static qboolean OSSL_Init(void);
static int ossl_fte_certctx;
struct fte_certctx_s
{
const char *peername;
qboolean dtls;
hashfunc_t *hash; //if set peer's cert MUST match the specified digest (with this hash function)
qbyte digest[DIGEST_MAXSIZE];
};
static struct
{
X509 *servercert;
EVP_PKEY *privatekey;
} vhost;
static BIO_METHOD *biometh_vfs;
static int OSSL_Bio_FWrite(BIO *h, const char *buf, int size)
{
vfsfile_t *f = BIO_get_data(h);
int r = VFS_WRITE(f, buf, size);
BIO_clear_retry_flags(h);
if (r == 0)
{
BIO_set_retry_write(h);
r = -1; //paranoia
}
return r;
}
static int OSSL_Bio_FRead(BIO *h, char *buf, int size)
{
vfsfile_t *f = BIO_get_data(h);
int r = VFS_READ(f, buf, size);
BIO_clear_retry_flags(h);
if (r == 0) //no data yet.
{
BIO_set_retry_read(h);
r = -1; //shouldn't be needed, but I'm paranoid
}
return r;
}
static int OSSL_Bio_FPuts(BIO *h, const char *buf)
{
return OSSL_Bio_FWrite(h, buf, strlen(buf));
}
static long OSSL_Bio_FCtrl(BIO *h, int cmd, long arg1, void *arg2)
{
vfsfile_t *f = BIO_get_data(h);
switch(cmd)
{
case BIO_CTRL_FLUSH:
VFS_FLUSH(f);
return 1;
default:
Con_Printf("OSSL_Bio_FCtrl: unknown cmd %i\n", cmd);
case BIO_CTRL_PUSH:
case BIO_CTRL_POP:
return 0;
}
return 0; //failure
}
static long OSSL_Bio_FOtherCtrl(BIO *h, int cmd, BIO_info_cb *cb)
{
switch(cmd)
{
default:
Con_Printf("OSSL_Bio_FOtherCtrl unknown cmd %i\n", cmd);
return 0;
}
return 0; //failure
}
static int OSSL_Bio_FCreate(BIO *h)
{ //we'll have to fill this in after we create the bio.
BIO_set_data(h, NULL);
return 1;
}
static int OSSL_Bio_FDestroy(BIO *h)
{
vfsfile_t *f = BIO_get_data(h);
VFS_CLOSE(f);
BIO_set_data(h, NULL);
return 1;
}
static int OSSL_PrintError_CB (const char *str, size_t len, void *u)
{
Con_Printf("%s\n", str);
return 1;
}
typedef struct
{
vfsfile_t funcs;
struct fte_certctx_s cert;
SSL_CTX *ctx;
BIO *bio;
SSL *ssl;
} osslvfs_t;
static int QDECL OSSL_FRead (struct vfsfile_s *file, void *buffer, int bytestoread)
{
osslvfs_t *o = (osslvfs_t*)file;
int r = BIO_read(o->bio, buffer, bytestoread);
if (r <= 0)
{
if (BIO_should_io_special(o->bio))
{
switch(BIO_get_retry_reason(o->bio))
{
//these are temporary errors, try again later.
case BIO_RR_SSL_X509_LOOKUP:
return -1; //certificate failure.
case BIO_RR_ACCEPT:
case BIO_RR_CONNECT:
return -1; //should never happen
}
}
if (BIO_should_retry(o->bio))
return 0;
return -1; //eof or something
}
return r;
}
static int QDECL OSSL_FWrite (struct vfsfile_s *file, const void *buffer, int bytestowrite)
{
osslvfs_t *o = (osslvfs_t*)file;
int r = BIO_write(o->bio, buffer, bytestowrite);
if (r <= 0)
{
if (BIO_should_io_special(o->bio))
{
switch(BIO_get_retry_reason(o->bio))
{
//these are temporary errors, try again later.
case BIO_RR_SSL_X509_LOOKUP:
return -1; //certificate failure.
case BIO_RR_ACCEPT:
case BIO_RR_CONNECT:
return -1; //should never happen
}
}
if (BIO_should_retry(o->bio))
return 0;
return -1; //eof or something
}
return r;
}
//static qboolean QDECL OSSL_Seek (struct vfsfile_s *file, qofs_t pos); //returns false for error
//static qofs_t QDECL OSSL_Tell (struct vfsfile_s *file);
//static qofs_t QDECL OSSL_GetLen (struct vfsfile_s *file); //could give some lag
static qboolean QDECL OSSL_Close (struct vfsfile_s *file)
{
osslvfs_t *o = (osslvfs_t*)file;
BIO_free(o->bio);
SSL_CTX_free(o->ctx);
free(o);
return true; //success, I guess
}
//static void QDECL OSSL_Flush (struct vfsfile_s *file);
static qboolean print_cn_name(X509_NAME* const name, const char *utf8match, const char *prefix)
{
int idx = -1;
qboolean success = 0;
unsigned char *utf8 = NULL;
X509_NAME_ENTRY* entry;
ASN1_STRING* data;
int length;
do
{
if(!name) break; /* failed */
idx = X509_NAME_get_index_by_NID(name, NID_commonName, -1);
if(!(idx > -1)) break; /* failed */
entry = X509_NAME_get_entry(name, idx);
if(!entry) break; /* failed */
data = X509_NAME_ENTRY_get_data(entry);
if(!data) break; /* failed */
length = ASN1_STRING_to_UTF8(&utf8, data);
if(!utf8 || !(length > 0)) break; /* failed */
if (utf8match)
success = !strcmp(utf8, utf8match);
else
{
Con_Printf("%s%s", prefix, utf8);
success = 1;
}
} while (0);
if(utf8)
OPENSSL_free(utf8);
return success;
}
static int OSSL_Verify_Peer(int preverify_ok, X509_STORE_CTX *x509_ctx)
{
SSL *ssl = X509_STORE_CTX_get_ex_data(x509_ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
struct fte_certctx_s *uctx = SSL_get_ex_data(ssl, ossl_fte_certctx);
if (uctx->hash)
{ //our special 'must-match-digest' mode without any other kind of trust.
X509* cert = X509_STORE_CTX_get_current_cert(x509_ctx);
size_t blobsize;
qbyte *blob;
qbyte *end;
qbyte digest[DIGEST_MAXSIZE];
void *hctx = alloca(uctx->hash->contextsize);
blobsize = i2d_X509(cert, NULL);
blob = alloca(blobsize);
end = blob;
i2d_X509(cert, &end);
uctx->hash->init(hctx);
uctx->hash->process(hctx, blob, blobsize);
uctx->hash->terminate(digest, hctx);
//return 1 for success
return !memcmp(digest, uctx->digest, uctx->hash->digestsize);
}
if(preverify_ok == 0)
{
int depth = X509_STORE_CTX_get_error_depth(x509_ctx);
int err = X509_STORE_CTX_get_error(x509_ctx);
X509* cert = X509_STORE_CTX_get_current_cert(x509_ctx);
X509_NAME* iname = cert ? X509_get_issuer_name(cert) : NULL;
//X509_NAME* sname = cert ? X509_get_subject_name(cert) : NULL;
if (err == X509_V_ERR_CERT_HAS_EXPIRED || err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT)
{
size_t knownsize;
qbyte *knowndata = netfuncs->TLS_GetKnownCertificate(uctx->peername, &knownsize);
if (knowndata)
{ //check
size_t blobsize;
qbyte *blob;
qbyte *end;
blobsize = i2d_X509(cert, NULL);
if (blobsize == knownsize)
{ //sizes must match.
blob = alloca(blobsize);
end = blob;
i2d_X509(cert, &end);
if (!memcmp(blob, knowndata, blobsize))
preverify_ok = 1; //exact match to a known cert. yay. allow it.
}
plugfuncs->Free(knowndata);
return preverify_ok;
}
#ifdef HAVE_CLIENT
if (uctx->dtls)
{
unsigned int probs = 0;
size_t blobsize;
qbyte *blob;
qbyte *end;
blobsize = i2d_X509(cert, NULL);
blob = alloca(blobsize);
end = blob;
i2d_X509(cert, &end);
switch(err)
{
case 0:
probs |= CERTLOG_WRONGHOST;
break;
case X509_V_ERR_CERT_HAS_EXPIRED:
probs |= CERTLOG_EXPIRED;
break;
case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
probs |= CERTLOG_MISSINGCA;
break;
default:
probs |= CERTLOG_UNKNOWN;
break;
}
if (netfuncs->CertLog_ConnectOkay && netfuncs->CertLog_ConnectOkay(uctx->peername, blob, blobsize, probs))
return 1; //ignore the errors...
return 0; //allow it.
}
#endif
}
Con_Printf(CON_ERROR"%s ", uctx->peername);
//FIXME: this is probably on a worker thread. expect munged prints.
//print_cn_name(sname, NULL, CON_ERROR);
Con_Printf(" (issued by ");
print_cn_name(iname, NULL, S_COLOR_YELLOW);
Con_Printf(")");
if(depth == 0) {
/* If depth is 0, its the server's certificate. Print the SANs too */
// print_san_name("Subject (san)", cert);
}
if(err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
Con_Printf(": Error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY\n");
else if (err == X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE)
Con_Printf(": Error = X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE\n");
else if(err == X509_V_ERR_CERT_UNTRUSTED)
Con_Printf(": Error = X509_V_ERR_CERT_UNTRUSTED\n");
else if(err == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN)
Con_Printf(": Error = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN\n");
else if(err == X509_V_ERR_CERT_NOT_YET_VALID)
Con_Printf(": Error = X509_V_ERR_CERT_NOT_YET_VALID\n");
else if(err == X509_V_ERR_CERT_HAS_EXPIRED)
Con_Printf(": Error = X509_V_ERR_CERT_HAS_EXPIRED\n");
else if(err == X509_V_OK)
Con_Printf(": Error = X509_V_OK\n");
else if(err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT)
Con_Printf(": Error = X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT\n");
else
Con_Printf(": Error = %d\n", err);
}
if (!preverify_ok && cvarfuncs->GetFloat("tls_ignorecertificateerrors"))
{
Con_Printf(CON_ERROR "%s: Ignoring certificate errors (tls_ignorecertificateerrors is set)\n", uctx->peername);
return 1;
}
return preverify_ok;
}
static vfsfile_t *OSSL_OpenPrivKeyFile(char *nativename, size_t nativesize)
{
#define privname "privkey.pem"
vfsfile_t *privf;
const char *mode = nativename?"wb":"rb";
/*int i = COM_CheckParm("-privkey");
if (i++)
{
if (nativename)
Q_strncpyz(nativename, com_argv[i], nativesize);
privf = FS_OpenVFS(com_argv[i], mode, FS_SYSTEM);
}
else*/
{
if (nativename)
if (!fsfuncs->NativePath(privname, FS_ROOT, nativename, nativesize))
return NULL;
privf = fsfuncs->OpenVFS(privname, mode, FS_ROOT);
}
return privf;
#undef privname
}
static vfsfile_t *OSSL_OpenPubKeyFile(char *nativename, size_t nativesize)
{
#define fullchainname "fullchain.pem"
#define pubname "cert.pem"
vfsfile_t *pubf = NULL;
const char *mode = nativename?"wb":"rb";
/*int i = COM_CheckParm("-pubkey");
if (i++)
{
if (nativename)
Q_strncpyz(nativename, com_argv[i], nativesize);
pubf = FS_OpenVFS(com_argv[i], mode, FS_SYSTEM);
}
else*/
{
if (!pubf && (!nativename || fsfuncs->NativePath(fullchainname, FS_ROOT, nativename, nativesize)))
pubf = fsfuncs->OpenVFS(fullchainname, mode, FS_ROOT);
if (!pubf && (!nativename || fsfuncs->NativePath(pubname, FS_ROOT, nativename, nativesize)))
pubf = fsfuncs->OpenVFS(pubname, mode, FS_ROOT);
}
return pubf;
#undef pubname
}
static BIO *OSSL_BioFromFile(vfsfile_t *f)
{
qbyte buf[4096];
int r;
BIO *b = BIO_new(BIO_s_mem());
if (f)
{
for(;;)
{
r = VFS_READ(f, buf, sizeof(buf));
if (r <= 0)
break;
BIO_write(b, buf, r);
}
VFS_CLOSE(f);
}
return b;
}
static void OSSL_OpenPrivKey(void)
{
BIO *bio = OSSL_BioFromFile(OSSL_OpenPrivKeyFile(NULL,0));
vhost.privatekey = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL);
BIO_free(bio);
}
static void OSSL_OpenPubKey(void)
{
BIO *bio = OSSL_BioFromFile(OSSL_OpenPubKeyFile(NULL,0));
vhost.servercert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
BIO_free(bio);
}
static char *OSSL_SetCertificateName(char *out, const char *hostname)
{ //glorified strcpy...
int i;
if (hostname)
{
const char *host = strstr(hostname, "://");
if (host)
hostname = host+3;
//any dtls:// prefix will have been stripped now.
if (*hostname == '[')
{ //eg: [::1]:foo - skip the lead [ and strip the ] and any trailing data (hopefully just a :port or nothing)
hostname++;
host = strchr(hostname, ']');
if (host)
{
memcpy(out, hostname, host-hostname);
out[host-hostname] = 0;
hostname = out;
}
}
else
{ //eg: 127.0.0.1:port - strip the port number if specified.
host = strchr(hostname, ':');
if (host)
{
memcpy(out, hostname, host-hostname);
out[host-hostname] = 0;
hostname = out;
}
}
for (i = 0; hostname[i]; i++)
{
if (hostname[i] >= 'a' && hostname[i] <= 'z')
;
else if (hostname[i] >= 'A' && hostname[i] <= 'Z')
;
else if (hostname[i] >= '0' && hostname[i] <= '9')
;
else if (hostname[i] == '-' || hostname[i] == '.')
;
else
{
hostname = NULL; //something invalid. bum.
break;
}
}
//we should have a cleaned up host name now, ready for (ab)use in certificates.
}
if (!hostname)
*out = 0;
else if (hostname == out)
;
else
memcpy(out, hostname, strlen(hostname)+1);
return out;
}
static vfsfile_t *OSSL_OpenVFS(const char *hostname, vfsfile_t *source, qboolean isserver)
{
BIO *sink;
osslvfs_t *n;
if (!OSSL_Init())
return NULL; //FAIL!
if (!hostname)
hostname = "";
n = calloc(sizeof(*n) + strlen(hostname)+1, 1);
n->funcs.ReadBytes = OSSL_FRead;
n->funcs.WriteBytes = OSSL_FWrite;
n->funcs.Seek = NULL;
n->funcs.Tell = NULL;
n->funcs.GetLen = NULL;
n->funcs.Close = OSSL_Close;
n->funcs.Flush = NULL;
n->funcs.seekstyle = SS_UNSEEKABLE;
n->cert.peername = OSSL_SetCertificateName((char*)(n+1), hostname);
n->cert.dtls = false;
ERR_print_errors_cb(OSSL_PrintError_CB, NULL);
sink = BIO_new(biometh_vfs);
if (sink)
{
n->ctx = SSL_CTX_new(isserver?TLS_server_method():TLS_client_method());
if (n->ctx)
{
assert(1==SSL_CTX_set_cipher_list(n->ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"));
SSL_CTX_set_session_cache_mode(n->ctx, SSL_SESS_CACHE_OFF);
SSL_CTX_set_default_verify_paths(n->ctx);
SSL_CTX_set_verify(n->ctx, SSL_VERIFY_PEER, OSSL_Verify_Peer);
SSL_CTX_set_verify_depth(n->ctx, 5);
SSL_CTX_set_options(n->ctx, SSL_OP_NO_COMPRESSION); //compression allows guessing the contents of the stream somehow.
if (isserver)
{
if (vhost.servercert && vhost.privatekey)
{
SSL_CTX_use_certificate(n->ctx, vhost.servercert);
SSL_CTX_use_PrivateKey(n->ctx, vhost.privatekey);
assert(1==SSL_CTX_check_private_key(n->ctx));
}
}
n->bio = BIO_new_ssl(n->ctx, !isserver);
//set up the source/sink
BIO_set_data(sink, source); //source now belongs to the bio
BIO_set_init(sink, true); //our sink is now ready...
n->bio = BIO_push(n->bio, sink);
BIO_free(sink);
sink = NULL;
BIO_get_ssl(n->bio, &n->ssl);
SSL_set_ex_data(n->ssl, ossl_fte_certctx, &n->cert);
SSL_set_mode(n->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE|SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
SSL_set_tlsext_host_name(n->ssl, n->cert.peername); //let the server know which cert to send
BIO_do_connect(n->bio);
return &n->funcs;
}
BIO_free(sink);
}
return NULL;
}
/*static int OSSL_GetChannelBinding(vfsfile_t *vf, qbyte *binddata, size_t *bindsize)
{
//FIXME: not yet supported. tbh I've no idea how to get that data. probably something convoluted.
return -1;
}*/
static BIO_METHOD *biometh_dtls;
typedef struct {
struct fte_certctx_s cert;
void *cbctx;
neterr_t(*push)(void *cbctx, const qbyte *data, size_t datasize);
SSL_CTX *ctx;
BIO *bio;
SSL *ssl;
// BIO *sink;
qbyte *pending;
size_t pendingsize;
void *peeraddr;
size_t peeraddrsize;
} ossldtls_t;
static int OSSL_Bio_DWrite(BIO *h, const char *buf, int size)
{
ossldtls_t *f = BIO_get_data(h);
neterr_t r = f->push(f->cbctx, buf, size);
BIO_clear_retry_flags(h);
switch(r)
{
case NETERR_SENT:
return size;
case NETERR_NOROUTE:
case NETERR_DISCONNECTED:
return -1;
case NETERR_MTU:
return -1;
case NETERR_CLOGGED:
BIO_set_retry_write(h);
return -1;
}
return r;
}
static int OSSL_Bio_DRead(BIO *h, char *buf, int size)
{
ossldtls_t *f = BIO_get_data(h);
BIO_clear_retry_flags(h);
if (f->pending)
{
size = min(size, f->pendingsize);
memcpy(buf, f->pending, f->pendingsize);
//we've read it now, don't read it again.
f->pending = 0;
f->pendingsize = 0;
return size;
}
//nothing available.
BIO_set_retry_read(h);
return -1;
}
static long OSSL_Bio_DCtrl(BIO *h, int cmd, long arg1, void *arg2)
{
// ossldtls_t *f = BIO_get_data(h);
switch(cmd)
{
case BIO_CTRL_FLUSH:
return 1;
case BIO_CTRL_DGRAM_GET_PEER:
return 0;
case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT: //we're non-blocking, so this doesn't affect us.
case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD:
case BIO_CTRL_WPENDING:
case BIO_CTRL_DGRAM_QUERY_MTU:
case BIO_CTRL_DGRAM_SET_MTU:
case BIO_CTRL_DGRAM_GET_FALLBACK_MTU:
return 0;
default:
Con_Printf("OSSL_Bio_DCtrl: unknown cmd %i\n", cmd);
case BIO_CTRL_PUSH:
case BIO_CTRL_POP:
return 0;
}
return 0; //failure
}
static long OSSL_Bio_DOtherCtrl(BIO *h, int cmd, BIO_info_cb *cb)
{
switch(cmd)
{
default:
Con_Printf("OSSL_Bio_DOtherCtrl unknown cmd %i\n", cmd);
return 0;
}
return 0; //failure
}
static int OSSL_Bio_DCreate(BIO *h)
{ //we'll have to fill this in after we create the bio.
BIO_set_data(h, NULL);
return 1;
}
static int OSSL_Bio_DDestroy(BIO *h)
{
BIO_set_data(h, NULL);
return 1;
}
static int dehex(int i)
{
if (i >= '0' && i <= '9')
return (i-'0');
else if (i >= 'A' && i <= 'F')
return (i-'A'+10);
else
return (i-'a'+10);
}
static size_t Base16_DecodeBlock_(const char *in, qbyte *out, size_t outsize)
{
qbyte *start = out;
if (!out)
return ((strlen(in)+1)/2) + 1;
for (; ishexcode(in[0]) && ishexcode(in[1]) && outsize > 0; outsize--, in+=2)
*out++ = (dehex(in[0])<<4) | dehex(in[1]);
return out-start;
}
static unsigned int OSSL_SV_Validate_PSK(SSL *ssl, const char *identity, unsigned char *psk, unsigned int max_psk_len)
{
if (!strcmp(identity, pdtls_psk_user->string))
{ //Yay! We know this one!
return Base16_DecodeBlock_(pdtls_psk_key->string, psk, max_psk_len);
}
return 0; //0 for error, or something.
}
unsigned int OSSL_CL_Validate_PSK(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len)
{ //if our hint cvar matches, then report our user+key cvars to the server
if ((!*hint && *pdtls_psk_user->string && !*pdtls_psk_hint->string) || (*hint && !strcmp(hint, pdtls_psk_hint->string)))
{
#ifndef NOLEGACY
if (*hint)
{
//Try to avoid crashing QE servers by recognising its hint and blocking it when the hashes of the user+key are wrong.
quint32_t digest[SHA_DIGEST_LENGTH/4];
SHA1(hint, strlen(hint), (qbyte*)digest);
if ((digest[0]^digest[1]^digest[2]^digest[3]^digest[4]) == 0xb6c27b61)
{
SHA1(pdtls_psk_key->string, strlen(pdtls_psk_key->string), (qbyte*)digest);
if (strcmp(hint, pdtls_psk_user->string) || (digest[0]^digest[1]^digest[2]^digest[3]^digest[4]) != 0x3dd348e4)
{
Con_Printf(CON_WARNING "Possible QEx Server, please set your ^[%s\\type\\%s^] and ^[%s\\type\\%s^] cvars correctly, their current values are likely to crash the server.\n", pdtls_psk_user->name,pdtls_psk_user->name, pdtls_psk_key->name,pdtls_psk_key->name);
return 0; //don't report anything.
}
}
}
#endif
Q_strlcpy(identity, pdtls_psk_user->string, max_identity_len);
return Base16_DecodeBlock_(pdtls_psk_key->string, psk, max_psk_len);
}
else if (*hint)
Con_Printf(CON_WARNING "Unable to supply PSK response to server (hint is \"%s\").\n"
"Please set ^[%s\\type\\%s^], ^[%s\\type\\%s^], and ^[%s\\type\\%s^] cvars to match the server.\n", hint, pdtls_psk_hint->name,pdtls_psk_hint->name, pdtls_psk_user->name,pdtls_psk_user->name, pdtls_psk_key->name,pdtls_psk_key->name);
return 0; //we don't know what to report.
}
static void *OSSL_CreateContext(const dtlscred_t *cred, void *cbctx, neterr_t(*push)(void *cbctx, const qbyte *data, size_t datasize), qboolean isserver)
{ //if remotehost is null then their certificate will not be validated.
ossldtls_t *n;
BIO *sink;
const char *remotehost = cred?cred->peer.name:NULL;
if (!remotehost)
remotehost = "";
n = calloc(sizeof(*n) + strlen(remotehost)+1, 1);
n->cbctx = cbctx;
n->push = push;
n->ctx = SSL_CTX_new(isserver?DTLS_server_method():DTLS_client_method());
n->cert.peername = OSSL_SetCertificateName((char*)(n+1), remotehost);
n->cert.dtls = true;
if (cred)
{
n->cert.hash = cred->peer.hash;
memcpy(n->cert.digest, cred->peer.digest, sizeof(cred->peer.digest));
}
else
{
n->cert.hash = NULL;
memset(n->cert.digest, 0, sizeof(n->cert.digest));
}
if (n->ctx)
{
assert(1==SSL_CTX_set_cipher_list(n->ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"));
SSL_CTX_set_session_cache_mode(n->ctx, SSL_SESS_CACHE_OFF);
SSL_CTX_set_verify(n->ctx, SSL_VERIFY_PEER|(n->cert.hash?SSL_VERIFY_FAIL_IF_NO_PEER_CERT:0), OSSL_Verify_Peer);
SSL_CTX_set_verify_depth(n->ctx, 10);
SSL_CTX_set_options(n->ctx, SSL_OP_NO_COMPRESSION| //compression allows guessing the contents of the stream somehow.
SSL_OP_NO_RENEGOTIATION);
if (cred && (cred->local.certsize||cred->local.keysize))
{
X509 *cert = NULL;
EVP_PKEY *key = NULL;
const unsigned char *ffs;
ffs = cred->local.cert;
d2i_X509(&cert, &ffs, cred->local.certsize);
SSL_CTX_use_certificate(n->ctx, cert);
ffs = cred->local.key;
d2i_PrivateKey(EVP_PKEY_RSA, &key, &ffs, cred->local.keysize);
SSL_CTX_use_PrivateKey(n->ctx, key);
}
else if (isserver)
{
if (*pdtls_psk_user->string)
{
if (*pdtls_psk_user->string)
SSL_CTX_use_psk_identity_hint(n->ctx, pdtls_psk_hint->string);
SSL_CTX_set_psk_server_callback(n->ctx, OSSL_SV_Validate_PSK);
}
if (vhost.servercert && vhost.privatekey)
{
SSL_CTX_use_certificate(n->ctx, vhost.servercert);
SSL_CTX_use_PrivateKey(n->ctx, vhost.privatekey);
assert(1==SSL_CTX_check_private_key(n->ctx));
}
}
else
{
// if (*pdtls_psk_user->string)
SSL_CTX_set_psk_client_callback(n->ctx, OSSL_CL_Validate_PSK);
}
//SSL_CTX_use_certificate_file
//FIXME: SSL_CTX_use_certificate_file aka SSL_CTX_use_certificate(PEM_read_bio_X509)
//FIXME: SSL_CTX_use_PrivateKey_file aka SSL_CTX_use_PrivateKey(PEM_read_bio_PrivateKey)
//assert(1==SSL_CTX_check_private_key(n->ctx));
{
n->bio = BIO_new_ssl(n->ctx, !isserver);
//set up the source/sink
sink = BIO_new(biometh_dtls);
if (sink)
{
BIO_set_data(sink, n);
BIO_set_init(sink, true); //our sink is now ready...
n->bio = BIO_push(n->bio, sink);
BIO_free(sink);
sink = NULL;
}
BIO_get_ssl(n->bio, &n->ssl);
SSL_set_app_data(n->ssl, n);
SSL_set_ex_data(n->ssl, ossl_fte_certctx, &n->cert);
if (*n->cert.peername)
SSL_set_tlsext_host_name(n->ssl, n->cert.peername); //let the server know which cert to send
BIO_do_connect(n->bio);
ERR_print_errors_cb(OSSL_PrintError_CB, NULL);
return n;
}
}
return NULL;
}
static qbyte dtlscookiekey[16];
static int OSSL_GenCookie(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len)
{
ossldtls_t *f = SSL_get_app_data(ssl);
qbyte *blurgh = alloca(sizeof(dtlscookiekey) + f->peeraddrsize);
memcpy(blurgh, dtlscookiekey, sizeof(dtlscookiekey));
memcpy(blurgh+sizeof(dtlscookiekey), f->peeraddr, f->peeraddrsize);
SHA1(blurgh, sizeof(dtlscookiekey) + f->peeraddrsize, cookie);
*cookie_len = SHA_DIGEST_LENGTH;
return 1;
}
static int OSSL_VerifyCookie(SSL *ssl, const unsigned char *cookie, unsigned int cookie_len)
{
unsigned char match[DTLS1_COOKIE_LENGTH];
unsigned int matchsize;
if (OSSL_GenCookie(ssl, match, &matchsize))
if (cookie_len == matchsize && !memcmp(cookie, match, matchsize))
return 1;
return 0; //not valid.
}
qboolean OSSL_CheckConnection(void *cbctx, void *peeraddr, size_t peeraddrsize, void *indata, size_t insize, neterr_t(*push)(void *cbctx, const qbyte *data, size_t datasize), void (*EstablishTrueContext)(void **cbctx, void *state))
{
int ret;
static ossldtls_t *pending;
BIO_ADDR *bioaddr = BIO_ADDR_new();
if (!pending)
{
pending = OSSL_CreateContext(NULL, cbctx, push, true);
SSL_CTX_set_cookie_generate_cb(pending->ctx, OSSL_GenCookie);
SSL_CTX_set_cookie_verify_cb(pending->ctx, OSSL_VerifyCookie);
}
SSL_set_app_data(pending->ssl, pending);
//make sure its kept current...
pending->cbctx = cbctx;
pending->push = push;
pending->pending = indata;
pending->pendingsize = insize;
ret = DTLSv1_listen(pending->ssl, bioaddr);
BIO_ADDR_free(bioaddr);
if (ret >= 1)
{
pending->pending = NULL;
pending->pendingsize = 0;
EstablishTrueContext(&pending->cbctx, pending);
pending = NULL; //returned to called. next request gets a new one.
return true;
}
//0 = nonfatal
//-1 = fatal
return false;
}
static void OSSL_DestroyContext(void *ctx)
{
ossldtls_t *o = (ossldtls_t*)ctx;
BIO_free(o->bio);
SSL_CTX_free(o->ctx);
free(o);
}
static neterr_t OSSL_Transmit(void *ctx, const qbyte *data, size_t datasize)
{ //we're sending data
ossldtls_t *o = (ossldtls_t*)ctx;
int r = BIO_write(o->bio, data, datasize);
if (r <= 0)
{
if (BIO_should_io_special(o->bio))
{
switch(BIO_get_retry_reason(o->bio))
{
//these are temporary errors, try again later.
case BIO_RR_SSL_X509_LOOKUP:
return NETERR_NOROUTE; //certificate failure.
case BIO_RR_ACCEPT:
case BIO_RR_CONNECT:
return NETERR_NOROUTE; //should never happen
}
}
if (BIO_should_retry(o->bio))
return NETERR_CLOGGED;
return NETERR_DISCONNECTED; //eof or something
}
return NETERR_SENT;
}
static neterr_t OSSL_Received(void *ctx, sizebuf_t *message)
{ //we have received some encrypted data...
ossldtls_t *o = (ossldtls_t*)ctx;
int r;
if (!message)
r = 0;
else
{
o->pending = message->data;
o->pendingsize = message->cursize;
r = BIO_read(o->bio, message->data, message->maxsize);
o->pending = NULL;
o->pendingsize = 0;
}
if (r > 0)
{
message->cursize = r;
return NETERR_SENT;
}
else
{
if (BIO_should_io_special(o->bio))
{
switch(BIO_get_retry_reason(o->bio))
{
//these are temporary errors, try again later.
case BIO_RR_SSL_X509_LOOKUP:
return NETERR_NOROUTE; //certificate failure.
case BIO_RR_ACCEPT:
case BIO_RR_CONNECT:
return NETERR_NOROUTE; //should never happen
}
}
if (BIO_should_retry(o->bio))
return 0;
return NETERR_DISCONNECTED; //eof or something
}
return NETERR_NOROUTE;
}
static neterr_t OSSL_Timeouts(void *ctx)
{ //keep it ticking over, or something.
return OSSL_Received(ctx, NULL);
}
qboolean OSSL_GenTempCertificate(const char *subject, struct dtlslocalcred_s *cred)
{
EVP_PKEY*pkey = EVP_PKEY_new();
RSA *rsa = RSA_new();
BIGNUM *pkexponent = BN_new();
qbyte *ffs;
//The pseudo-random number generator must be seeded prior to calling RSA_generate_key_ex().
BN_set_word(pkexponent, RSA_F4);
RSA_generate_key_ex(rsa, 2048, pkexponent, NULL);
BN_free(pkexponent);
EVP_PKEY_assign_RSA(pkey, rsa);
cred->keysize = i2d_PrivateKey(pkey, NULL);
cred->key = ffs = plugfuncs->Malloc(cred->keysize);
cred->keysize = i2d_PrivateKey(pkey, &ffs);
{
X509 *x509 = X509_new();
ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
X509_gmtime_adj(X509_get_notBefore(x509), 0);
X509_gmtime_adj(X509_get_notAfter(x509), 365*24*60*60); //lots of validity
X509_set_pubkey(x509, pkey);
{
X509_NAME *name = X509_get_subject_name(x509);
X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (subject?subject:"localhost"), -1, -1, 0);
X509_set_issuer_name(x509, name);
}
X509_sign(x509, pkey, EVP_sha1());
cred->certsize = i2d_X509(x509, NULL);
cred->cert = ffs = plugfuncs->Malloc(cred->certsize);
cred->certsize = i2d_X509(x509, &ffs);
X509_free(x509);
}
EVP_PKEY_free(pkey); //also frees the rsa pointer.
return true;
}
static dtlsfuncs_t ossl_dtlsfuncs =
{
OSSL_CreateContext,
OSSL_CheckConnection,
OSSL_DestroyContext,
OSSL_Transmit,
OSSL_Received,
OSSL_Timeouts,
NULL,
OSSL_GenTempCertificate,
};
static const dtlsfuncs_t *OSSL_InitClient(void)
{
if (OSSL_Init())
return &ossl_dtlsfuncs;
return NULL;
}
static const dtlsfuncs_t *OSSL_InitServer(void)
{
if (OSSL_Init())
return &ossl_dtlsfuncs;
return NULL;
}
static struct
{
qboolean inited;
qboolean init_success;
} ossl;
static qboolean OSSL_Init(void)
{
if (ossl.inited)
return ossl.init_success;
ossl.inited = true;
#if 0//def LOADERTHREAD
Sys_LockMutex(com_resourcemutex);
if (inited) //now check again, just in case
{
Sys_UnlockMutex(com_resourcemutex);
return init_success;
}
#endif
SSL_library_init();
SSL_load_error_strings();
// OPENSSL_config(NULL);
ERR_print_errors_cb(OSSL_PrintError_CB, NULL);
OSSL_OpenPubKey();
OSSL_OpenPrivKey();
biometh_vfs = BIO_meth_new(BIO_get_new_index()|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR, "fte_vfs");
if (biometh_vfs)
{
BIO_meth_set_write(biometh_vfs, OSSL_Bio_FWrite);
BIO_meth_set_read(biometh_vfs, OSSL_Bio_FRead);
BIO_meth_set_puts(biometh_vfs, OSSL_Bio_FPuts); //I cannot see how gets/puts can work with dtls...
// BIO_meth_set_gets(biometh_vfs, OSSL_Bio_FGets);
BIO_meth_set_ctrl(biometh_vfs, OSSL_Bio_FCtrl);
BIO_meth_set_create(biometh_vfs, OSSL_Bio_FCreate);
BIO_meth_set_destroy(biometh_vfs, OSSL_Bio_FDestroy);
BIO_meth_set_callback_ctrl(biometh_vfs, OSSL_Bio_FOtherCtrl);
ossl.init_success |= 1;
}
biometh_dtls = BIO_meth_new(BIO_get_new_index()|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR, "fte_dtls");
if (biometh_dtls)
{
BIO_meth_set_write(biometh_dtls, OSSL_Bio_DWrite);
BIO_meth_set_read(biometh_dtls, OSSL_Bio_DRead);
// BIO_meth_set_puts(biometh_dtls, OSSL_Bio_DPuts); //I cannot see how gets/puts can work with dtls...
// BIO_meth_set_gets(biometh_dtls, OSSL_Bio_DGets);
BIO_meth_set_ctrl(biometh_dtls, OSSL_Bio_DCtrl);
BIO_meth_set_create(biometh_dtls, OSSL_Bio_DCreate);
BIO_meth_set_destroy(biometh_dtls, OSSL_Bio_DDestroy);
BIO_meth_set_callback_ctrl(biometh_dtls, OSSL_Bio_DOtherCtrl);
ossl.init_success |= 2;
}
ossl_fte_certctx = SSL_get_ex_new_index(0, "ossl_fte_certctx", NULL, NULL, NULL);
#if 0//def LOADERTHREAD
Sys_UnlockMutex(com_resourcemutex);
#endif
return ossl.init_success;
}
static enum hashvalidation_e OSSL_VerifyHash(const qbyte *hashdata, size_t hashsize, const qbyte *pubkeydata, size_t pubkeysize, const qbyte *signdata, size_t signsize)
{
int result = VH_UNSUPPORTED;
BIO *bio_pubkey = BIO_new_mem_buf(pubkeydata, pubkeysize);
if (bio_pubkey)
{
X509 *x509_pubkey = PEM_read_bio_X509(bio_pubkey, NULL, NULL, NULL);
if (x509_pubkey)
{
EVP_PKEY *evp_pubkey = X509_get_pubkey(x509_pubkey);
if (evp_pubkey)
{
RSA *rsa_pubkey = EVP_PKEY_get1_RSA(evp_pubkey);
if (rsa_pubkey)
{
if (1 == RSA_verify(NID_sha512, hashdata, hashsize, signdata, signsize, rsa_pubkey))
result = VH_CORRECT;
else
result = VH_INCORRECT;
RSA_free(rsa_pubkey);
}
EVP_PKEY_free(evp_pubkey);
}
X509_free(x509_pubkey);
}
BIO_free(bio_pubkey);
}
return result;
}
static ftecrypto_t crypto_openssl =
{
"OpenSSL",
OSSL_OpenVFS,
NULL,//OSSL_GetChannelBinding,
OSSL_InitClient,
OSSL_InitServer,
OSSL_VerifyHash,
NULL,
};
static void OSSL_PluginShutdown(void)
{
ossl.inited = false;
ossl.init_success = false;
X509_free(vhost.servercert);
EVP_PKEY_free(vhost.privatekey);
BIO_meth_free(biometh_vfs);
BIO_meth_free(biometh_dtls);
}
static qboolean OSSL_PluginMayShutdown(void)
{
//the engine has a habit of holding on to handles without any refcounts, so don't allow it to die early.
return false;
}
qboolean Plug_Init(void)
{
fsfuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*fsfuncs));
netfuncs = plugfuncs->GetEngineInterface(plugnetfuncs_name, sizeof(*netfuncs));
if (!fsfuncs || !netfuncs)
return false;
plugfuncs->ExportFunction("Shutdown", OSSL_PluginShutdown);
plugfuncs->ExportFunction("MayUnload", OSSL_PluginMayShutdown);
pdtls_psk_hint = cvarfuncs->GetNVFDG("dtls_psk_hint", "", 0, NULL, "DTLS stuff");
pdtls_psk_user = cvarfuncs->GetNVFDG("dtls_psk_user", "", 0, NULL, "DTLS stuff");
pdtls_psk_key = cvarfuncs->GetNVFDG("dtls_psk_key", "", 0, NULL, "DTLS stuff");
netfuncs->RandomBytes(dtlscookiekey, sizeof(dtlscookiekey)); //something random so people can't guess cookies for arbitrary victim IPs.
OSSL_Init(); //shoving this here solves threading issues (eg two loader threads racing to open an https image url)
return plugfuncs->ExportInterface("Crypto", &crypto_openssl, sizeof(crypto_openssl)); //export a named interface struct to the engine
}
Reference in New Issue View Git Blame Copy Permalink