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

*/

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "pythread.h"

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

#define _PySSL_FIX_ERRNO

#define PySSL_BEGIN_ALLOW_THREADS_S(save) \

do { if (_ssl_locks_count>0) { (save) = PyEval_SaveThread(); } } while (0)

#define PySSL_END_ALLOW_THREADS_S(save) \

do { if (_ssl_locks_count>0) { 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); }

/* Include symbols from _socket module */

#include "socketmodule.h"

static PySocketModule_APIObject PySocketModule;

#if defined(HAVE_POLL_H)

#include <poll.h>

#elif defined(HAVE_SYS_POLL_H)

#include <sys/poll.h>

#endif

/* Don't warn about deprecated functions */

#ifdef __GNUC__

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#endif

#ifdef __clang__

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

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

#ifndef HAVE_X509_VERIFY_PARAM_SET1_HOST

# ifdef LIBRESSL_VERSION_NUMBER

# error "LibreSSL is missing X509_VERIFY_PARAM_set1_host(), see https://github.com/libressl-portable/portable/issues/381"

# elif OPENSSL_VERSION_NUMBER > 0x1000200fL

# define HAVE_X509_VERIFY_PARAM_SET1_HOST

# else

# error "libssl is too old and does not support X509_VERIFY_PARAM_set1_host()"

# endif

#endif

/* SSL error object */

static PyObject *PySSLErrorObject;

static PyObject *PySSLCertVerificationErrorObject;

static PyObject *PySSLZeroReturnErrorObject;

static PyObject *PySSLWantReadErrorObject;

static PyObject *PySSLWantWriteErrorObject;

static PyObject *PySSLSyscallErrorObject;

static PyObject *PySSLEOFErrorObject;

/* Error mappings */

static PyObject *err_codes_to_names;

static PyObject *err_names_to_codes;

static PyObject *lib_codes_to_names;

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

#include "_ssl_data.h"

#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

# define OPENSSL_VERSION_1_1 1

# define PY_OPENSSL_1_1_API 1

#endif

/* LibreSSL 2.7.0 provides necessary OpenSSL 1.1.0 APIs */

#if defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER >= 0x2070000fL

# define PY_OPENSSL_1_1_API 1

#endif

/* Openssl comes with TLSv1.1 and TLSv1.2 between 1.0.0h and 1.0.1

http://www.openssl.org/news/changelog.html

*/

#if OPENSSL_VERSION_NUMBER >= 0x10001000L

# define HAVE_TLSv1_2 1

#else

# define HAVE_TLSv1_2 0

#endif

/* SNI support (client- and server-side) appeared in OpenSSL 1.0.0 and 0.9.8f

* This includes the SSL_set_SSL_CTX() function.

*/

#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

# define HAVE_SNI 1

#else

# define HAVE_SNI 0

#endif

#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

# define HAVE_ALPN 1

#else

# define HAVE_ALPN 0

#endif

/* We cannot rely on OPENSSL_NO_NEXTPROTONEG because LibreSSL 2.6.1 dropped

* NPN support but did not set OPENSSL_NO_NEXTPROTONEG for compatibility

* reasons. The check for TLSEXT_TYPE_next_proto_neg works with

* OpenSSL 1.0.1+ and LibreSSL.

* OpenSSL 1.1.1-pre1 dropped NPN but still has TLSEXT_TYPE_next_proto_neg.

*/

#ifdef OPENSSL_NO_NEXTPROTONEG

# define HAVE_NPN 0

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

# define HAVE_NPN 0

#elif defined(TLSEXT_TYPE_next_proto_neg)

# define HAVE_NPN 1

#else

# define HAVE_NPN 0

#endif

#ifndef INVALID_SOCKET /* MS defines this */

#define INVALID_SOCKET (-1)

#endif

/* OpenSSL 1.0.2 and LibreSSL needs extra code for locking */

#ifndef OPENSSL_VERSION_1_1

#define HAVE_OPENSSL_CRYPTO_LOCK

#endif

#if defined(OPENSSL_VERSION_1_1) && !defined(OPENSSL_NO_SSL2)

#define OPENSSL_NO_SSL2

#endif

#ifndef PY_OPENSSL_1_1_API

/* OpenSSL 1.1 API shims for OpenSSL < 1.1.0 and LibreSSL < 2.7.0 */

#define TLS_method SSLv23_method

#define TLS_client_method SSLv23_client_method

#define TLS_server_method SSLv23_server_method

static int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)

{

return ne->set;

}

#ifndef OPENSSL_NO_COMP

/* LCOV_EXCL_START */

static int COMP_get_type(const COMP_METHOD *meth)

{

return meth->type;

}

/* LCOV_EXCL_STOP */

#endif

static pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)

{

return ctx->default_passwd_callback;

}

static void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)

{

return ctx->default_passwd_callback_userdata;

}

static int X509_OBJECT_get_type(X509_OBJECT *x)

{

return x->type;

}

static X509 *X509_OBJECT_get0_X509(X509_OBJECT *x)

{

return x->data.x509;

}

static int BIO_up_ref(BIO *b)

{

CRYPTO_add(&b->references, 1, CRYPTO_LOCK_BIO);

return 1;

}

static STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(X509_STORE *store) {

return store->objs;

}

static int

SSL_SESSION_has_ticket(const SSL_SESSION *s)

{

return (s->tlsext_ticklen > 0) ? 1 : 0;

}

static unsigned long

SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s)

{

return s->tlsext_tick_lifetime_hint;

}

#endif /* OpenSSL < 1.1.0 or LibreSSL < 2.7.0 */

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

#if HAVE_TLSv1_2

PY_SSL_VERSION_TLS1,

PY_SSL_VERSION_TLS1_1,

PY_SSL_VERSION_TLS1_2,

#else

PY_SSL_VERSION_TLS1,

#endif

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

};

/* serves as a flag to see whether we've initialized the SSL thread support. */

/* 0 means no, greater than 0 means yes */

static unsigned int _ssl_locks_count = 0;

/* SSL socket object */

#define X509_NAME_MAXLEN 256

/* SSL_CTX_clear_options() and SSL_clear_options() were first added in

* OpenSSL 0.9.8m but do not appear in some 0.9.9-dev versions such the

* 0.9.9 from "May 2008" that NetBSD 5.0 uses. */

#if OPENSSL_VERSION_NUMBER >= 0x009080dfL && OPENSSL_VERSION_NUMBER != 0x00909000L

# define HAVE_SSL_CTX_CLEAR_OPTIONS

#else

# undef HAVE_SSL_CTX_CLEAR_OPTIONS

#endif

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

#if HAVE_NPN

unsigned char *npn_protocols;

int npn_protocols_len;

#endif

#if HAVE_ALPN

unsigned char *alpn_protocols;

unsigned int alpn_protocols_len;

#endif

#ifndef OPENSSL_NO_TLSEXT

PyObject *set_sni_cb;

#endif

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;

} PySSLContext;

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;

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

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

#ifdef MS_WINDOWS

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

#endif

} PySSLSocket;

typedef struct {

PyObject_HEAD

BIO *bio;

int eof_written;

} PySSLMemoryBIO;

typedef struct {

PyObject_HEAD

SSL_SESSION *session;

PySSLContext *ctx;

} PySSLSession;

static PyTypeObject PySSLContext_Type;

static PyTypeObject PySSLSocket_Type;

static PyTypeObject PySSLMemoryBIO_Type;

static PyTypeObject PySSLSession_Type;

#ifdef MS_WINDOWS

#define _PySSL_UPDATE_ERRNO_IF(cond, sock, retcode) if (cond) { \

(sock)->ws_errno = WSAGetLastError(); \

_PySSL_FIX_ERRNO; \

(sock)->c_errno = errno; \

(sock)->ssl_errno = SSL_get_error((sock->ssl), (retcode)); \

} else { sock->ws_errno = 0; sock->c_errno = 0; sock->ssl_errno = 0; }

#else

#define _PySSL_UPDATE_ERRNO_IF(cond, sock, retcode) if (cond) { \

(sock)->c_errno = errno; \

(sock)->ssl_errno = SSL_get_error((sock->ssl), (retcode)); \

} else { (sock)->c_errno = 0; (sock)->ssl_errno = 0; }

#endif

#define _PySSL_UPDATE_ERRNO(sock, retcode) _PySSL_UPDATE_ERRNO_IF(1, (sock), (retcode))

/*[clinic input]

module _ssl

class _ssl._SSLContext "PySSLContext *" "&PySSLContext_Type"

class _ssl._SSLSocket "PySSLSocket *" "&PySSLSocket_Type"

class _ssl.MemoryBIO "PySSLMemoryBIO *" "&PySSLMemoryBIO_Type"

class _ssl.SSLSession "PySSLSession *" "&PySSLSession_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=bdc67fafeeaa8109]*/

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

#define PySSLSocket_Check(v) (Py_TYPE(v) == &PySSLSocket_Type)

#define PySSLMemoryBIO_Check(v) (Py_TYPE(v) == &PySSLMemoryBIO_Type)

#define PySSLSession_Check(v) (Py_TYPE(v) == &PySSLSession_Type)

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)

/*

* 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_base, NULL}, /* Filled out in module init as it's not a constant */

{Py_tp_doc, 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(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_GetItem(err_codes_to_names, key);

Py_DECREF(key);

if (reason_obj == NULL) {

/* XXX if reason < 100, it might reflect a library number (!!) */

PyErr_Clear();

}

key = PyLong_FromLong(lib);

if (key == NULL)

goto fail;

lib_obj = PyDict_GetItem(lib_codes_to_names, key);

Py_DECREF(key);

if (lib_obj == NULL) {

PyErr_Clear();

}

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

#ifdef X509_V_ERR_HOSTNAME_MISMATCH

/* OpenSSL >= 1.0.2, LibreSSL >= 2.5.3 */

case X509_V_ERR_HOSTNAME_MISMATCH:

verify_obj = PyUnicode_FromFormat(

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

sslsock->server_hostname

);

break;

#endif

#ifdef X509_V_ERR_IP_ADDRESS_MISMATCH

case X509_V_ERR_IP_ADDRESS_MISMATCH:

verify_obj = PyUnicode_FromFormat(

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

sslsock->server_hostname

);

break;

#endif

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", 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 == 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 PyObject *

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

{

PyObject *type = PySSLErrorObject;

char *errstr = NULL;

int err;

enum py_ssl_error p = PY_SSL_ERROR_NONE;

unsigned long e = 0;

assert(ret <= 0);

e = ERR_peek_last_error();

if (sslsock->ssl != NULL) {

err = sslsock->ssl_errno;

switch (err) {

case SSL_ERROR_ZERO_RETURN:

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

type = PySSLZeroReturnErrorObject;

p = PY_SSL_ERROR_ZERO_RETURN;

break;

case SSL_ERROR_WANT_READ:

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

type = PySSLWantReadErrorObject;

p = PY_SSL_ERROR_WANT_READ;

break;

case SSL_ERROR_WANT_WRITE:

p = PY_SSL_ERROR_WANT_WRITE;

type = 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 = 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 (sslsock->ws_errno)

return PyErr_SetFromWindowsErr(sslsock->ws_errno);

#endif

if (sslsock->c_errno) {

errno = sslsock->c_errno;

return PyErr_SetFromErrno(PyExc_OSError);

}

Py_INCREF(s);

s->errorhandler();

Py_DECREF(s);

return NULL;

} else { /* possible? */

p = PY_SSL_ERROR_SYSCALL;

type = 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 = PySSLCertVerificationErrorObject;

}

break;

}

default:

p = PY_SSL_ERROR_INVALID_ERROR_CODE;

errstr = "Invalid error code";

}

}

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

ERR_clear_error();

return NULL;

}

static PyObject *

_setSSLError (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(NULL, PySSLErrorObject, errcode, errstr, lineno, errcode);

ERR_clear_error();

return NULL;

}

/*

* 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(NULL, 0, __FILE__, __LINE__);

}

}

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(NULL, 0, __FILE__, __LINE__);

goto error;

}

} else {

if (!X509_VERIFY_PARAM_set1_ip(param, ASN1_STRING_data(ip),

ASN1_STRING_length(ip))) {

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

long mode;

self = PyObject_New(PySSLSocket, &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->ssl_errno = 0;

self->c_errno = 0;

#ifdef MS_WINDOWS

self->ws_errno = 0;

#endif

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

(void) ERR_get_state();

ERR_clear_error();

PySSL_BEGIN_ALLOW_THREADS

self->ssl = SSL_new(ctx);

PySSL_END_ALLOW_THREADS

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

}

mode = SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER;

#ifdef SSL_MODE_AUTO_RETRY

mode |= SSL_MODE_AUTO_RETRY;

#endif

SSL_set_mode(self->ssl, mode);

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;

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