/* 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 ?

*/

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

/* Don't warn about deprecated functions, */

#ifndef OPENSSL_API_COMPAT

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

#define OPENSSL_API_COMPAT 0x10101000L

#endif

#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 symbols from _socket module */

#include "socketmodule.h"

#ifdef MS_WINDOWS

# include <wincrypt.h>

#endif

#include "_ssl.h"

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

#define _PySSL_FIX_ERRNO

#define PySSL_BEGIN_ALLOW_THREADS_S(save) \

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

#define PySSL_END_ALLOW_THREADS_S(save) \

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

#define PySSL_BEGIN_ALLOW_THREADS(self) { \

PyThreadState *_save = NULL; \

PySSL_BEGIN_ALLOW_THREADS_S(_save); \

PyMutex_Lock(&(self)->tstate_mutex);

#define PySSL_END_ALLOW_THREADS(self) \

PyMutex_Unlock(&(self)->tstate_mutex); \

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"

#ifndef OPENSSL_THREADS

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

#endif

#ifdef BIO_get_ktls_send

# ifdef MS_WINDOWS

typedef long long Py_off_t;

# else

typedef off_t Py_off_t;

# endif

static int

Py_off_t_converter(PyObject *arg, void *addr)

{

#ifdef HAVE_LARGEFILE_SUPPORT

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

#else

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

#endif

return PyErr_Occurred() ? 0 : 1;

}

/*[python input]

class Py_off_t_converter(CConverter):

type = 'Py_off_t'

converter = 'Py_off_t_converter'

[python start generated code]*/

/*[python end generated code: output=da39a3ee5e6b4b0d input=3fd9ca8ca6f0cbb8]*/

#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)

/* 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.

*/

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

* have a catastrophic failure, but this function is not the

* place to raise it. */

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()

#endif

/* Include generated data (error codes) */

/* See Tools/ssl/make_ssl_data.py for notes on adding a new version. */

#if (OPENSSL_VERSION_NUMBER >= 0x30401000L)

#include "_ssl_data_36.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 */

#ifndef OPENSSL_NO_SSL3_METHOD

extern const SSL_METHOD *SSLv3_method(void);

#endif

#ifndef OPENSSL_NO_TLS1_METHOD

extern const SSL_METHOD *TLSv1_method(void);

#endif

#ifndef OPENSSL_NO_TLS1_1_METHOD

extern const SSL_METHOD *TLSv1_1_method(void);

#endif

#ifndef OPENSSL_NO_TLS1_2_METHOD

extern const SSL_METHOD *TLSv1_2_method(void);

#endif

#ifndef INVALID_SOCKET /* MS defines this */

#define INVALID_SOCKET (-1)

#endif

/* Default cipher suites */

#ifndef PY_SSL_DEFAULT_CIPHERS

#define PY_SSL_DEFAULT_CIPHERS 1

#endif

#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

/* 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/

*/

#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

/* Ignored in SSLContext constructor, only used to as _ssl.DEFAULT_CIPHER_STRING */

#define PY_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)

#define PySSL_HAVE_POST_HS_AUTH

#endif

enum py_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

};

enum py_ssl_server_or_client {

PY_SSL_CLIENT,

PY_SSL_SERVER

};

enum py_ssl_cert_requirements {

PY_SSL_CERT_NONE,

PY_SSL_CERT_OPTIONAL,

PY_SSL_CERT_REQUIRED

};

enum py_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,

};

enum py_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 */

#define X509_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 */

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

#endif

PyObject *msg_cb;

PyObject *keylog_filename; // can be anything accepted by Py_fopen()

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;

#endif

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

See also gh-134698. */

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 */

#endif

} _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; /* weakref to Python level "owner" passed to servername callback */

PyObject *server_hostname;

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

#endif

err.c = errno;

err.ssl = SSL_get_error(ssl, retcode);

}

return err;

}

/*[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"

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;

/* Wrap error strings with filename and line # */

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

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

/* If sock is NULL, use a timeout of 0 second */

#define GET_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.");

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);

}

// Set the appropriate SSL error exception.

// err - error information from SSL and libc

// exc - if not NULL, an exception from _debughelpers.c callback to be chained

static PyObject *

PySSL_SetError(PySSLSocket *sslsock, _PySSLError err, PyObject *exc,

const char *filename, int lineno)

{

PyObject *type;

char *errstr = NULL;

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) {

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);

}

#endif

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

* 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);

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();

_PyErr_ChainExceptions1(exc); // chain any exceptions from callbacks

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)

// Get the socket from a PySSLSocket, if it has one.

// Stores a strong reference in out_sock.

static int

get_socket(PySSLSocket *obj, PySocketSockObject **out_sock,

const char *filename, int lineno)

{

if (!obj->Socket) {

*out_sock = NULL;

return 0;

}

PySocketSockObject *sock;

int res = PyWeakref_GetRef(obj->Socket, (PyObject **)&sock);

if (res == 0 || sock->sock_fd == INVALID_SOCKET) {

_setSSLError(get_state_sock(obj),

"Underlying socket connection gone",

PY_SSL_ERROR_NO_SOCKET, filename, lineno);

*out_sock = NULL;

return -1;

}

if (sock != NULL) {

/* just in case the blocking state of the socket has been changed */

int nonblocking = (sock->sock_timeout >= 0);

BIO_set_nbio(SSL_get_rbio(obj->ssl), nonblocking);

BIO_set_nbio(SSL_get_wbio(obj->ssl), nonblocking);

}

*out_sock = sock;

return res;

}

/*

* SSL objects

*/

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:

* 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.");

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,

enum py_ssl_server_or_client socket_type,

char *server_hostname,

PyObject *owner, PyObject *session,

PySSLMemoryBIO *inbio, PySSLMemoryBIO *outbio)

{

PySSLSocket *self;

SSL_CTX *ctx = sslctx->ctx;

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;

/* 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) {

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

Py_DECREF(self);

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_NUMBER < 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);

#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. */

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);

}

}

#endif

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

* 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);

}

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;

if (sock != NULL) {

self->Socket = PyWeakref_NewRef((PyObject *) sock, NULL);

if (self->Socket == NULL) {

Py_DECREF(self);

return NULL;

}