fteqw/plugins/net_ssl_openssl.c

#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 0;
		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
}