#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#ifndef OPENSSL_API_COMPAT

// 0x10101000L == 1.1.1, 30000 == 3.0.0

#define OPENSSL_API_COMPAT 0x10101000L

#define OPENSSL_NO_DEPRECATED 1

#include "Python.h"

#include "pycore_fileutils.h" // _PyIsSelectable_fd()

#include "pycore_long.h" // _PyLong_UnsignedLongLong_Converter()

#include "pycore_pyerrors.h" // _PyErr_ChainExceptions1()

#include "pycore_time.h" // _PyDeadline_Init()

#include "socketmodule.h"

#ifdef MS_WINDOWS

# include <wincrypt.h>

#include "_ssl.h"

#define _PySSL_FIX_ERRNO

#define PySSL_BEGIN_ALLOW_THREADS_S(save, mutex) \

do { (save) = PyEval_SaveThread(); PyMutex_Lock(mutex); } while(0)

#define PySSL_END_ALLOW_THREADS_S(save, mutex) \

do { PyMutex_Unlock(mutex); PyEval_RestoreThread(save); _PySSL_FIX_ERRNO; } while(0)

#define PySSL_BEGIN_ALLOW_THREADS(self) { \

PyThreadState *_save = NULL; \

PySSL_BEGIN_ALLOW_THREADS_S(_save, &self->tstate_mutex);

#define PySSL_END_ALLOW_THREADS(self) PySSL_END_ALLOW_THREADS_S(_save, &self->tstate_mutex); }

#if defined(HAVE_POLL_H)

#include <poll.h>

#elif defined(HAVE_SYS_POLL_H)

#include <sys/poll.h>

#include "openssl/rsa.h"

#include "openssl/crypto.h"

#include "openssl/x509.h"

#include "openssl/x509v3.h"

#include "openssl/pem.h"

#include "openssl/ssl.h"

#include "openssl/err.h"

#include "openssl/rand.h"

#include "openssl/bio.h"

#include "openssl/dh.h"

#ifndef OPENSSL_THREADS

# error "OPENSSL_THREADS is not defined, Python requires thread-safe OpenSSL"

#ifdef BIO_get_ktls_send

# ifdef MS_WINDOWS

typedef long long Py_off_t;

typedef off_t Py_off_t;

static int

Py_off_t_converter(PyObject *arg, void *addr)

{

#ifdef HAVE_LARGEFILE_SUPPORT

*((Py_off_t *)addr) = PyLong_AsLongLong(arg);

*((Py_off_t *)addr) = PyLong_AsLong(arg);

return PyErr_Occurred() ? 0 : 1;

}

#endif /* BIO_get_ktls_send */

struct py_ssl_error_code {

const char *mnemonic;

int library, reason;

};

struct py_ssl_library_code {

const char *library;

int code;

};

#if defined(MS_WINDOWS) && defined(Py_DEBUG)

static void _PySSLFixErrno(void) {

HMODULE ucrtbase = GetModuleHandleW(L"ucrtbase.dll");

if (!ucrtbase) {

/* If ucrtbase.dll is not loaded but the SSL DLLs are, we likely

return;

}

typedef int *(__stdcall *errno_func)(void);

errno_func ssl_errno = (errno_func)GetProcAddress(ucrtbase, "_errno");

if (ssl_errno) {

errno = *ssl_errno();

*ssl_errno() = 0;

} else {

errno = ENOTRECOVERABLE;

}

}

#undef _PySSL_FIX_ERRNO

#define _PySSL_FIX_ERRNO _PySSLFixErrno()

#if (OPENSSL_VERSION_NUMBER >= 0x30401000L)

#include "_ssl_data_35.h"

#elif (OPENSSL_VERSION_NUMBER >= 0x30100000L)

#include "_ssl_data_340.h"

#elif (OPENSSL_VERSION_NUMBER >= 0x30000000L)

#include "_ssl_data_300.h"

#elif (OPENSSL_VERSION_NUMBER >= 0x10101000L)

#include "_ssl_data_111.h"

#error Unsupported OpenSSL version

#ifndef OPENSSL_NO_SSL3_METHOD

extern const SSL_METHOD *SSLv3_method(void);

#ifndef OPENSSL_NO_TLS1_METHOD

extern const SSL_METHOD *TLSv1_method(void);

#ifndef OPENSSL_NO_TLS1_1_METHOD

extern const SSL_METHOD *TLSv1_1_method(void);

#ifndef OPENSSL_NO_TLS1_2_METHOD

extern const SSL_METHOD *TLSv1_2_method(void);

#ifndef INVALID_SOCKET /* MS defines this */

#define INVALID_SOCKET (-1)

#ifndef PY_SSL_DEFAULT_CIPHERS

#define PY_SSL_DEFAULT_CIPHERS 1

#if PY_SSL_DEFAULT_CIPHERS == 0

#ifndef PY_SSL_DEFAULT_CIPHER_STRING

#error "Py_SSL_DEFAULT_CIPHERS 0 needs Py_SSL_DEFAULT_CIPHER_STRING"

#endif

#ifndef PY_SSL_MIN_PROTOCOL

#define PY_SSL_MIN_PROTOCOL TLS1_2_VERSION

#endif

#elif PY_SSL_DEFAULT_CIPHERS == 1

#define PY_SSL_DEFAULT_CIPHER_STRING "@SECLEVEL=2:ECDH+AESGCM:ECDH+CHACHA20:ECDH+AES:DHE+AES:!aNULL:!eNULL:!aDSS:!SHA1:!AESCCM"

#ifndef PY_SSL_MIN_PROTOCOL

#define PY_SSL_MIN_PROTOCOL TLS1_2_VERSION

#endif

#elif PY_SSL_DEFAULT_CIPHERS == 2

#define PY_SSL_DEFAULT_CIPHER_STRING SSL_DEFAULT_CIPHER_LIST

#error "Unsupported PY_SSL_DEFAULT_CIPHERS"

#if defined(SSL_VERIFY_POST_HANDSHAKE) && defined(TLS1_3_VERSION) && !defined(OPENSSL_NO_TLS1_3)

#define PySSL_HAVE_POST_HS_AUTH

enum py_ssl_error {

};

enum py_ssl_server_or_client {

PY_SSL_CLIENT,

PY_SSL_SERVER

};

enum py_ssl_cert_requirements {

};

enum py_ssl_version {

};

enum py_proto_version {

};

#define X509_NAME_MAXLEN 256

#define PySSL_CB_MAXLEN 128

typedef struct {

PyObject_HEAD

SSL_CTX *ctx;

unsigned char *alpn_protocols;

unsigned int alpn_protocols_len;

PyObject *set_sni_cb;

int check_hostname;

int protocol;

#if defined(PySSL_HAVE_POST_HS_AUTH)

int post_handshake_auth;

PyObject *msg_cb;

PyObject *keylog_filename;

BIO *keylog_bio;

/* Cached module state, also used in SSLSocket and SSLSession code. */

_sslmodulestate *state;

#ifndef OPENSSL_NO_PSK

PyObject *psk_client_callback;

PyObject *psk_server_callback;

/* Lock to synchronize calls when the thread state is detached.

PyMutex tstate_mutex;

} PySSLContext;

#define PySSLContext_CAST(op) ((PySSLContext *)(op))

typedef struct {

int ssl; /* last seen error from SSL */

int c; /* last seen error from libc */

#ifdef MS_WINDOWS

int ws; /* last seen error from winsock */

} _PySSLError;

typedef struct {

PyObject_HEAD

PyObject *Socket; /* weakref to socket on which we're layered */

SSL *ssl;

PySSLContext *ctx; /* weakref to SSL context */

char shutdown_seen_zero;

enum py_ssl_server_or_client socket_type;

PyObject *owner; /* Python level "owner" passed to servername callback */

PyObject *server_hostname;

_PySSLError err; /* last seen error from various sources */

/* Some SSL callbacks don't have error reporting. Callback wrappers

PyObject *exc;

} PySSLSocket;

#define PySSLSocket_CAST(op) ((PySSLSocket *)(op))

typedef struct {

PyObject_HEAD

BIO *bio;

int eof_written;

} PySSLMemoryBIO;

#define PySSLMemoryBIO_CAST(op) ((PySSLMemoryBIO *)(op))

typedef struct {

PyObject_HEAD

SSL_SESSION *session;

PySSLContext *ctx;

} PySSLSession;

#define PySSLSession_CAST(op) ((PySSLSession *)(op))

static inline _PySSLError _PySSL_errno(int failed, const SSL *ssl, int retcode)

{

_PySSLError err = { 0 };

if (failed) {

#ifdef MS_WINDOWS

err.ws = WSAGetLastError();

_PySSL_FIX_ERRNO;

err.c = errno;

err.ssl = SSL_get_error(ssl, retcode);

}

return err;

}

#include "clinic/_ssl.c.h"

static int PySSL_select(PySocketSockObject *s, int writing, PyTime_t timeout);

typedef enum {

SOCKET_IS_NONBLOCKING,

SOCKET_IS_BLOCKING,

SOCKET_HAS_TIMED_OUT,

SOCKET_HAS_BEEN_CLOSED,

SOCKET_TOO_LARGE_FOR_SELECT,

SOCKET_OPERATION_OK

} timeout_state;

#define ERRSTR1(x,y,z) (x ":" y ": " z)

#define ERRSTR(x) ERRSTR1("_ssl.c", Py_STRINGIFY(__LINE__), x)

static inline PySocketSockObject* GET_SOCKET(PySSLSocket *obj) {

if (obj->Socket) {

PyObject *sock;

if (PyWeakref_GetRef(obj->Socket, &sock)) {

// GET_SOCKET() returns a borrowed reference

Py_DECREF(sock);

}

else {

// dead weak reference

sock = Py_None;

}

return (PySocketSockObject *)sock; // borrowed reference

}

else {

return NULL;

}

}

#define GET_SOCKET_TIMEOUT(sock) \

((sock != NULL) ? (sock)->sock_timeout : 0)

#include "_ssl/debughelpers.c"

PyDoc_STRVAR(SSLError_doc,

"An error occurred in the SSL implementation.");

PyDoc_STRVAR(SSLCertVerificationError_doc,

"A certificate could not be verified.");

PyDoc_STRVAR(SSLZeroReturnError_doc,

"SSL/TLS session closed cleanly.");

PyDoc_STRVAR(SSLWantReadError_doc,

"before the requested operation can be completed.");

PyDoc_STRVAR(SSLWantWriteError_doc,

"before the requested operation can be completed.");

PyDoc_STRVAR(SSLSyscallError_doc,

"System error when attempting SSL operation.");

PyDoc_STRVAR(SSLEOFError_doc,

"SSL/TLS connection terminated abruptly.");

static PyObject *

SSLError_str(PyObject *op)

{

PyOSErrorObject *self = (PyOSErrorObject*)op;

if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {

return Py_NewRef(self->strerror);

}

else

return PyObject_Str(self->args);

}

static PyType_Slot sslerror_type_slots[] = {

{Py_tp_doc, (void*)SSLError_doc},

{Py_tp_str, SSLError_str},

{0, 0},

};

static PyType_Spec sslerror_type_spec = {

.name = "ssl.SSLError",

.basicsize = sizeof(PyOSErrorObject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_IMMUTABLETYPE),

.slots = sslerror_type_slots

};

static void

fill_and_set_sslerror(_sslmodulestate *state,

PySSLSocket *sslsock, PyObject *type, int ssl_errno,

const char *errstr, int lineno, unsigned long errcode)

{

PyObject *err_value = NULL, *reason_obj = NULL, *lib_obj = NULL;

PyObject *verify_obj = NULL, *verify_code_obj = NULL;

PyObject *init_value, *msg, *key;

PyUnicodeWriter *writer = NULL;

if (errcode != 0) {

int lib, reason;

lib = ERR_GET_LIB(errcode);

reason = ERR_GET_REASON(errcode);

key = Py_BuildValue("ii", lib, reason);

if (key == NULL)

goto fail;

reason_obj = PyDict_GetItemWithError(state->err_codes_to_names, key);

Py_DECREF(key);

if (reason_obj == NULL && PyErr_Occurred()) {

goto fail;

}

key = PyLong_FromLong(lib);

if (key == NULL)

goto fail;

lib_obj = PyDict_GetItemWithError(state->lib_codes_to_names, key);

Py_DECREF(key);

if (lib_obj == NULL && PyErr_Occurred()) {

goto fail;

}

if (errstr == NULL) {

errstr = ERR_reason_error_string(errcode);

}

}

/* verify code for cert validation error */

if ((sslsock != NULL) && (type == state->PySSLCertVerificationErrorObject)) {

const char *verify_str = NULL;

long verify_code;

verify_code = SSL_get_verify_result(sslsock->ssl);

verify_code_obj = PyLong_FromLong(verify_code);

if (verify_code_obj == NULL) {

goto fail;

}

switch (verify_code) {

case X509_V_ERR_HOSTNAME_MISMATCH:

verify_obj = PyUnicode_FromFormat(

"Hostname mismatch, certificate is not valid for '%S'.",

sslsock->server_hostname

);

break;

case X509_V_ERR_IP_ADDRESS_MISMATCH:

verify_obj = PyUnicode_FromFormat(

"IP address mismatch, certificate is not valid for '%S'.",

sslsock->server_hostname

);

break;

default:

verify_str = X509_verify_cert_error_string(verify_code);

if (verify_str != NULL) {

verify_obj = PyUnicode_FromString(verify_str);

} else {

verify_obj = Py_NewRef(Py_None);

}

break;

}

if (verify_obj == NULL) {

goto fail;

}

}

// Format message roughly as:

// [lib_obj: reason_obj] errstr: verify_obj (_ssl.c:lineno)

// with parts missing/replaced if unavailable

writer = PyUnicodeWriter_Create(64);

if (!writer) {

goto fail;

}

if (lib_obj) {

if (PyUnicodeWriter_Format(writer, "[%S", lib_obj) < 0) {

goto fail;

}

if (reason_obj) {

if (PyUnicodeWriter_Format(writer, ": %S", reason_obj) < 0) {

goto fail;

}

}

if (PyUnicodeWriter_WriteASCII(writer, "] ", 2) < 0) {

goto fail;

}

}

if (errstr) {

if (PyUnicodeWriter_Format(writer, "%s", errstr) < 0) {

goto fail;

}

}

else {

if (PyUnicodeWriter_Format(

writer, "unknown error (0x%x)", errcode) < 0) {

goto fail;

}

}

if (verify_obj) {

if (PyUnicodeWriter_Format(writer, ": %S", verify_obj) < 0) {

goto fail;

}

}

if (PyUnicodeWriter_Format(writer, " (_ssl.c:%d)", lineno) < 0) {

goto fail;

}

msg = PyUnicodeWriter_Finish(writer);

writer = NULL;

if (!msg) {

goto fail;

}

init_value = Py_BuildValue("iN", ERR_GET_REASON(ssl_errno), msg);

if (init_value == NULL)

goto fail;

err_value = PyObject_CallObject(type, init_value);

Py_DECREF(init_value);

if (err_value == NULL)

goto fail;

if (reason_obj == NULL)

reason_obj = Py_None;

if (PyObject_SetAttr(err_value, state->str_reason, reason_obj))

goto fail;

if (lib_obj == NULL)

lib_obj = Py_None;

if (PyObject_SetAttr(err_value, state->str_library, lib_obj))

goto fail;

if ((sslsock != NULL) && (type == state->PySSLCertVerificationErrorObject)) {

/* Only set verify code / message for SSLCertVerificationError */

if (PyObject_SetAttr(err_value, state->str_verify_code,

verify_code_obj))

goto fail;

if (PyObject_SetAttr(err_value, state->str_verify_message, verify_obj))

goto fail;

}

PyErr_SetObject(type, err_value);

fail:

Py_XDECREF(err_value);

Py_XDECREF(verify_code_obj);

Py_XDECREF(verify_obj);

PyUnicodeWriter_Discard(writer);

}

static int

PySSL_ChainExceptions(PySSLSocket *sslsock) {

if (sslsock->exc == NULL)

return 0;

_PyErr_ChainExceptions1(sslsock->exc);

sslsock->exc = NULL;

return -1;

}

static PyObject *

PySSL_SetError(PySSLSocket *sslsock, const char *filename, int lineno)

{

PyObject *type;

char *errstr = NULL;

_PySSLError err;

enum py_ssl_error p = PY_SSL_ERROR_NONE;

unsigned long e = 0;

assert(sslsock != NULL);

_sslmodulestate *state = get_state_sock(sslsock);

type = state->PySSLErrorObject;

// ERR functions are thread local, no need to lock them.

e = ERR_peek_last_error();

if (sslsock->ssl != NULL) {

err = sslsock->err;

switch (err.ssl) {

case SSL_ERROR_ZERO_RETURN:

errstr = "TLS/SSL connection has been closed (EOF)";

type = state->PySSLZeroReturnErrorObject;

p = PY_SSL_ERROR_ZERO_RETURN;

break;

case SSL_ERROR_WANT_READ:

errstr = "The operation did not complete (read)";

type = state->PySSLWantReadErrorObject;

p = PY_SSL_ERROR_WANT_READ;

break;

case SSL_ERROR_WANT_WRITE:

p = PY_SSL_ERROR_WANT_WRITE;

type = state->PySSLWantWriteErrorObject;

errstr = "The operation did not complete (write)";

break;

case SSL_ERROR_WANT_X509_LOOKUP:

p = PY_SSL_ERROR_WANT_X509_LOOKUP;

errstr = "The operation did not complete (X509 lookup)";

break;

case SSL_ERROR_WANT_CONNECT:

p = PY_SSL_ERROR_WANT_CONNECT;

errstr = "The operation did not complete (connect)";

break;

case SSL_ERROR_SYSCALL:

{

if (e == 0) {

/* underlying BIO reported an I/O error */

ERR_clear_error();

#ifdef MS_WINDOWS

if (err.ws) {

return PyErr_SetFromWindowsErr(err.ws);

}

if (err.c) {

errno = err.c;

return PyErr_SetFromErrno(PyExc_OSError);

}

else {

p = PY_SSL_ERROR_EOF;

type = state->PySSLEOFErrorObject;

errstr = "EOF occurred in violation of protocol";

}

} else {

if (ERR_GET_LIB(e) == ERR_LIB_SSL &&

ERR_GET_REASON(e) == SSL_R_CERTIFICATE_VERIFY_FAILED) {

type = state->PySSLCertVerificationErrorObject;

}

if (ERR_GET_LIB(e) == ERR_LIB_SYS) {

// A system error is being reported; reason is set to errno

errno = ERR_GET_REASON(e);

return PyErr_SetFromErrno(PyExc_OSError);

}

p = PY_SSL_ERROR_SYSCALL;

}

break;

}

case SSL_ERROR_SSL:

{

p = PY_SSL_ERROR_SSL;

if (e == 0) {

/* possible? */

errstr = "A failure in the SSL library occurred";

}

if (ERR_GET_LIB(e) == ERR_LIB_SSL &&

ERR_GET_REASON(e) == SSL_R_CERTIFICATE_VERIFY_FAILED) {

type = state->PySSLCertVerificationErrorObject;

}

#if defined(SSL_R_UNEXPECTED_EOF_WHILE_READING)

/* OpenSSL 3.0 changed transport EOF from SSL_ERROR_SYSCALL with

if (ERR_GET_LIB(e) == ERR_LIB_SSL &&

ERR_GET_REASON(e) == SSL_R_UNEXPECTED_EOF_WHILE_READING) {

p = PY_SSL_ERROR_EOF;

type = state->PySSLEOFErrorObject;

errstr = "EOF occurred in violation of protocol";

}

if (ERR_GET_LIB(e) == ERR_LIB_SYS) {

// A system error is being reported; reason is set to errno

errno = ERR_GET_REASON(e);

return PyErr_SetFromErrno(PyExc_OSError);

}

break;

}

default:

p = PY_SSL_ERROR_INVALID_ERROR_CODE;

errstr = "Invalid error code";

}

}

fill_and_set_sslerror(state, sslsock, type, p, errstr, lineno, e);

ERR_clear_error();

PySSL_ChainExceptions(sslsock);

return NULL;

}

static PyObject *

_setSSLError (_sslmodulestate *state, const char *errstr, int errcode, const char *filename, int lineno)

{

if (errstr == NULL)

errcode = ERR_peek_last_error();

else

errcode = 0;

fill_and_set_sslerror(state, NULL, state->PySSLErrorObject, errcode, errstr, lineno, errcode);

ERR_clear_error();

return NULL;

}

static int

_ssl_deprecated(const char* msg, int stacklevel) {

return PyErr_WarnEx(

PyExc_DeprecationWarning, msg, stacklevel

);

}

#define PY_SSL_DEPRECATED(name, stacklevel, ret) \

if (_ssl_deprecated((name), (stacklevel)) == -1) return (ret)

static int

_ssl_configure_hostname(PySSLSocket *self, const char* server_hostname)

{

int retval = -1;

ASN1_OCTET_STRING *ip;

PyObject *hostname;

size_t len;

assert(server_hostname);

/* Disable OpenSSL's special mode with leading dot in hostname:

len = strlen(server_hostname);

if (len == 0 || *server_hostname == '.') {

PyErr_SetString(

PyExc_ValueError,

"server_hostname cannot be an empty string or start with a "

"leading dot.");

return retval;

}

/* inet_pton is not available on all platforms. */

ip = a2i_IPADDRESS(server_hostname);

if (ip == NULL) {

ERR_clear_error();

}

hostname = PyUnicode_Decode(server_hostname, len, "ascii", "strict");

if (hostname == NULL) {

goto error;

}

self->server_hostname = hostname;

/* Only send SNI extension for non-IP hostnames */

if (ip == NULL) {

if (!SSL_set_tlsext_host_name(self->ssl, server_hostname)) {

_setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);

goto error;

}

}

if (self->ctx->check_hostname) {

X509_VERIFY_PARAM *ssl_verification_params = SSL_get0_param(self->ssl);

if (ip == NULL) {

if (!X509_VERIFY_PARAM_set1_host(ssl_verification_params, server_hostname,

strlen(server_hostname))) {

_setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);

goto error;

}

} else {

if (!X509_VERIFY_PARAM_set1_ip(ssl_verification_params, ASN1_STRING_get0_data(ip),

ASN1_STRING_length(ip))) {

_setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);

goto error;

}

}

}

retval = 0;

error:

if (ip != NULL) {

ASN1_OCTET_STRING_free(ip);

}

return retval;

}

static PySSLSocket *

newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,

PySSLMemoryBIO *inbio, PySSLMemoryBIO *outbio)

{

PySSLSocket *self;

SSL_CTX *ctx = sslctx->ctx;

_PySSLError err = { 0 };

if ((socket_type == PY_SSL_SERVER) &&

(sslctx->protocol == PY_SSL_VERSION_TLS_CLIENT)) {

_setSSLError(get_state_ctx(sslctx),

"Cannot create a server socket with a "

"PROTOCOL_TLS_CLIENT context", 0, __FILE__, __LINE__);

return NULL;

}

if ((socket_type == PY_SSL_CLIENT) &&

(sslctx->protocol == PY_SSL_VERSION_TLS_SERVER)) {

_setSSLError(get_state_ctx(sslctx),

"Cannot create a client socket with a "

"PROTOCOL_TLS_SERVER context", 0, __FILE__, __LINE__);

return NULL;

}

self = PyObject_GC_New(PySSLSocket,

get_state_ctx(sslctx)->PySSLSocket_Type);

if (self == NULL)

return NULL;

self->ssl = NULL;

self->Socket = NULL;

self->ctx = (PySSLContext*)Py_NewRef(sslctx);

self->shutdown_seen_zero = 0;

self->owner = NULL;

self->server_hostname = NULL;

self->err = err;

self->exc = NULL;

/* Make sure the SSL error state is initialized */

ERR_clear_error();

PySSL_BEGIN_ALLOW_THREADS(sslctx)

self->ssl = SSL_new(ctx);

PySSL_END_ALLOW_THREADS(sslctx)

if (self->ssl == NULL) {

Py_DECREF(self);

_setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);

return NULL;

}

if (socket_type == PY_SSL_SERVER) {

#define SID_CTX "Python"

/* Set the session id context (server-side only) */

SSL_set_session_id_context(self->ssl, (const unsigned char *) SID_CTX,

sizeof(SID_CTX));

#undef SID_CTX

}

/* bpo43522 and OpenSSL < 1.1.1l: copy hostflags manually */

#if OPENSSL_VERSION < 0x101010cf

X509_VERIFY_PARAM *ssl_verification_params = SSL_get0_param(self->ssl);

X509_VERIFY_PARAM *ssl_ctx_verification_params = SSL_CTX_get0_param(ctx);

unsigned int ssl_ctx_host_flags = X509_VERIFY_PARAM_get_hostflags(ssl_ctx_verification_params);

X509_VERIFY_PARAM_set_hostflags(ssl_verification_params, ssl_ctx_host_flags);

SSL_set_app_data(self->ssl, self);

if (sock) {

SSL_set_fd(self->ssl, Py_SAFE_DOWNCAST(sock->sock_fd, SOCKET_T, int));

} else {

/* BIOs are reference counted and SSL_set_bio borrows our reference.

BIO_up_ref(inbio->bio);

BIO_up_ref(outbio->bio);

SSL_set_bio(self->ssl, inbio->bio, outbio->bio);

}

SSL_set_mode(self->ssl,

SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER | SSL_MODE_AUTO_RETRY);

#if defined(PySSL_HAVE_POST_HS_AUTH)

if (sslctx->post_handshake_auth == 1) {

if (socket_type == PY_SSL_SERVER) {

/* bpo-37428: OpenSSL does not ignore SSL_VERIFY_POST_HANDSHAKE.

int mode = SSL_get_verify_mode(self->ssl);

if (mode & SSL_VERIFY_PEER) {

mode |= SSL_VERIFY_POST_HANDSHAKE;

SSL_set_verify(self->ssl, mode, NULL);

}

} else {

/* client socket */

SSL_set_post_handshake_auth(self->ssl, 1);

}

}

if (server_hostname != NULL) {

if (_ssl_configure_hostname(self, server_hostname) < 0) {

Py_DECREF(self);

return NULL;

}

}

/* If the socket is in non-blocking mode or timeout mode, set the BIO

if (sock && sock->sock_timeout >= 0) {

BIO_set_nbio(SSL_get_rbio(self->ssl), 1);

BIO_set_nbio(SSL_get_wbio(self->ssl), 1);

}

Py_BEGIN_ALLOW_THREADS;

if (socket_type == PY_SSL_CLIENT)

SSL_set_connect_state(self->ssl);

else

SSL_set_accept_state(self->ssl);

Py_END_ALLOW_THREADS;

self->socket_type = socket_type;