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

*/

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

#define PY_SSIZE_T_CLEAN

#include "Python.h"

/* Include symbols from _socket module */

#include "socketmodule.h"

#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 { \

PyThreadState *_save = NULL; \

PySSL_BEGIN_ALLOW_THREADS_S(_save);

#define PySSL_BLOCK_THREADS PySSL_END_ALLOW_THREADS_S(_save);

#define PySSL_UNBLOCK_THREADS PySSL_BEGIN_ALLOW_THREADS_S(_save);

#define PySSL_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"

#ifndef OPENSSL_THREADS

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

#endif

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

#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)

#include "_ssl_data_300.h"

#elif (OPENSSL_VERSION_NUMBER >= 0x10101000L) && !defined(LIBRESSL_VERSION_NUMBER)

#include "_ssl_data_111.h"

#else

#include "_ssl_data.h"

#endif

/* OpenSSL API 1.1.0+ does not include version methods */

#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

/* OpenSSL 1.1 does not have SSL 2.0 */

#define OPENSSL_NO_SSL2

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

#elif PY_SSL_DEFAULT_CIPHERS == 1

/* Python custom selection of sensible cipher suites

* DEFAULT: OpenSSL's default cipher list. Since 1.0.2 the list is in sensible order.

* !aNULL:!eNULL: really no NULL ciphers

* !MD5:!3DES:!DES:!RC4:!IDEA:!SEED: no weak or broken algorithms on old OpenSSL versions.

* !aDSS: no authentication with discrete logarithm DSA algorithm

* !SRP:!PSK: no secure remote password or pre-shared key authentication

*/

#define PY_SSL_DEFAULT_CIPHER_STRING "DEFAULT:!aNULL:!eNULL:!MD5:!3DES:!DES:!RC4:!IDEA:!SEED:!aDSS:!SRP:!PSK"

#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

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,

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

/* OpenSSL has no API to get hostflags from X509_VERIFY_PARAM* struct.

* We have to maintain our own copy. OpenSSL's hostflags default to 0.

*/

unsigned int hostflags;

int protocol;

#ifdef TLS1_3_VERSION

int post_handshake_auth;

#endif

PyObject *msg_cb;

PyObject *keylog_filename;

BIO *keylog_bio;

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

_sslmodulestate *state;

} PySSLContext;

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

* store exception information on the socket. The handshake, read, write,

* and shutdown methods check for chained exceptions.

*/

PyObject *exc_type;

PyObject *exc_value;

PyObject *exc_tb;

} PySSLSocket;

typedef struct {

PyObject_HEAD

BIO *bio;

int eof_written;

} PySSLMemoryBIO;

typedef struct {

PyObject_HEAD

SSL_SESSION *session;

PySSLContext *ctx;

} PySSLSession;

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

static int PySSL_set_owner(PySSLSocket *, PyObject *, void *);

static int PySSL_set_session(PySSLSocket *, PyObject *, void *);

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)

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

#define GET_SOCKET(obj) ((obj)->Socket ? \

(PySocketSockObject *) PyWeakref_GetObject((obj)->Socket) : NULL)

/* 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(PyOSErrorObject *self)

{

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

Py_INCREF(self->strerror);

return 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 = {

"ssl.SSLError",

sizeof(PyOSErrorObject),

0,

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

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;

_Py_IDENTIFIER(reason);

_Py_IDENTIFIER(library);

_Py_IDENTIFIER(verify_message);

_Py_IDENTIFIER(verify_code);

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

}

if (errstr == NULL)

errstr = "unknown error";

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

Py_INCREF(verify_obj);

}

break;

}

if (verify_obj == NULL) {

goto fail;

}

}

if (verify_obj && reason_obj && lib_obj)

msg = PyUnicode_FromFormat("[%S: %S] %s: %S (_ssl.c:%d)",

lib_obj, reason_obj, errstr, verify_obj,

lineno);

else if (reason_obj && lib_obj)

msg = PyUnicode_FromFormat("[%S: %S] %s (_ssl.c:%d)",

lib_obj, reason_obj, errstr, lineno);

else if (lib_obj)

msg = PyUnicode_FromFormat("[%S] %s (_ssl.c:%d)",

lib_obj, errstr, lineno);

else

msg = PyUnicode_FromFormat("%s (_ssl.c:%d)", errstr, lineno);

if (msg == NULL)

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_SetAttrId(err_value, &PyId_reason, reason_obj))

goto fail;

if (lib_obj == NULL)

lib_obj = Py_None;

if (_PyObject_SetAttrId(err_value, &PyId_library, lib_obj))

goto fail;

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

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

if (_PyObject_SetAttrId(err_value, &PyId_verify_code,

verify_code_obj))

goto fail;

if (_PyObject_SetAttrId(err_value, &PyId_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);

}

static int

PySSL_ChainExceptions(PySSLSocket *sslsock) {

if (sslsock->exc_type == NULL)

return 0;

_PyErr_ChainExceptions(sslsock->exc_type, sslsock->exc_value, sslsock->exc_tb);

sslsock->exc_type = NULL;

sslsock->exc_value = NULL;

sslsock->exc_tb = NULL;

return -1;

}

static PyObject *

PySSL_SetError(PySSLSocket *sslsock, int ret, 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;

assert(ret <= 0);

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

PySocketSockObject *s = GET_SOCKET(sslsock);

if (ret == 0 || (((PyObject *)s) == Py_None)) {

p = PY_SSL_ERROR_EOF;

type = state->PySSLEOFErrorObject;

errstr = "EOF occurred in violation of protocol";

} else if (s && ret == -1) {

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

p = PY_SSL_ERROR_SYSCALL;

type = state->PySSLSyscallErrorObject;

errstr = "Some I/O error occurred";

}

} else {

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;

}

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* name, int stacklevel) {

return PyErr_WarnFormat(

PyExc_DeprecationWarning, stacklevel,

"ssl module: %s is deprecated", name

);

}

#define PY_SSL_DEPRECATED(name, stacklevel, ret) \

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

/*

* 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 *param = SSL_get0_param(self->ssl);

if (ip == NULL) {

if (!X509_VERIFY_PARAM_set1_host(param, server_hostname,

strlen(server_hostname))) {

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

goto error;

}

} else {

if (!X509_VERIFY_PARAM_set1_ip(param, 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;

_PySSLError err = { 0 };

self = PyObject_New(PySSLSocket, get_state_ctx(sslctx)->PySSLSocket_Type);

if (self == NULL)

return NULL;

self->ssl = NULL;

self->Socket = NULL;

self->ctx = sslctx;

Py_INCREF(sslctx);

self->shutdown_seen_zero = 0;

self->owner = NULL;

self->server_hostname = NULL;

self->err = err;

self->exc_type = NULL;

self->exc_value = NULL;

self->exc_tb = 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__);

return NULL;

}

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

#if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION < 0x101010cf

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

X509_VERIFY_PARAM_set_hostflags(ssl_params, sslctx->hostflags);

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

#ifdef TLS1_3_VERSION

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

int (*verify_cb)(int, X509_STORE_CTX *) = NULL;

verify_cb = SSL_get_verify_callback(self->ssl);

mode |= SSL_VERIFY_POST_HANDSHAKE;

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

}

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

}

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

return NULL;

}

}

if (owner && owner != Py_None) {

if (PySSL_set_owner(self, owner, NULL) == -1) {

Py_DECREF(self);

return NULL;

}

}

if (session && session != Py_None) {

if (PySSL_set_session(self, session, NULL) == -1) {

Py_DECREF(self);

return NULL;

}

}

return self;

}

/* SSL object methods */

/*[clinic input]

_ssl._SSLSocket.do_handshake

[clinic start generated code]*/

static PyObject *

_ssl__SSLSocket_do_handshake_impl(PySSLSocket *self)

/*[clinic end generated code: output=6c0898a8936548f6 input=d2d737de3df018c8]*/

{

int ret;

_PySSLError err;

int sockstate, nonblocking;

PySocketSockObject *sock = GET_SOCKET(self);

_PyTime_t timeout, deadline = 0;

int has_timeout;

if (sock) {

if (((PyObject*)sock) == Py_None) {

_setSSLError(get_state_sock(self),

"Underlying socket connection gone",

PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);

return NULL;

}

Py_INCREF(sock);

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

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

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

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

}

timeout = GET_SOCKET_TIMEOUT(sock);

has_timeout = (timeout > 0);

if (has_timeout)

deadline = _PyTime_GetMonotonicClock() + timeout;

/* Actually negotiate SSL connection */

/* XXX If SSL_do_handshake() returns 0, it's also a failure. */

do {

PySSL_BEGIN_ALLOW_THREADS

ret = SSL_do_handshake(self->ssl);

err = _PySSL_errno(ret < 1, self->ssl, ret);

PySSL_END_ALLOW_THREADS

self->err = err;

if (PyErr_CheckSignals())

goto error;

if (has_timeout)

timeout = deadline - _PyTime_GetMonotonicClock();

if (err.ssl == SSL_ERROR_WANT_READ) {

sockstate = PySSL_select(sock, 0, timeout);

} else if (err.ssl == SSL_ERROR_WANT_WRITE) {

sockstate = PySSL_select(sock, 1, timeout);

} else {

sockstate = SOCKET_OPERATION_OK;

}

if (sockstate == SOCKET_HAS_TIMED_OUT) {

PyErr_SetString(PyExc_TimeoutError,

ERRSTR("The handshake operation timed out"));

goto error;

} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {

PyErr_SetString(get_state_sock(self)->PySSLErrorObject,

ERRSTR("Underlying socket has been closed."));

goto error;

} else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {

PyErr_SetString(get_state_sock(self)->PySSLErrorObject,

ERRSTR("Underlying socket too large for select()."));

goto error;

} else if (sockstate == SOCKET_IS_NONBLOCKING) {

break;

}

} while (err.ssl == SSL_ERROR_WANT_READ ||

err.ssl == SSL_ERROR_WANT_WRITE);

Py_XDECREF(sock);

if (ret < 1)

return PySSL_SetError(self, ret, __FILE__, __LINE__);

if (PySSL_ChainExceptions(self) < 0)

return NULL;

Py_RETURN_NONE;

error:

Py_XDECREF(sock);

PySSL_ChainExceptions(self);

return NULL;

}

static PyObject *

_asn1obj2py(_sslmodulestate *state, const ASN1_OBJECT *name, int no_name)

{

char buf[X509_NAME_MAXLEN];

char *namebuf = buf;

int buflen;

PyObject *name_obj = NULL;

buflen = OBJ_obj2txt(namebuf, X509_NAME_MAXLEN, name, no_name);

if (buflen < 0) {

_setSSLError(state, NULL, 0, __FILE__, __LINE__);

return NULL;

}

/* initial buffer is too small for oid + terminating null byte */

if (buflen > X509_NAME_MAXLEN - 1) {

/* make OBJ_obj2txt() calculate the required buflen */

buflen = OBJ_obj2txt(NULL, 0, name, no_name);

/* allocate len + 1 for terminating NULL byte */

namebuf = PyMem_Malloc(buflen + 1);

if (namebuf == NULL) {

PyErr_NoMemory();

return NULL;

}

buflen = OBJ_obj2txt(namebuf, buflen + 1, name, no_name);

if (buflen < 0) {