_ssl.c

/* SSL socket module

 SSL support based on patches by Brian E Gallew and Laszlo Kovacs.
 Re-worked a bit by Bill Janssen to add server-side support and
 certificate decoding. Chris Stawarz contributed some non-blocking
 patches.

 This module is imported by ssl.py. It should *not* be used
 directly.

 XXX should partial writes be enabled, SSL_MODE_ENABLE_PARTIAL_WRITE?

 XXX integrate several "shutdown modes" as suggested in
 http://bugs.python.org/issue8108#msg102867 ?
*/

#ifndefPy_BUILD_CORE_BUILTIN
# definePy_BUILD_CORE_MODULE 1
#endif

/* Don't warn about deprecated functions, */
#ifndefOPENSSL_API_COMPAT
// 0x10101000L == 1.1.1, 30000 == 3.0.0
#defineOPENSSL_API_COMPAT 0x10101000L
#endif
#defineOPENSSL_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 symbols from _socket module */
#include"socketmodule.h"

#ifdefMS_WINDOWS
# include<wincrypt.h>
#endif

#include"_ssl.h"

/* Redefined below for Windows debug builds after important #includes */
#define_PySSL_FIX_ERRNO

#definePySSL_BEGIN_ALLOW_THREADS_S(save) \
 do { (save) = PyEval_SaveThread(); } while(0)
#definePySSL_END_ALLOW_THREADS_S(save) \
 do { PyEval_RestoreThread(save); _PySSL_FIX_ERRNO; } while(0)
#definePySSL_BEGIN_ALLOW_THREADS { \
 PyThreadState *_save = NULL; \
 PySSL_BEGIN_ALLOW_THREADS_S(_save);
#definePySSL_END_ALLOW_THREADS PySSL_END_ALLOW_THREADS_S(_save); }

#if defined(HAVE_POLL_H)
#include<poll.h>
#elif defined(HAVE_SYS_POLL_H)
#include<sys/poll.h>
#endif

/* Include OpenSSL header files */
#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"

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



structpy_ssl_error_code {
constchar*mnemonic;
intlibrary, reason;
};

structpy_ssl_library_code {
constchar*library;
intcode;
};

#if defined(MS_WINDOWS) && defined(Py_DEBUG)
/* Debug builds on Windows rely on getting errno directly from OpenSSL.
 * However, because it uses a different CRT, we need to transfer the
 * value of errno from OpenSSL into our debug CRT.
 *
 * Don't be fooled - this is horribly ugly code. The only reasonable
 * alternative is to do both debug and release builds of OpenSSL, which
 * requires much uglier code to transform their automatically generated
 * makefile. This is the lesser of all the evils.
 */

staticvoid_PySSLFixErrno(void) {
HMODULEucrtbase=GetModuleHandleW(L"ucrtbase.dll");
if (!ucrtbase) {
/* If ucrtbase.dll is not loaded but the SSL DLLs are, we likely
 * have a catastrophic failure, but this function is not the
 * place to raise it. */
return;
 }

typedefint*(__stdcall *errno_func)(void);
errno_funcssl_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()
#endif

/* Include generated data (error codes) */
/* See make_ssl_data.h for notes on adding a new version. */
#if (OPENSSL_VERSION_NUMBER >= 0x30401000L)
#include"_ssl_data_34.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"
#else
#error Unsupported OpenSSL version
#endif

/* OpenSSL API 1.1.0+ does not include version methods */
#ifndefOPENSSL_NO_SSL3_METHOD
externconstSSL_METHOD*SSLv3_method(void);
#endif
#ifndefOPENSSL_NO_TLS1_METHOD
externconstSSL_METHOD*TLSv1_method(void);
#endif
#ifndefOPENSSL_NO_TLS1_1_METHOD
externconstSSL_METHOD*TLSv1_1_method(void);
#endif
#ifndefOPENSSL_NO_TLS1_2_METHOD
externconstSSL_METHOD*TLSv1_2_method(void);
#endif

#ifndefINVALID_SOCKET/* MS defines this */
#defineINVALID_SOCKET (-1)
#endif

/* Default cipher suites */
#ifndefPY_SSL_DEFAULT_CIPHERS
#definePY_SSL_DEFAULT_CIPHERS 1
#endif

#ifPY_SSL_DEFAULT_CIPHERS==0
#ifndefPY_SSL_DEFAULT_CIPHER_STRING
#error "Py_SSL_DEFAULT_CIPHERS 0 needs Py_SSL_DEFAULT_CIPHER_STRING"
#endif
#ifndefPY_SSL_MIN_PROTOCOL
#definePY_SSL_MIN_PROTOCOL TLS1_2_VERSION
#endif
#elifPY_SSL_DEFAULT_CIPHERS==1
/* Python custom selection of sensible cipher suites
 * @SECLEVEL=2: security level 2 with 112 bits minimum security (e.g. 2048 bits RSA key)
 * ECDH+*: enable ephemeral elliptic curve Diffie-Hellman
 * DHE+*: fallback to ephemeral finite field Diffie-Hellman
 * encryption order: AES AEAD (GCM), ChaCha AEAD, AES CBC
 * !aNULL:!eNULL: really no NULL ciphers
 * !aDSS: no authentication with discrete logarithm DSA algorithm
 * !SHA1: no weak SHA1 MAC
 * !AESCCM: no CCM mode, it's uncommon and slow
 *
 * Based on Hynek's excellent blog post (update 2021-02-11)
 * https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
 */
#definePY_SSL_DEFAULT_CIPHER_STRING "@SECLEVEL=2:ECDH+AESGCM:ECDH+CHACHA20:ECDH+AES:DHE+AES:!aNULL:!eNULL:!aDSS:!SHA1:!AESCCM"
#ifndefPY_SSL_MIN_PROTOCOL
#definePY_SSL_MIN_PROTOCOL TLS1_2_VERSION
#endif
#elifPY_SSL_DEFAULT_CIPHERS==2
/* Ignored in SSLContext constructor, only used to as _ssl.DEFAULT_CIPHER_STRING */
#definePY_SSL_DEFAULT_CIPHER_STRING SSL_DEFAULT_CIPHER_LIST
#else
#error "Unsupported PY_SSL_DEFAULT_CIPHERS"
#endif


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


enumpy_ssl_error {
/* these mirror ssl.h */
PY_SSL_ERROR_NONE,
PY_SSL_ERROR_SSL,
PY_SSL_ERROR_WANT_READ,
PY_SSL_ERROR_WANT_WRITE,
PY_SSL_ERROR_WANT_X509_LOOKUP,
PY_SSL_ERROR_SYSCALL, /* look at error stack/return value/errno */
PY_SSL_ERROR_ZERO_RETURN,
PY_SSL_ERROR_WANT_CONNECT,
/* start of non ssl.h errorcodes */
PY_SSL_ERROR_EOF, /* special case of SSL_ERROR_SYSCALL */
PY_SSL_ERROR_NO_SOCKET, /* socket has been GC'd */
PY_SSL_ERROR_INVALID_ERROR_CODE
};

enumpy_ssl_server_or_client {
PY_SSL_CLIENT,
PY_SSL_SERVER
};

enumpy_ssl_cert_requirements {
PY_SSL_CERT_NONE,
PY_SSL_CERT_OPTIONAL,
PY_SSL_CERT_REQUIRED
};

enumpy_ssl_version {
PY_SSL_VERSION_SSL2,
PY_SSL_VERSION_SSL3=1,
PY_SSL_VERSION_TLS, /* SSLv23 */
PY_SSL_VERSION_TLS1,
PY_SSL_VERSION_TLS1_1,
PY_SSL_VERSION_TLS1_2,
PY_SSL_VERSION_TLS_CLIENT=0x10,
PY_SSL_VERSION_TLS_SERVER,
};

enumpy_proto_version {
PY_PROTO_MINIMUM_SUPPORTED=-2,
PY_PROTO_SSLv3=SSL3_VERSION,
PY_PROTO_TLSv1=TLS1_VERSION,
PY_PROTO_TLSv1_1=TLS1_1_VERSION,
PY_PROTO_TLSv1_2=TLS1_2_VERSION,
#if defined(TLS1_3_VERSION)
PY_PROTO_TLSv1_3=TLS1_3_VERSION,
#else
PY_PROTO_TLSv1_3=0x304,
#endif
PY_PROTO_MAXIMUM_SUPPORTED=-1,

/* OpenSSL has no dedicated API to set the minimum version to the maximum
 * available version, and the other way around. We have to figure out the
 * minimum and maximum available version on our own and hope for the best.
 */
#if defined(SSL3_VERSION) && !defined(OPENSSL_NO_SSL3)
PY_PROTO_MINIMUM_AVAILABLE=PY_PROTO_SSLv3,
#elif defined(TLS1_VERSION) && !defined(OPENSSL_NO_TLS1)
PY_PROTO_MINIMUM_AVAILABLE=PY_PROTO_TLSv1,
#elif defined(TLS1_1_VERSION) && !defined(OPENSSL_NO_TLS1_1)
PY_PROTO_MINIMUM_AVAILABLE=PY_PROTO_TLSv1_1,
#elif defined(TLS1_2_VERSION) && !defined(OPENSSL_NO_TLS1_2)
PY_PROTO_MINIMUM_AVAILABLE=PY_PROTO_TLSv1_2,
#elif defined(TLS1_3_VERSION) && !defined(OPENSSL_NO_TLS1_3)
PY_PROTO_MINIMUM_AVAILABLE=PY_PROTO_TLSv1_3,
#else
#error "PY_PROTO_MINIMUM_AVAILABLE not found"
#endif

#if defined(TLS1_3_VERSION) && !defined(OPENSSL_NO_TLS1_3)
PY_PROTO_MAXIMUM_AVAILABLE=PY_PROTO_TLSv1_3,
#elif defined(TLS1_2_VERSION) && !defined(OPENSSL_NO_TLS1_2)
PY_PROTO_MAXIMUM_AVAILABLE=PY_PROTO_TLSv1_2,
#elif defined(TLS1_1_VERSION) && !defined(OPENSSL_NO_TLS1_1)
PY_PROTO_MAXIMUM_AVAILABLE=PY_PROTO_TLSv1_1,
#elif defined(TLS1_VERSION) && !defined(OPENSSL_NO_TLS1)
PY_PROTO_MAXIMUM_AVAILABLE=PY_PROTO_TLSv1,
#elif defined(SSL3_VERSION) && !defined(OPENSSL_NO_SSL3)
PY_PROTO_MAXIMUM_AVAILABLE=PY_PROTO_SSLv3,
#else
#error "PY_PROTO_MAXIMUM_AVAILABLE not found"
#endif
};

/* SSL socket object */

#defineX509_NAME_MAXLEN 256


/* In case of 'tls-unique' it will be 12 bytes for TLS, 36 bytes for
 * older SSL, but let's be safe */
#definePySSL_CB_MAXLEN 128


typedefstruct {
PyObject_HEAD
SSL_CTX*ctx;
unsigned char*alpn_protocols;
unsigned intalpn_protocols_len;
PyObject*set_sni_cb;
intcheck_hostname;
intprotocol;
#if defined(PySSL_HAVE_POST_HS_AUTH)
intpost_handshake_auth;
#endif
PyObject*msg_cb;
PyObject*keylog_filename;
BIO*keylog_bio;
/* Cached module state, also used in SSLSocket and SSLSession code. */
_sslmodulestate*state;
#ifndefOPENSSL_NO_PSK
PyObject*psk_client_callback;
PyObject*psk_server_callback;
#endif
} PySSLContext;

#definePySSLContext_CAST(op) ((PySSLContext *)(op))

typedefstruct {
intssl; /* last seen error from SSL */
intc; /* last seen error from libc */
#ifdefMS_WINDOWS
intws; /* last seen error from winsock */
#endif
} _PySSLError;

typedefstruct {
PyObject_HEAD
PyObject*Socket; /* weakref to socket on which we're layered */
SSL*ssl;
PySSLContext*ctx; /* weakref to SSL context */
charshutdown_seen_zero;
enumpy_ssl_server_or_clientsocket_type;
PyObject*owner; /* Python level "owner" passed to servername callback */
PyObject*server_hostname;
_PySSLErrorerr; /* last seen error from various sources */
/* Some SSL callbacks don't have error reporting. Callback wrappers
 * store exception information on the socket. The handshake, read, write,
 * and shutdown methods check for chained exceptions.
 */
PyObject*exc;
} PySSLSocket;

#definePySSLSocket_CAST(op) ((PySSLSocket *)(op))

typedefstruct {
PyObject_HEAD
BIO*bio;
inteof_written;
} PySSLMemoryBIO;

#definePySSLMemoryBIO_CAST(op) ((PySSLMemoryBIO *)(op))

typedefstruct {
PyObject_HEAD
SSL_SESSION*session;
PySSLContext*ctx;
} PySSLSession;

#definePySSLSession_CAST(op) ((PySSLSession *)(op))

staticinline_PySSLError_PySSL_errno(intfailed, constSSL*ssl, intretcode)
{
_PySSLErrorerr= { 0 };
if (failed) {
#ifdefMS_WINDOWS
err.ws=WSAGetLastError();
_PySSL_FIX_ERRNO;
#endif
err.c=errno;
err.ssl=SSL_get_error(ssl, retcode);
 }
returnerr;
}

/*[clinic input]
module _ssl
class _ssl._SSLContext "PySSLContext *" "get_state_type(type)->PySSLContext_Type"
class _ssl._SSLSocket "PySSLSocket *" "get_state_type(type)->PySSLSocket_Type"
class _ssl.MemoryBIO "PySSLMemoryBIO *" "get_state_type(type)->PySSLMemoryBIO_Type"
class _ssl.SSLSession "PySSLSession *" "get_state_type(type)->PySSLSession_Type"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=d293bed8bae240fd]*/

#include"clinic/_ssl.c.h"

staticintPySSL_select(PySocketSockObject*s, intwriting, PyTime_ttimeout);

typedefenum {
SOCKET_IS_NONBLOCKING,
SOCKET_IS_BLOCKING,
SOCKET_HAS_TIMED_OUT,
SOCKET_HAS_BEEN_CLOSED,
SOCKET_TOO_LARGE_FOR_SELECT,
SOCKET_OPERATION_OK
} timeout_state;

/* Wrap error strings with filename and line # */
#defineERRSTR1(x,y,z) (x ":" y ": " z)
#defineERRSTR(x) ERRSTR1("_ssl.c", Py_STRINGIFY(__LINE__), x)

// Get the socket from a PySSLSocket, if it has one.
// Return a borrowed reference.
staticinlinePySocketSockObject*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 {
returnNULL;
 }
}

/* If sock is NULL, use a timeout of 0 second */
#defineGET_SOCKET_TIMEOUT(sock) \
 ((sock != NULL) ? (sock)->sock_timeout : 0)

#include"_ssl/debughelpers.c"

/*
 * SSL errors.
 */

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,
"Non-blocking SSL socket needs to read more data\n"
"before the requested operation can be completed.");

PyDoc_STRVAR(SSLWantWriteError_doc,
"Non-blocking SSL socket needs to write more data\n"
"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.");

staticPyObject*
SSLError_str(PyObject*op)
{
PyOSErrorObject*self= (PyOSErrorObject*)op;
if (self->strerror!=NULL&&PyUnicode_Check(self->strerror)) {
returnPy_NewRef(self->strerror);
 }
else
returnPyObject_Str(self->args);
}

staticPyType_Slotsslerror_type_slots[] = {
 {Py_tp_doc, (void*)SSLError_doc},
 {Py_tp_str, SSLError_str},
 {0, 0},
};

staticPyType_Specsslerror_type_spec= {
 .name="ssl.SSLError",
 .basicsize=sizeof(PyOSErrorObject),
 .flags= (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_IMMUTABLETYPE),
 .slots=sslerror_type_slots
};

staticvoid
fill_and_set_sslerror(_sslmodulestate*state,
PySSLSocket*sslsock, PyObject*type, intssl_errno,
constchar*errstr, intlineno, unsigned longerrcode)
{
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) {
intlib, 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)) {
constchar*verify_str=NULL;
longverify_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) {
caseX509_V_ERR_HOSTNAME_MISMATCH:
verify_obj=PyUnicode_FromFormat(
"Hostname mismatch, certificate is not valid for '%S'.",
sslsock->server_hostname
 );
break;
caseX509_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_WriteUTF8(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);
}

staticint
PySSL_ChainExceptions(PySSLSocket*sslsock) {
if (sslsock->exc==NULL)
return0;

_PyErr_ChainExceptions1(sslsock->exc);
sslsock->exc=NULL;
return-1;
}

staticPyObject*
PySSL_SetError(PySSLSocket*sslsock, constchar*filename, intlineno)
{
PyObject*type;
char*errstr=NULL;
_PySSLErrorerr;
enumpy_ssl_errorp=PY_SSL_ERROR_NONE;
unsigned longe=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) {
caseSSL_ERROR_ZERO_RETURN:
errstr="TLS/SSL connection has been closed (EOF)";
type=state->PySSLZeroReturnErrorObject;
p=PY_SSL_ERROR_ZERO_RETURN;
break;
caseSSL_ERROR_WANT_READ:
errstr="The operation did not complete (read)";
type=state->PySSLWantReadErrorObject;
p=PY_SSL_ERROR_WANT_READ;
break;
caseSSL_ERROR_WANT_WRITE:
p=PY_SSL_ERROR_WANT_WRITE;
type=state->PySSLWantWriteErrorObject;
errstr="The operation did not complete (write)";
break;
caseSSL_ERROR_WANT_X509_LOOKUP:
p=PY_SSL_ERROR_WANT_X509_LOOKUP;
errstr="The operation did not complete (X509 lookup)";
break;
caseSSL_ERROR_WANT_CONNECT:
p=PY_SSL_ERROR_WANT_CONNECT;
errstr="The operation did not complete (connect)";
break;
caseSSL_ERROR_SYSCALL:
 {
if (e==0) {
/* underlying BIO reported an I/O error */
ERR_clear_error();
#ifdefMS_WINDOWS
if (err.ws) {
returnPyErr_SetFromWindowsErr(err.ws);
 }
#endif
if (err.c) {
errno=err.c;
returnPyErr_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);
returnPyErr_SetFromErrno(PyExc_OSError);
 }
p=PY_SSL_ERROR_SYSCALL;
 }
break;
 }
caseSSL_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
 * zero return value to SSL_ERROR_SSL with a special error code. */
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";
 }
#endif
if (ERR_GET_LIB(e) ==ERR_LIB_SYS) {
// A system error is being reported; reason is set to errno
errno=ERR_GET_REASON(e);
returnPyErr_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);
returnNULL;
}

staticPyObject*
_setSSLError (_sslmodulestate*state, constchar*errstr, interrcode, constchar*filename, intlineno)
{
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();
returnNULL;
}

staticint
_ssl_deprecated(constchar*msg, intstacklevel) {
returnPyErr_WarnEx(
PyExc_DeprecationWarning, msg, stacklevel
 );
}

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

/*
 * SSL objects
 */

staticint
_ssl_configure_hostname(PySSLSocket*self, constchar*server_hostname)
{
intretval=-1;
ASN1_OCTET_STRING*ip;
PyObject*hostname;
size_tlen;

assert(server_hostname);

/* Disable OpenSSL's special mode with leading dot in hostname:
 * When name starts with a dot (e.g ".example.com"), it will be
 * matched by a certificate valid for any sub-domain of name.
 */
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.");
returnretval;
 }

/* 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);
 }
returnretval;
}

staticPySSLSocket*
newPySSLSocket(PySSLContext*sslctx, PySocketSockObject*sock,
enumpy_ssl_server_or_clientsocket_type,
char*server_hostname,
PyObject*owner, PyObject*session,
PySSLMemoryBIO*inbio, PySSLMemoryBIO*outbio)
{
PySSLSocket*self;
SSL_CTX*ctx=sslctx->ctx;
_PySSLErrorerr= { 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__);
returnNULL;
 }
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__);
returnNULL;
 }

self=PyObject_GC_New(PySSLSocket,
get_state_ctx(sslctx)->PySSLSocket_Type);
if (self==NULL)
returnNULL;

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
self->ssl=SSL_new(ctx);
PySSL_END_ALLOW_THREADS
if (self->ssl== NULL) {
Py_DECREF(self);
_setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
returnNULL;
 }

if (socket_type==PY_SSL_SERVER) {
#defineSID_CTX "Python"
/* Set the session id context (server-side only) */
SSL_set_session_id_context(self->ssl, (constunsigned char*) SID_CTX,
sizeof(SID_CTX));
#undef SID_CTX
 }

/* bpo43522 and OpenSSL < 1.1.1l: copy hostflags manually */
#ifOPENSSL_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 intssl_ctx_host_flags=X509_VERIFY_PARAM_get_hostflags(ssl_ctx_verification_params);
X509_VERIFY_PARAM_set_hostflags(ssl_verification_params, ssl_ctx_host_flags);
#endif
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.
 * To prevent a double free in memory_bio_dealloc() we need to take an
 * extra reference here. */
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.
 * Set SSL_VERIFY_POST_HANDSHAKE flag only for server sockets and
 * only in combination with SSL_VERIFY_PEER flag. */
intmode=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);
 }
 }
#endif

if (server_hostname!=NULL) {
if (_ssl_configure_hostname(self, server_hostname) <0) {
Py_DECREF(self);
returnNULL;
 }
 }
/* If the socket is in non-blocking mode or timeout mode, set the BIO
 * to non-blocking mode (blocking is the default)
 */
if (sock&&sock->sock_timeout >= 0) {
BIO_set_nbio(SSL_get_rbio(self->ssl), 1);
BIO_set_nbio(SSL_get_wbio(self->ssl), 1);
 }

PySSL_BEGIN_ALLOW_THREADS
if (socket_type==PY_SSL_CLIENT)
SSL_set_connect_state(self->ssl);
else
SSL_set_accept_state(self->ssl);
PySSL_END_ALLOW_THREADS

self->socket_type=socket_type;
if (sock!=NULL) {
self->Socket=PyWeakref_NewRef((PyObject*) sock, NULL);
if (self->Socket==NULL) {
Py_DECREF(self);
returnNULL;
 }
 }
if (owner&&owner!=Py_None) {
if (_ssl__SSLSocket_owner_set((PyObject*)self, owner, NULL) <0) {
Py_DECREF(self);
returnNULL;
 }
 }
if (session&&session!=Py_None) {
if (_ssl__SSLSocket_session_set((PyObject*)self, session, NULL) <0) {
Py_DECREF(self);
returnNULL;
 }
 }

PyObject_GC_Track(self);
returnself;
}

/* SSL object methods */

/*[clinic input]
@critical_section
_ssl._SSLSocket.do_handshake
[clinic start generated code]*/