LCOV - code coverage report
Current view: | top level - Modules - _ssl.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 275 | 2612 | 10.5 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 15 | 133 | 11.3 %
|  |  | Branches: | 135 | 1521 | 8.9 %

               Branch data     Line data    Source code
           1                 :            : /* SSL socket module
           2                 :            :
           3                 :            :    SSL support based on patches by Brian E Gallew and Laszlo Kovacs.
           4                 :            :    Re-worked a bit by Bill Janssen to add server-side support and
           5                 :            :    certificate decoding.  Chris Stawarz contributed some non-blocking
           6                 :            :    patches.
           7                 :            :
           8                 :            :    This module is imported by ssl.py. It should *not* be used
           9                 :            :    directly.
          10                 :            :
          11                 :            :    XXX should partial writes be enabled, SSL_MODE_ENABLE_PARTIAL_WRITE?
          12                 :            :
          13                 :            :    XXX integrate several "shutdown modes" as suggested in
          14                 :            :        http://bugs.python.org/issue8108#msg102867 ?
          15                 :            : */
          16                 :            :
          17                 :            : /* Don't warn about deprecated functions, */
          18                 :            : #ifndef OPENSSL_API_COMPAT
          19                 :            :   // 0x10101000L == 1.1.1, 30000 == 3.0.0
          20                 :            :   #define OPENSSL_API_COMPAT 0x10101000L
          21                 :            : #endif
          22                 :            : #define OPENSSL_NO_DEPRECATED 1
          23                 :            :
          24                 :            : #define PY_SSIZE_T_CLEAN
          25                 :            :
          26                 :            : #include "Python.h"
          27                 :            :
          28                 :            : /* Include symbols from _socket module */
          29                 :            : #include "socketmodule.h"
          30                 :            :
          31                 :            : #ifdef MS_WINDOWS
          32                 :            : #  include <wincrypt.h>
          33                 :            : #endif
          34                 :            :
          35                 :            : #include "_ssl.h"
          36                 :            :
          37                 :            : /* Redefined below for Windows debug builds after important #includes */
          38                 :            : #define _PySSL_FIX_ERRNO
          39                 :            :
          40                 :            : #define PySSL_BEGIN_ALLOW_THREADS_S(save) \
          41                 :            :     do { (save) = PyEval_SaveThread(); } while(0)
          42                 :            : #define PySSL_END_ALLOW_THREADS_S(save) \
          43                 :            :     do { PyEval_RestoreThread(save); _PySSL_FIX_ERRNO; } while(0)
          44                 :            : #define PySSL_BEGIN_ALLOW_THREADS { \
          45                 :            :             PyThreadState *_save = NULL;  \
          46                 :            :             PySSL_BEGIN_ALLOW_THREADS_S(_save);
          47                 :            : #define PySSL_END_ALLOW_THREADS PySSL_END_ALLOW_THREADS_S(_save); }
          48                 :            :
          49                 :            :
          50                 :            : #if defined(HAVE_POLL_H)
          51                 :            : #include <poll.h>
          52                 :            : #elif defined(HAVE_SYS_POLL_H)
          53                 :            : #include <sys/poll.h>
          54                 :            : #endif
          55                 :            :
          56                 :            : /* Include OpenSSL header files */
          57                 :            : #include "openssl/rsa.h"
          58                 :            : #include "openssl/crypto.h"
          59                 :            : #include "openssl/x509.h"
          60                 :            : #include "openssl/x509v3.h"
          61                 :            : #include "openssl/pem.h"
          62                 :            : #include "openssl/ssl.h"
          63                 :            : #include "openssl/err.h"
          64                 :            : #include "openssl/rand.h"
          65                 :            : #include "openssl/bio.h"
          66                 :            : #include "openssl/dh.h"
          67                 :            :
          68                 :            : #ifndef OPENSSL_THREADS
          69                 :            : #  error "OPENSSL_THREADS is not defined, Python requires thread-safe OpenSSL"
          70                 :            : #endif
          71                 :            :
          72                 :            :
          73                 :            :
          74                 :            : struct py_ssl_error_code {
          75                 :            :     const char *mnemonic;
          76                 :            :     int library, reason;
          77                 :            : };
          78                 :            :
          79                 :            : struct py_ssl_library_code {
          80                 :            :     const char *library;
          81                 :            :     int code;
          82                 :            : };
          83                 :            :
          84                 :            : #if defined(MS_WINDOWS) && defined(Py_DEBUG)
          85                 :            : /* Debug builds on Windows rely on getting errno directly from OpenSSL.
          86                 :            :  * However, because it uses a different CRT, we need to transfer the
          87                 :            :  * value of errno from OpenSSL into our debug CRT.
          88                 :            :  *
          89                 :            :  * Don't be fooled - this is horribly ugly code. The only reasonable
          90                 :            :  * alternative is to do both debug and release builds of OpenSSL, which
          91                 :            :  * requires much uglier code to transform their automatically generated
          92                 :            :  * makefile. This is the lesser of all the evils.
          93                 :            :  */
          94                 :            :
          95                 :            : static void _PySSLFixErrno(void) {
          96                 :            :     HMODULE ucrtbase = GetModuleHandleW(L"ucrtbase.dll");
          97                 :            :     if (!ucrtbase) {
          98                 :            :         /* If ucrtbase.dll is not loaded but the SSL DLLs are, we likely
          99                 :            :          * have a catastrophic failure, but this function is not the
         100                 :            :          * place to raise it. */
         101                 :            :         return;
         102                 :            :     }
         103                 :            :
         104                 :            :     typedef int *(__stdcall *errno_func)(void);
         105                 :            :     errno_func ssl_errno = (errno_func)GetProcAddress(ucrtbase, "_errno");
         106                 :            :     if (ssl_errno) {
         107                 :            :         errno = *ssl_errno();
         108                 :            :         *ssl_errno() = 0;
         109                 :            :     } else {
         110                 :            :         errno = ENOTRECOVERABLE;
         111                 :            :     }
         112                 :            : }
         113                 :            :
         114                 :            : #undef _PySSL_FIX_ERRNO
         115                 :            : #define _PySSL_FIX_ERRNO _PySSLFixErrno()
         116                 :            : #endif
         117                 :            :
         118                 :            : /* Include generated data (error codes) */
         119                 :            : #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
         120                 :            : #include "_ssl_data_300.h"
         121                 :            : #elif (OPENSSL_VERSION_NUMBER >= 0x10101000L) && !defined(LIBRESSL_VERSION_NUMBER)
         122                 :            : #include "_ssl_data_111.h"
         123                 :            : #else
         124                 :            : #include "_ssl_data.h"
         125                 :            : #endif
         126                 :            :
         127                 :            : /* OpenSSL API 1.1.0+ does not include version methods */
         128                 :            : #ifndef OPENSSL_NO_SSL3_METHOD
         129                 :            : extern const SSL_METHOD *SSLv3_method(void);
         130                 :            : #endif
         131                 :            : #ifndef OPENSSL_NO_TLS1_METHOD
         132                 :            : extern const SSL_METHOD *TLSv1_method(void);
         133                 :            : #endif
         134                 :            : #ifndef OPENSSL_NO_TLS1_1_METHOD
         135                 :            : extern const SSL_METHOD *TLSv1_1_method(void);
         136                 :            : #endif
         137                 :            : #ifndef OPENSSL_NO_TLS1_2_METHOD
         138                 :            : extern const SSL_METHOD *TLSv1_2_method(void);
         139                 :            : #endif
         140                 :            :
         141                 :            : #ifndef INVALID_SOCKET /* MS defines this */
         142                 :            : #define INVALID_SOCKET (-1)
         143                 :            : #endif
         144                 :            :
         145                 :            : /* Default cipher suites */
         146                 :            : #ifndef PY_SSL_DEFAULT_CIPHERS
         147                 :            : #define PY_SSL_DEFAULT_CIPHERS 1
         148                 :            : #endif
         149                 :            :
         150                 :            : #if PY_SSL_DEFAULT_CIPHERS == 0
         151                 :            :   #ifndef PY_SSL_DEFAULT_CIPHER_STRING
         152                 :            :      #error "Py_SSL_DEFAULT_CIPHERS 0 needs Py_SSL_DEFAULT_CIPHER_STRING"
         153                 :            :   #endif
         154                 :            :   #ifndef PY_SSL_MIN_PROTOCOL
         155                 :            :     #define PY_SSL_MIN_PROTOCOL TLS1_2_VERSION
         156                 :            :   #endif
         157                 :            : #elif PY_SSL_DEFAULT_CIPHERS == 1
         158                 :            : /* Python custom selection of sensible cipher suites
         159                 :            :  * @SECLEVEL=2: security level 2 with 112 bits minimum security (e.g. 2048 bits RSA key)
         160                 :            :  * ECDH+*: enable ephemeral elliptic curve Diffie-Hellman
         161                 :            :  * DHE+*: fallback to ephemeral finite field Diffie-Hellman
         162                 :            :  * encryption order: AES AEAD (GCM), ChaCha AEAD, AES CBC
         163                 :            :  * !aNULL:!eNULL: really no NULL ciphers
         164                 :            :  * !aDSS: no authentication with discrete logarithm DSA algorithm
         165                 :            :  * !SHA1: no weak SHA1 MAC
         166                 :            :  * !AESCCM: no CCM mode, it's uncommon and slow
         167                 :            :  *
         168                 :            :  * Based on Hynek's excellent blog post (update 2021-02-11)
         169                 :            :  * https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
         170                 :            :  */
         171                 :            :   #define PY_SSL_DEFAULT_CIPHER_STRING "@SECLEVEL=2:ECDH+AESGCM:ECDH+CHACHA20:ECDH+AES:DHE+AES:!aNULL:!eNULL:!aDSS:!SHA1:!AESCCM"
         172                 :            :   #ifndef PY_SSL_MIN_PROTOCOL
         173                 :            :     #define PY_SSL_MIN_PROTOCOL TLS1_2_VERSION
         174                 :            :   #endif
         175                 :            : #elif PY_SSL_DEFAULT_CIPHERS == 2
         176                 :            : /* Ignored in SSLContext constructor, only used to as _ssl.DEFAULT_CIPHER_STRING */
         177                 :            :   #define PY_SSL_DEFAULT_CIPHER_STRING SSL_DEFAULT_CIPHER_LIST
         178                 :            : #else
         179                 :            :   #error "Unsupported PY_SSL_DEFAULT_CIPHERS"
         180                 :            : #endif
         181                 :            :
         182                 :            :
         183                 :            : enum py_ssl_error {
         184                 :            :     /* these mirror ssl.h */
         185                 :            :     PY_SSL_ERROR_NONE,
         186                 :            :     PY_SSL_ERROR_SSL,
         187                 :            :     PY_SSL_ERROR_WANT_READ,
         188                 :            :     PY_SSL_ERROR_WANT_WRITE,
         189                 :            :     PY_SSL_ERROR_WANT_X509_LOOKUP,
         190                 :            :     PY_SSL_ERROR_SYSCALL,     /* look at error stack/return value/errno */
         191                 :            :     PY_SSL_ERROR_ZERO_RETURN,
         192                 :            :     PY_SSL_ERROR_WANT_CONNECT,
         193                 :            :     /* start of non ssl.h errorcodes */
         194                 :            :     PY_SSL_ERROR_EOF,         /* special case of SSL_ERROR_SYSCALL */
         195                 :            :     PY_SSL_ERROR_NO_SOCKET,   /* socket has been GC'd */
         196                 :            :     PY_SSL_ERROR_INVALID_ERROR_CODE
         197                 :            : };
         198                 :            :
         199                 :            : enum py_ssl_server_or_client {
         200                 :            :     PY_SSL_CLIENT,
         201                 :            :     PY_SSL_SERVER
         202                 :            : };
         203                 :            :
         204                 :            : enum py_ssl_cert_requirements {
         205                 :            :     PY_SSL_CERT_NONE,
         206                 :            :     PY_SSL_CERT_OPTIONAL,
         207                 :            :     PY_SSL_CERT_REQUIRED
         208                 :            : };
         209                 :            :
         210                 :            : enum py_ssl_version {
         211                 :            :     PY_SSL_VERSION_SSL2,
         212                 :            :     PY_SSL_VERSION_SSL3=1,
         213                 :            :     PY_SSL_VERSION_TLS, /* SSLv23 */
         214                 :            :     PY_SSL_VERSION_TLS1,
         215                 :            :     PY_SSL_VERSION_TLS1_1,
         216                 :            :     PY_SSL_VERSION_TLS1_2,
         217                 :            :     PY_SSL_VERSION_TLS_CLIENT=0x10,
         218                 :            :     PY_SSL_VERSION_TLS_SERVER,
         219                 :            : };
         220                 :            :
         221                 :            : enum py_proto_version {
         222                 :            :     PY_PROTO_MINIMUM_SUPPORTED = -2,
         223                 :            :     PY_PROTO_SSLv3 = SSL3_VERSION,
         224                 :            :     PY_PROTO_TLSv1 = TLS1_VERSION,
         225                 :            :     PY_PROTO_TLSv1_1 = TLS1_1_VERSION,
         226                 :            :     PY_PROTO_TLSv1_2 = TLS1_2_VERSION,
         227                 :            : #ifdef TLS1_3_VERSION
         228                 :            :     PY_PROTO_TLSv1_3 = TLS1_3_VERSION,
         229                 :            : #else
         230                 :            :     PY_PROTO_TLSv1_3 = 0x304,
         231                 :            : #endif
         232                 :            :     PY_PROTO_MAXIMUM_SUPPORTED = -1,
         233                 :            :
         234                 :            : /* OpenSSL has no dedicated API to set the minimum version to the maximum
         235                 :            :  * available version, and the other way around. We have to figure out the
         236                 :            :  * minimum and maximum available version on our own and hope for the best.
         237                 :            :  */
         238                 :            : #if defined(SSL3_VERSION) && !defined(OPENSSL_NO_SSL3)
         239                 :            :     PY_PROTO_MINIMUM_AVAILABLE = PY_PROTO_SSLv3,
         240                 :            : #elif defined(TLS1_VERSION) && !defined(OPENSSL_NO_TLS1)
         241                 :            :     PY_PROTO_MINIMUM_AVAILABLE = PY_PROTO_TLSv1,
         242                 :            : #elif defined(TLS1_1_VERSION) && !defined(OPENSSL_NO_TLS1_1)
         243                 :            :     PY_PROTO_MINIMUM_AVAILABLE = PY_PROTO_TLSv1_1,
         244                 :            : #elif defined(TLS1_2_VERSION) && !defined(OPENSSL_NO_TLS1_2)
         245                 :            :     PY_PROTO_MINIMUM_AVAILABLE = PY_PROTO_TLSv1_2,
         246                 :            : #elif defined(TLS1_3_VERSION) && !defined(OPENSSL_NO_TLS1_3)
         247                 :            :     PY_PROTO_MINIMUM_AVAILABLE = PY_PROTO_TLSv1_3,
         248                 :            : #else
         249                 :            :     #error "PY_PROTO_MINIMUM_AVAILABLE not found"
         250                 :            : #endif
         251                 :            :
         252                 :            : #if defined(TLS1_3_VERSION) && !defined(OPENSSL_NO_TLS1_3)
         253                 :            :     PY_PROTO_MAXIMUM_AVAILABLE = PY_PROTO_TLSv1_3,
         254                 :            : #elif defined(TLS1_2_VERSION) && !defined(OPENSSL_NO_TLS1_2)
         255                 :            :     PY_PROTO_MAXIMUM_AVAILABLE = PY_PROTO_TLSv1_2,
         256                 :            : #elif defined(TLS1_1_VERSION) && !defined(OPENSSL_NO_TLS1_1)
         257                 :            :     PY_PROTO_MAXIMUM_AVAILABLE = PY_PROTO_TLSv1_1,
         258                 :            : #elif defined(TLS1_VERSION) && !defined(OPENSSL_NO_TLS1)
         259                 :            :     PY_PROTO_MAXIMUM_AVAILABLE = PY_PROTO_TLSv1,
         260                 :            : #elif defined(SSL3_VERSION) && !defined(OPENSSL_NO_SSL3)
         261                 :            :     PY_PROTO_MAXIMUM_AVAILABLE = PY_PROTO_SSLv3,
         262                 :            : #else
         263                 :            :     #error "PY_PROTO_MAXIMUM_AVAILABLE not found"
         264                 :            : #endif
         265                 :            : };
         266                 :            :
         267                 :            : /* SSL socket object */
         268                 :            :
         269                 :            : #define X509_NAME_MAXLEN 256
         270                 :            :
         271                 :            :
         272                 :            : /* In case of 'tls-unique' it will be 12 bytes for TLS, 36 bytes for
         273                 :            :  * older SSL, but let's be safe */
         274                 :            : #define PySSL_CB_MAXLEN 128
         275                 :            :
         276                 :            :
         277                 :            : typedef struct {
         278                 :            :     PyObject_HEAD
         279                 :            :     SSL_CTX *ctx;
         280                 :            :     unsigned char *alpn_protocols;
         281                 :            :     unsigned int alpn_protocols_len;
         282                 :            :     PyObject *set_sni_cb;
         283                 :            :     int check_hostname;
         284                 :            :     /* OpenSSL has no API to get hostflags from X509_VERIFY_PARAM* struct.
         285                 :            :      * We have to maintain our own copy. OpenSSL's hostflags default to 0.
         286                 :            :      */
         287                 :            :     unsigned int hostflags;
         288                 :            :     int protocol;
         289                 :            : #ifdef TLS1_3_VERSION
         290                 :            :     int post_handshake_auth;
         291                 :            : #endif
         292                 :            :     PyObject *msg_cb;
         293                 :            :     PyObject *keylog_filename;
         294                 :            :     BIO *keylog_bio;
         295                 :            :     /* Cached module state, also used in SSLSocket and SSLSession code. */
         296                 :            :     _sslmodulestate *state;
         297                 :            : } PySSLContext;
         298                 :            :
         299                 :            : typedef struct {
         300                 :            :     int ssl; /* last seen error from SSL */
         301                 :            :     int c; /* last seen error from libc */
         302                 :            : #ifdef MS_WINDOWS
         303                 :            :     int ws; /* last seen error from winsock */
         304                 :            : #endif
         305                 :            : } _PySSLError;
         306                 :            :
         307                 :            : typedef struct {
         308                 :            :     PyObject_HEAD
         309                 :            :     PyObject *Socket; /* weakref to socket on which we're layered */
         310                 :            :     SSL *ssl;
         311                 :            :     PySSLContext *ctx; /* weakref to SSL context */
         312                 :            :     char shutdown_seen_zero;
         313                 :            :     enum py_ssl_server_or_client socket_type;
         314                 :            :     PyObject *owner; /* Python level "owner" passed to servername callback */
         315                 :            :     PyObject *server_hostname;
         316                 :            :     _PySSLError err; /* last seen error from various sources */
         317                 :            :     /* Some SSL callbacks don't have error reporting. Callback wrappers
         318                 :            :      * store exception information on the socket. The handshake, read, write,
         319                 :            :      * and shutdown methods check for chained exceptions.
         320                 :            :      */
         321                 :            :     PyObject *exc;
         322                 :            : } PySSLSocket;
         323                 :            :
         324                 :            : typedef struct {
         325                 :            :     PyObject_HEAD
         326                 :            :     BIO *bio;
         327                 :            :     int eof_written;
         328                 :            : } PySSLMemoryBIO;
         329                 :            :
         330                 :            : typedef struct {
         331                 :            :     PyObject_HEAD
         332                 :            :     SSL_SESSION *session;
         333                 :            :     PySSLContext *ctx;
         334                 :            : } PySSLSession;
         335                 :            :
         336                 :          0 : static inline _PySSLError _PySSL_errno(int failed, const SSL *ssl, int retcode)
         337                 :            : {
         338                 :          0 :     _PySSLError err = { 0 };
         339         [ #  # ]:          0 :     if (failed) {
         340                 :            : #ifdef MS_WINDOWS
         341                 :            :         err.ws = WSAGetLastError();
         342                 :            :         _PySSL_FIX_ERRNO;
         343                 :            : #endif
         344                 :          0 :         err.c = errno;
         345                 :          0 :         err.ssl = SSL_get_error(ssl, retcode);
         346                 :            :     }
         347                 :          0 :     return err;
         348                 :            : }
         349                 :            :
         350                 :            : /*[clinic input]
         351                 :            : module _ssl
         352                 :            : class _ssl._SSLContext "PySSLContext *" "get_state_type(type)->PySSLContext_Type"
         353                 :            : class _ssl._SSLSocket "PySSLSocket *" "get_state_type(type)->PySSLSocket_Type"
         354                 :            : class _ssl.MemoryBIO "PySSLMemoryBIO *" "get_state_type(type)->PySSLMemoryBIO_Type"
         355                 :            : class _ssl.SSLSession "PySSLSession *" "get_state_type(type)->PySSLSession_Type"
         356                 :            : [clinic start generated code]*/
         357                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=d293bed8bae240fd]*/
         358                 :            :
         359                 :            : #include "clinic/_ssl.c.h"
         360                 :            :
         361                 :            : static int PySSL_select(PySocketSockObject *s, int writing, _PyTime_t timeout);
         362                 :            :
         363                 :            : static int PySSL_set_owner(PySSLSocket *, PyObject *, void *);
         364                 :            : static int PySSL_set_session(PySSLSocket *, PyObject *, void *);
         365                 :            :
         366                 :            : typedef enum {
         367                 :            :     SOCKET_IS_NONBLOCKING,
         368                 :            :     SOCKET_IS_BLOCKING,
         369                 :            :     SOCKET_HAS_TIMED_OUT,
         370                 :            :     SOCKET_HAS_BEEN_CLOSED,
         371                 :            :     SOCKET_TOO_LARGE_FOR_SELECT,
         372                 :            :     SOCKET_OPERATION_OK
         373                 :            : } timeout_state;
         374                 :            :
         375                 :            : /* Wrap error strings with filename and line # */
         376                 :            : #define ERRSTR1(x,y,z) (x ":" y ": " z)
         377                 :            : #define ERRSTR(x) ERRSTR1("_ssl.c", Py_STRINGIFY(__LINE__), x)
         378                 :            :
         379                 :            : /* Get the socket from a PySSLSocket, if it has one */
         380                 :            : #define GET_SOCKET(obj) ((obj)->Socket ? \
         381                 :            :     (PySocketSockObject *) PyWeakref_GetObject((obj)->Socket) : NULL)
         382                 :            :
         383                 :            : /* If sock is NULL, use a timeout of 0 second */
         384                 :            : #define GET_SOCKET_TIMEOUT(sock) \
         385                 :            :     ((sock != NULL) ? (sock)->sock_timeout : 0)
         386                 :            :
         387                 :            : #include "_ssl/debughelpers.c"
         388                 :            :
         389                 :            : /*
         390                 :            :  * SSL errors.
         391                 :            :  */
         392                 :            :
         393                 :            : PyDoc_STRVAR(SSLError_doc,
         394                 :            : "An error occurred in the SSL implementation.");
         395                 :            :
         396                 :            : PyDoc_STRVAR(SSLCertVerificationError_doc,
         397                 :            : "A certificate could not be verified.");
         398                 :            :
         399                 :            : PyDoc_STRVAR(SSLZeroReturnError_doc,
         400                 :            : "SSL/TLS session closed cleanly.");
         401                 :            :
         402                 :            : PyDoc_STRVAR(SSLWantReadError_doc,
         403                 :            : "Non-blocking SSL socket needs to read more data\n"
         404                 :            : "before the requested operation can be completed.");
         405                 :            :
         406                 :            : PyDoc_STRVAR(SSLWantWriteError_doc,
         407                 :            : "Non-blocking SSL socket needs to write more data\n"
         408                 :            : "before the requested operation can be completed.");
         409                 :            :
         410                 :            : PyDoc_STRVAR(SSLSyscallError_doc,
         411                 :            : "System error when attempting SSL operation.");
         412                 :            :
         413                 :            : PyDoc_STRVAR(SSLEOFError_doc,
         414                 :            : "SSL/TLS connection terminated abruptly.");
         415                 :            :
         416                 :            : static PyObject *
         417                 :          0 : SSLError_str(PyOSErrorObject *self)
         418                 :            : {
         419   [ #  #  #  # ]:          0 :     if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {
         420                 :          0 :         return Py_NewRef(self->strerror);
         421                 :            :     }
         422                 :            :     else
         423                 :          0 :         return PyObject_Str(self->args);
         424                 :            : }
         425                 :            :
         426                 :            : static PyType_Slot sslerror_type_slots[] = {
         427                 :            :     {Py_tp_doc, (void*)SSLError_doc},
         428                 :            :     {Py_tp_str, SSLError_str},
         429                 :            :     {0, 0},
         430                 :            : };
         431                 :            :
         432                 :            : static PyType_Spec sslerror_type_spec = {
         433                 :            :     .name = "ssl.SSLError",
         434                 :            :     .basicsize = sizeof(PyOSErrorObject),
         435                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_IMMUTABLETYPE),
         436                 :            :     .slots = sslerror_type_slots
         437                 :            : };
         438                 :            :
         439                 :            : static void
         440                 :          0 : fill_and_set_sslerror(_sslmodulestate *state,
         441                 :            :                       PySSLSocket *sslsock, PyObject *type, int ssl_errno,
         442                 :            :                       const char *errstr, int lineno, unsigned long errcode)
         443                 :            : {
         444                 :          0 :     PyObject *err_value = NULL, *reason_obj = NULL, *lib_obj = NULL;
         445                 :          0 :     PyObject *verify_obj = NULL, *verify_code_obj = NULL;
         446                 :            :     PyObject *init_value, *msg, *key;
         447                 :            :
         448         [ #  # ]:          0 :     if (errcode != 0) {
         449                 :            :         int lib, reason;
         450                 :            :
         451                 :          0 :         lib = ERR_GET_LIB(errcode);
         452                 :          0 :         reason = ERR_GET_REASON(errcode);
         453                 :          0 :         key = Py_BuildValue("ii", lib, reason);
         454         [ #  # ]:          0 :         if (key == NULL)
         455                 :          0 :             goto fail;
         456                 :          0 :         reason_obj = PyDict_GetItemWithError(state->err_codes_to_names, key);
         457                 :          0 :         Py_DECREF(key);
         458   [ #  #  #  # ]:          0 :         if (reason_obj == NULL && PyErr_Occurred()) {
         459                 :          0 :             goto fail;
         460                 :            :         }
         461                 :          0 :         key = PyLong_FromLong(lib);
         462         [ #  # ]:          0 :         if (key == NULL)
         463                 :          0 :             goto fail;
         464                 :          0 :         lib_obj = PyDict_GetItemWithError(state->lib_codes_to_names, key);
         465                 :          0 :         Py_DECREF(key);
         466   [ #  #  #  # ]:          0 :         if (lib_obj == NULL && PyErr_Occurred()) {
         467                 :          0 :             goto fail;
         468                 :            :         }
         469         [ #  # ]:          0 :         if (errstr == NULL)
         470                 :          0 :             errstr = ERR_reason_error_string(errcode);
         471                 :            :     }
         472         [ #  # ]:          0 :     if (errstr == NULL)
         473                 :          0 :         errstr = "unknown error";
         474                 :            :
         475                 :            :     /* verify code for cert validation error */
         476   [ #  #  #  # ]:          0 :     if ((sslsock != NULL) && (type == state->PySSLCertVerificationErrorObject)) {
         477                 :          0 :         const char *verify_str = NULL;
         478                 :            :         long verify_code;
         479                 :            :
         480                 :          0 :         verify_code = SSL_get_verify_result(sslsock->ssl);
         481                 :          0 :         verify_code_obj = PyLong_FromLong(verify_code);
         482         [ #  # ]:          0 :         if (verify_code_obj == NULL) {
         483                 :          0 :             goto fail;
         484                 :            :         }
         485                 :            :
         486      [ #  #  # ]:          0 :         switch (verify_code) {
         487                 :          0 :         case X509_V_ERR_HOSTNAME_MISMATCH:
         488                 :          0 :             verify_obj = PyUnicode_FromFormat(
         489                 :            :                 "Hostname mismatch, certificate is not valid for '%S'.",
         490                 :            :                 sslsock->server_hostname
         491                 :            :             );
         492                 :          0 :             break;
         493                 :          0 :         case X509_V_ERR_IP_ADDRESS_MISMATCH:
         494                 :          0 :             verify_obj = PyUnicode_FromFormat(
         495                 :            :                 "IP address mismatch, certificate is not valid for '%S'.",
         496                 :            :                 sslsock->server_hostname
         497                 :            :             );
         498                 :          0 :             break;
         499                 :          0 :         default:
         500                 :          0 :             verify_str = X509_verify_cert_error_string(verify_code);
         501         [ #  # ]:          0 :             if (verify_str != NULL) {
         502                 :          0 :                 verify_obj = PyUnicode_FromString(verify_str);
         503                 :            :             } else {
         504                 :          0 :                 verify_obj = Py_NewRef(Py_None);
         505                 :            :             }
         506                 :          0 :             break;
         507                 :            :         }
         508         [ #  # ]:          0 :         if (verify_obj == NULL) {
         509                 :          0 :             goto fail;
         510                 :            :         }
         511                 :            :     }
         512                 :            :
         513   [ #  #  #  #  :          0 :     if (verify_obj && reason_obj && lib_obj)
                       #  # ]
         514                 :          0 :         msg = PyUnicode_FromFormat("[%S: %S] %s: %S (_ssl.c:%d)",
         515                 :            :                                    lib_obj, reason_obj, errstr, verify_obj,
         516                 :            :                                    lineno);
         517   [ #  #  #  # ]:          0 :     else if (reason_obj && lib_obj)
         518                 :          0 :         msg = PyUnicode_FromFormat("[%S: %S] %s (_ssl.c:%d)",
         519                 :            :                                    lib_obj, reason_obj, errstr, lineno);
         520         [ #  # ]:          0 :     else if (lib_obj)
         521                 :          0 :         msg = PyUnicode_FromFormat("[%S] %s (_ssl.c:%d)",
         522                 :            :                                    lib_obj, errstr, lineno);
         523                 :            :     else
         524                 :          0 :         msg = PyUnicode_FromFormat("%s (_ssl.c:%d)", errstr, lineno);
         525         [ #  # ]:          0 :     if (msg == NULL)
         526                 :          0 :         goto fail;
         527                 :            :
         528                 :          0 :     init_value = Py_BuildValue("iN", ERR_GET_REASON(ssl_errno), msg);
         529         [ #  # ]:          0 :     if (init_value == NULL)
         530                 :          0 :         goto fail;
         531                 :            :
         532                 :          0 :     err_value = PyObject_CallObject(type, init_value);
         533                 :          0 :     Py_DECREF(init_value);
         534         [ #  # ]:          0 :     if (err_value == NULL)
         535                 :          0 :         goto fail;
         536                 :            :
         537         [ #  # ]:          0 :     if (reason_obj == NULL)
         538                 :          0 :         reason_obj = Py_None;
         539         [ #  # ]:          0 :     if (PyObject_SetAttr(err_value, state->str_reason, reason_obj))
         540                 :          0 :         goto fail;
         541                 :            :
         542         [ #  # ]:          0 :     if (lib_obj == NULL)
         543                 :          0 :         lib_obj = Py_None;
         544         [ #  # ]:          0 :     if (PyObject_SetAttr(err_value, state->str_library, lib_obj))
         545                 :          0 :         goto fail;
         546                 :            :
         547   [ #  #  #  # ]:          0 :     if ((sslsock != NULL) && (type == state->PySSLCertVerificationErrorObject)) {
         548                 :            :         /* Only set verify code / message for SSLCertVerificationError */
         549         [ #  # ]:          0 :         if (PyObject_SetAttr(err_value, state->str_verify_code,
         550                 :            :                                 verify_code_obj))
         551                 :          0 :             goto fail;
         552         [ #  # ]:          0 :         if (PyObject_SetAttr(err_value, state->str_verify_message, verify_obj))
         553                 :          0 :             goto fail;
         554                 :            :     }
         555                 :            :
         556                 :          0 :     PyErr_SetObject(type, err_value);
         557                 :          0 : fail:
         558                 :          0 :     Py_XDECREF(err_value);
         559                 :          0 :     Py_XDECREF(verify_code_obj);
         560                 :          0 :     Py_XDECREF(verify_obj);
         561                 :          0 : }
         562                 :            :
         563                 :            : static int
         564                 :          0 : PySSL_ChainExceptions(PySSLSocket *sslsock) {
         565         [ #  # ]:          0 :     if (sslsock->exc == NULL)
         566                 :          0 :         return 0;
         567                 :            :
         568                 :          0 :     _PyErr_ChainExceptions1(sslsock->exc);
         569                 :          0 :     sslsock->exc = NULL;
         570                 :          0 :     return -1;
         571                 :            : }
         572                 :            :
         573                 :            : static PyObject *
         574                 :          0 : PySSL_SetError(PySSLSocket *sslsock, int ret, const char *filename, int lineno)
         575                 :            : {
         576                 :            :     PyObject *type;
         577                 :          0 :     char *errstr = NULL;
         578                 :            :     _PySSLError err;
         579                 :          0 :     enum py_ssl_error p = PY_SSL_ERROR_NONE;
         580                 :          0 :     unsigned long e = 0;
         581                 :            :
         582                 :            :     assert(sslsock != NULL);
         583                 :            :
         584                 :          0 :     _sslmodulestate *state = get_state_sock(sslsock);
         585                 :          0 :     type = state->PySSLErrorObject;
         586                 :            :
         587                 :            :     assert(ret <= 0);
         588                 :          0 :     e = ERR_peek_last_error();
         589                 :            :
         590         [ #  # ]:          0 :     if (sslsock->ssl != NULL) {
         591                 :          0 :         err = sslsock->err;
         592                 :            :
         593   [ #  #  #  #  :          0 :         switch (err.ssl) {
                 #  #  #  # ]
         594                 :          0 :         case SSL_ERROR_ZERO_RETURN:
         595                 :          0 :             errstr = "TLS/SSL connection has been closed (EOF)";
         596                 :          0 :             type = state->PySSLZeroReturnErrorObject;
         597                 :          0 :             p = PY_SSL_ERROR_ZERO_RETURN;
         598                 :          0 :             break;
         599                 :          0 :         case SSL_ERROR_WANT_READ:
         600                 :          0 :             errstr = "The operation did not complete (read)";
         601                 :          0 :             type = state->PySSLWantReadErrorObject;
         602                 :          0 :             p = PY_SSL_ERROR_WANT_READ;
         603                 :          0 :             break;
         604                 :          0 :         case SSL_ERROR_WANT_WRITE:
         605                 :          0 :             p = PY_SSL_ERROR_WANT_WRITE;
         606                 :          0 :             type = state->PySSLWantWriteErrorObject;
         607                 :          0 :             errstr = "The operation did not complete (write)";
         608                 :          0 :             break;
         609                 :          0 :         case SSL_ERROR_WANT_X509_LOOKUP:
         610                 :          0 :             p = PY_SSL_ERROR_WANT_X509_LOOKUP;
         611                 :          0 :             errstr = "The operation did not complete (X509 lookup)";
         612                 :          0 :             break;
         613                 :          0 :         case SSL_ERROR_WANT_CONNECT:
         614                 :          0 :             p = PY_SSL_ERROR_WANT_CONNECT;
         615                 :          0 :             errstr = "The operation did not complete (connect)";
         616                 :          0 :             break;
         617                 :          0 :         case SSL_ERROR_SYSCALL:
         618                 :            :         {
         619         [ #  # ]:          0 :             if (e == 0) {
         620         [ #  # ]:          0 :                 PySocketSockObject *s = GET_SOCKET(sslsock);
         621   [ #  #  #  # ]:          0 :                 if (ret == 0 || (((PyObject *)s) == Py_None)) {
         622                 :          0 :                     p = PY_SSL_ERROR_EOF;
         623                 :          0 :                     type = state->PySSLEOFErrorObject;
         624                 :          0 :                     errstr = "EOF occurred in violation of protocol";
         625   [ #  #  #  # ]:          0 :                 } else if (s && ret == -1) {
         626                 :            :                     /* underlying BIO reported an I/O error */
         627                 :          0 :                     ERR_clear_error();
         628                 :            : #ifdef MS_WINDOWS
         629                 :            :                     if (err.ws) {
         630                 :            :                         return PyErr_SetFromWindowsErr(err.ws);
         631                 :            :                     }
         632                 :            : #endif
         633         [ #  # ]:          0 :                     if (err.c) {
         634                 :          0 :                         errno = err.c;
         635                 :          0 :                         return PyErr_SetFromErrno(PyExc_OSError);
         636                 :            :                     }
         637                 :            :                     else {
         638                 :          0 :                         p = PY_SSL_ERROR_EOF;
         639                 :          0 :                         type = state->PySSLEOFErrorObject;
         640                 :          0 :                         errstr = "EOF occurred in violation of protocol";
         641                 :            :                     }
         642                 :            :                 } else { /* possible? */
         643                 :          0 :                     p = PY_SSL_ERROR_SYSCALL;
         644                 :          0 :                     type = state->PySSLSyscallErrorObject;
         645                 :          0 :                     errstr = "Some I/O error occurred";
         646                 :            :                 }
         647                 :            :             } else {
         648                 :          0 :                 p = PY_SSL_ERROR_SYSCALL;
         649                 :            :             }
         650                 :          0 :             break;
         651                 :            :         }
         652                 :          0 :         case SSL_ERROR_SSL:
         653                 :            :         {
         654                 :          0 :             p = PY_SSL_ERROR_SSL;
         655         [ #  # ]:          0 :             if (e == 0) {
         656                 :            :                 /* possible? */
         657                 :          0 :                 errstr = "A failure in the SSL library occurred";
         658                 :            :             }
         659         [ #  # ]:          0 :             if (ERR_GET_LIB(e) == ERR_LIB_SSL &&
         660         [ #  # ]:          0 :                     ERR_GET_REASON(e) == SSL_R_CERTIFICATE_VERIFY_FAILED) {
         661                 :          0 :                 type = state->PySSLCertVerificationErrorObject;
         662                 :            :             }
         663                 :          0 :             break;
         664                 :            :         }
         665                 :          0 :         default:
         666                 :          0 :             p = PY_SSL_ERROR_INVALID_ERROR_CODE;
         667                 :          0 :             errstr = "Invalid error code";
         668                 :            :         }
         669                 :          0 :     }
         670                 :          0 :     fill_and_set_sslerror(state, sslsock, type, p, errstr, lineno, e);
         671                 :          0 :     ERR_clear_error();
         672                 :          0 :     PySSL_ChainExceptions(sslsock);
         673                 :          0 :     return NULL;
         674                 :            : }
         675                 :            :
         676                 :            : static PyObject *
         677                 :          0 : _setSSLError (_sslmodulestate *state, const char *errstr, int errcode, const char *filename, int lineno)
         678                 :            : {
         679         [ #  # ]:          0 :     if (errstr == NULL)
         680                 :          0 :         errcode = ERR_peek_last_error();
         681                 :            :     else
         682                 :          0 :         errcode = 0;
         683                 :          0 :     fill_and_set_sslerror(state, NULL, state->PySSLErrorObject, errcode, errstr, lineno, errcode);
         684                 :          0 :     ERR_clear_error();
         685                 :          0 :     return NULL;
         686                 :            : }
         687                 :            :
         688                 :            : static int
         689                 :          0 : _ssl_deprecated(const char* msg, int stacklevel) {
         690                 :          0 :     return PyErr_WarnEx(
         691                 :            :         PyExc_DeprecationWarning, msg, stacklevel
         692                 :            :     );
         693                 :            : }
         694                 :            :
         695                 :            : #define PY_SSL_DEPRECATED(name, stacklevel, ret) \
         696                 :            :     if (_ssl_deprecated((name), (stacklevel)) == -1) return (ret)
         697                 :            :
         698                 :            : /*
         699                 :            :  * SSL objects
         700                 :            :  */
         701                 :            :
         702                 :            : static int
         703                 :          0 : _ssl_configure_hostname(PySSLSocket *self, const char* server_hostname)
         704                 :            : {
         705                 :          0 :     int retval = -1;
         706                 :            :     ASN1_OCTET_STRING *ip;
         707                 :            :     PyObject *hostname;
         708                 :            :     size_t len;
         709                 :            :
         710                 :            :     assert(server_hostname);
         711                 :            :
         712                 :            :     /* Disable OpenSSL's special mode with leading dot in hostname:
         713                 :            :      * When name starts with a dot (e.g ".example.com"), it will be
         714                 :            :      * matched by a certificate valid for any sub-domain of name.
         715                 :            :      */
         716                 :          0 :     len = strlen(server_hostname);
         717   [ #  #  #  # ]:          0 :     if (len == 0 || *server_hostname == '.') {
         718                 :          0 :         PyErr_SetString(
         719                 :            :             PyExc_ValueError,
         720                 :            :             "server_hostname cannot be an empty string or start with a "
         721                 :            :             "leading dot.");
         722                 :          0 :         return retval;
         723                 :            :     }
         724                 :            :
         725                 :            :     /* inet_pton is not available on all platforms. */
         726                 :          0 :     ip = a2i_IPADDRESS(server_hostname);
         727         [ #  # ]:          0 :     if (ip == NULL) {
         728                 :          0 :         ERR_clear_error();
         729                 :            :     }
         730                 :            :
         731                 :          0 :     hostname = PyUnicode_Decode(server_hostname, len, "ascii", "strict");
         732         [ #  # ]:          0 :     if (hostname == NULL) {
         733                 :          0 :         goto error;
         734                 :            :     }
         735                 :          0 :     self->server_hostname = hostname;
         736                 :            :
         737                 :            :     /* Only send SNI extension for non-IP hostnames */
         738         [ #  # ]:          0 :     if (ip == NULL) {
         739         [ #  # ]:          0 :         if (!SSL_set_tlsext_host_name(self->ssl, server_hostname)) {
         740                 :          0 :             _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
         741                 :          0 :             goto error;
         742                 :            :         }
         743                 :            :     }
         744         [ #  # ]:          0 :     if (self->ctx->check_hostname) {
         745                 :          0 :         X509_VERIFY_PARAM *param = SSL_get0_param(self->ssl);
         746         [ #  # ]:          0 :         if (ip == NULL) {
         747         [ #  # ]:          0 :             if (!X509_VERIFY_PARAM_set1_host(param, server_hostname,
         748                 :            :                                              strlen(server_hostname))) {
         749                 :          0 :                 _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
         750                 :          0 :                 goto error;
         751                 :            :             }
         752                 :            :         } else {
         753         [ #  # ]:          0 :             if (!X509_VERIFY_PARAM_set1_ip(param, ASN1_STRING_get0_data(ip),
         754                 :          0 :                                            ASN1_STRING_length(ip))) {
         755                 :          0 :                 _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
         756                 :          0 :                 goto error;
         757                 :            :             }
         758                 :            :         }
         759                 :            :     }
         760                 :          0 :     retval = 0;
         761                 :          0 :   error:
         762         [ #  # ]:          0 :     if (ip != NULL) {
         763                 :          0 :         ASN1_OCTET_STRING_free(ip);
         764                 :            :     }
         765                 :          0 :     return retval;
         766                 :            : }
         767                 :            :
         768                 :            : static PySSLSocket *
         769                 :          0 : newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
         770                 :            :                enum py_ssl_server_or_client socket_type,
         771                 :            :                char *server_hostname,
         772                 :            :                PyObject *owner, PyObject *session,
         773                 :            :                PySSLMemoryBIO *inbio, PySSLMemoryBIO *outbio)
         774                 :            : {
         775                 :            :     PySSLSocket *self;
         776                 :          0 :     SSL_CTX *ctx = sslctx->ctx;
         777                 :          0 :     _PySSLError err = { 0 };
         778                 :            :
         779         [ #  # ]:          0 :     if ((socket_type == PY_SSL_SERVER) &&
         780         [ #  # ]:          0 :         (sslctx->protocol == PY_SSL_VERSION_TLS_CLIENT)) {
         781                 :          0 :         _setSSLError(get_state_ctx(sslctx),
         782                 :            :                      "Cannot create a server socket with a "
         783                 :            :                      "PROTOCOL_TLS_CLIENT context", 0, __FILE__, __LINE__);
         784                 :          0 :         return NULL;
         785                 :            :     }
         786         [ #  # ]:          0 :     if ((socket_type == PY_SSL_CLIENT) &&
         787         [ #  # ]:          0 :         (sslctx->protocol == PY_SSL_VERSION_TLS_SERVER)) {
         788                 :          0 :         _setSSLError(get_state_ctx(sslctx),
         789                 :            :                      "Cannot create a client socket with a "
         790                 :            :                      "PROTOCOL_TLS_SERVER context", 0, __FILE__, __LINE__);
         791                 :          0 :         return NULL;
         792                 :            :     }
         793                 :            :
         794                 :          0 :     self = PyObject_GC_New(PySSLSocket,
         795                 :            :                            get_state_ctx(sslctx)->PySSLSocket_Type);
         796         [ #  # ]:          0 :     if (self == NULL)
         797                 :          0 :         return NULL;
         798                 :            :
         799                 :          0 :     self->ssl = NULL;
         800                 :          0 :     self->Socket = NULL;
         801                 :          0 :     self->ctx = (PySSLContext*)Py_NewRef(sslctx);
         802                 :          0 :     self->shutdown_seen_zero = 0;
         803                 :          0 :     self->owner = NULL;
         804                 :          0 :     self->server_hostname = NULL;
         805                 :          0 :     self->err = err;
         806                 :          0 :     self->exc = NULL;
         807                 :            :
         808                 :            :     /* Make sure the SSL error state is initialized */
         809                 :          0 :     ERR_clear_error();
         810                 :            :
         811                 :          0 :     PySSL_BEGIN_ALLOW_THREADS
         812                 :          0 :     self->ssl = SSL_new(ctx);
         813                 :          0 :     PySSL_END_ALLOW_THREADS
         814         [ #  # ]:          0 :     if (self->ssl == NULL) {
         815                 :          0 :         Py_DECREF(self);
         816                 :          0 :         _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
         817                 :          0 :         return NULL;
         818                 :            :     }
         819                 :            :     /* bpo43522 and OpenSSL < 1.1.1l: copy hostflags manually */
         820                 :            : #if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION < 0x101010cf
         821                 :          0 :     X509_VERIFY_PARAM *ssl_params = SSL_get0_param(self->ssl);
         822                 :          0 :     X509_VERIFY_PARAM_set_hostflags(ssl_params, sslctx->hostflags);
         823                 :            : #endif
         824                 :          0 :     SSL_set_app_data(self->ssl, self);
         825         [ #  # ]:          0 :     if (sock) {
         826                 :          0 :         SSL_set_fd(self->ssl, Py_SAFE_DOWNCAST(sock->sock_fd, SOCKET_T, int));
         827                 :            :     } else {
         828                 :            :         /* BIOs are reference counted and SSL_set_bio borrows our reference.
         829                 :            :          * To prevent a double free in memory_bio_dealloc() we need to take an
         830                 :            :          * extra reference here. */
         831                 :          0 :         BIO_up_ref(inbio->bio);
         832                 :          0 :         BIO_up_ref(outbio->bio);
         833                 :          0 :         SSL_set_bio(self->ssl, inbio->bio, outbio->bio);
         834                 :            :     }
         835                 :          0 :     SSL_set_mode(self->ssl,
         836                 :            :                  SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER | SSL_MODE_AUTO_RETRY);
         837                 :            :
         838                 :            : #ifdef TLS1_3_VERSION
         839         [ #  # ]:          0 :     if (sslctx->post_handshake_auth == 1) {
         840         [ #  # ]:          0 :         if (socket_type == PY_SSL_SERVER) {
         841                 :            :             /* bpo-37428: OpenSSL does not ignore SSL_VERIFY_POST_HANDSHAKE.
         842                 :            :              * Set SSL_VERIFY_POST_HANDSHAKE flag only for server sockets and
         843                 :            :              * only in combination with SSL_VERIFY_PEER flag. */
         844                 :          0 :             int mode = SSL_get_verify_mode(self->ssl);
         845         [ #  # ]:          0 :             if (mode & SSL_VERIFY_PEER) {
         846                 :          0 :                 int (*verify_cb)(int, X509_STORE_CTX *) = NULL;
         847                 :          0 :                 verify_cb = SSL_get_verify_callback(self->ssl);
         848                 :          0 :                 mode |= SSL_VERIFY_POST_HANDSHAKE;
         849                 :          0 :                 SSL_set_verify(self->ssl, mode, verify_cb);
         850                 :            :             }
         851                 :            :         } else {
         852                 :            :             /* client socket */
         853                 :          0 :             SSL_set_post_handshake_auth(self->ssl, 1);
         854                 :            :         }
         855                 :            :     }
         856                 :            : #endif
         857                 :            :
         858         [ #  # ]:          0 :     if (server_hostname != NULL) {
         859         [ #  # ]:          0 :         if (_ssl_configure_hostname(self, server_hostname) < 0) {
         860                 :          0 :             Py_DECREF(self);
         861                 :          0 :             return NULL;
         862                 :            :         }
         863                 :            :     }
         864                 :            :     /* If the socket is in non-blocking mode or timeout mode, set the BIO
         865                 :            :      * to non-blocking mode (blocking is the default)
         866                 :            :      */
         867   [ #  #  #  # ]:          0 :     if (sock && sock->sock_timeout >= 0) {
         868                 :          0 :         BIO_set_nbio(SSL_get_rbio(self->ssl), 1);
         869                 :          0 :         BIO_set_nbio(SSL_get_wbio(self->ssl), 1);
         870                 :            :     }
         871                 :            :
         872                 :          0 :     PySSL_BEGIN_ALLOW_THREADS
         873         [ #  # ]:          0 :     if (socket_type == PY_SSL_CLIENT)
         874                 :          0 :         SSL_set_connect_state(self->ssl);
         875                 :            :     else
         876                 :          0 :         SSL_set_accept_state(self->ssl);
         877                 :          0 :     PySSL_END_ALLOW_THREADS
         878                 :            :
         879                 :          0 :     self->socket_type = socket_type;
         880         [ #  # ]:          0 :     if (sock != NULL) {
         881                 :          0 :         self->Socket = PyWeakref_NewRef((PyObject *) sock, NULL);
         882         [ #  # ]:          0 :         if (self->Socket == NULL) {
         883                 :          0 :             Py_DECREF(self);
         884                 :          0 :             return NULL;
         885                 :            :         }
         886                 :            :     }
         887   [ #  #  #  # ]:          0 :     if (owner && owner != Py_None) {
         888         [ #  # ]:          0 :         if (PySSL_set_owner(self, owner, NULL) == -1) {
         889                 :          0 :             Py_DECREF(self);
         890                 :          0 :             return NULL;
         891                 :            :         }
         892                 :            :     }
         893   [ #  #  #  # ]:          0 :     if (session && session != Py_None) {
         894         [ #  # ]:          0 :         if (PySSL_set_session(self, session, NULL) == -1) {
         895                 :          0 :             Py_DECREF(self);
         896                 :          0 :             return NULL;
         897                 :            :         }
         898                 :            :     }
         899                 :            :
         900                 :          0 :     PyObject_GC_Track(self);
         901                 :          0 :     return self;
         902                 :            : }
         903                 :            :
         904                 :            : /* SSL object methods */
         905                 :            :
         906                 :            : /*[clinic input]
         907                 :            : _ssl._SSLSocket.do_handshake
         908                 :            : [clinic start generated code]*/
         909                 :            :
         910                 :            : static PyObject *
         911                 :          0 : _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self)
         912                 :            : /*[clinic end generated code: output=6c0898a8936548f6 input=d2d737de3df018c8]*/
         913                 :            : {
         914                 :            :     int ret;
         915                 :            :     _PySSLError err;
         916                 :            :     int sockstate, nonblocking;
         917         [ #  # ]:          0 :     PySocketSockObject *sock = GET_SOCKET(self);
         918                 :          0 :     _PyTime_t timeout, deadline = 0;
         919                 :            :     int has_timeout;
         920                 :            :
         921         [ #  # ]:          0 :     if (sock) {
         922         [ #  # ]:          0 :         if (((PyObject*)sock) == Py_None) {
         923                 :          0 :             _setSSLError(get_state_sock(self),
         924                 :            :                          "Underlying socket connection gone",
         925                 :            :                          PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);
         926                 :          0 :             return NULL;
         927                 :            :         }
         928                 :          0 :         Py_INCREF(sock);
         929                 :            :
         930                 :            :         /* just in case the blocking state of the socket has been changed */
         931                 :          0 :         nonblocking = (sock->sock_timeout >= 0);
         932                 :          0 :         BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
         933                 :          0 :         BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
         934                 :            :     }
         935                 :            :
         936         [ #  # ]:          0 :     timeout = GET_SOCKET_TIMEOUT(sock);
         937                 :          0 :     has_timeout = (timeout > 0);
         938         [ #  # ]:          0 :     if (has_timeout) {
         939                 :          0 :         deadline = _PyDeadline_Init(timeout);
         940                 :            :     }
         941                 :            :
         942                 :            :     /* Actually negotiate SSL connection */
         943                 :            :     /* XXX If SSL_do_handshake() returns 0, it's also a failure. */
         944                 :            :     do {
         945                 :          0 :         PySSL_BEGIN_ALLOW_THREADS
         946                 :          0 :         ret = SSL_do_handshake(self->ssl);
         947                 :          0 :         err = _PySSL_errno(ret < 1, self->ssl, ret);
         948                 :          0 :         PySSL_END_ALLOW_THREADS
         949                 :          0 :         self->err = err;
         950                 :            :
         951         [ #  # ]:          0 :         if (PyErr_CheckSignals())
         952                 :          0 :             goto error;
         953                 :            :
         954         [ #  # ]:          0 :         if (has_timeout)
         955                 :          0 :             timeout = _PyDeadline_Get(deadline);
         956                 :            :
         957         [ #  # ]:          0 :         if (err.ssl == SSL_ERROR_WANT_READ) {
         958                 :          0 :             sockstate = PySSL_select(sock, 0, timeout);
         959         [ #  # ]:          0 :         } else if (err.ssl == SSL_ERROR_WANT_WRITE) {
         960                 :          0 :             sockstate = PySSL_select(sock, 1, timeout);
         961                 :            :         } else {
         962                 :          0 :             sockstate = SOCKET_OPERATION_OK;
         963                 :            :         }
         964                 :            :
         965         [ #  # ]:          0 :         if (sockstate == SOCKET_HAS_TIMED_OUT) {
         966                 :          0 :             PyErr_SetString(PyExc_TimeoutError,
         967                 :            :                             ERRSTR("The handshake operation timed out"));
         968                 :          0 :             goto error;
         969         [ #  # ]:          0 :         } else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
         970                 :          0 :             PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
         971                 :            :                             ERRSTR("Underlying socket has been closed."));
         972                 :          0 :             goto error;
         973         [ #  # ]:          0 :         } else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {
         974                 :          0 :             PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
         975                 :            :                             ERRSTR("Underlying socket too large for select()."));
         976                 :          0 :             goto error;
         977         [ #  # ]:          0 :         } else if (sockstate == SOCKET_IS_NONBLOCKING) {
         978                 :          0 :             break;
         979                 :            :         }
         980                 :          0 :     } while (err.ssl == SSL_ERROR_WANT_READ ||
         981   [ #  #  #  # ]:          0 :              err.ssl == SSL_ERROR_WANT_WRITE);
         982                 :          0 :     Py_XDECREF(sock);
         983         [ #  # ]:          0 :     if (ret < 1)
         984                 :          0 :         return PySSL_SetError(self, ret, __FILE__, __LINE__);
         985         [ #  # ]:          0 :     if (PySSL_ChainExceptions(self) < 0)
         986                 :          0 :         return NULL;
         987                 :          0 :     Py_RETURN_NONE;
         988                 :          0 : error:
         989                 :          0 :     Py_XDECREF(sock);
         990                 :          0 :     PySSL_ChainExceptions(self);
         991                 :          0 :     return NULL;
         992                 :            : }
         993                 :            :
         994                 :            : static PyObject *
         995                 :          4 : _asn1obj2py(_sslmodulestate *state, const ASN1_OBJECT *name, int no_name)
         996                 :            : {
         997                 :            :     char buf[X509_NAME_MAXLEN];
         998                 :          4 :     char *namebuf = buf;
         999                 :            :     int buflen;
        1000                 :          4 :     PyObject *name_obj = NULL;
        1001                 :            :
        1002                 :          4 :     buflen = OBJ_obj2txt(namebuf, X509_NAME_MAXLEN, name, no_name);
        1003         [ -  + ]:          4 :     if (buflen < 0) {
        1004                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1005                 :          0 :         return NULL;
        1006                 :            :     }
        1007                 :            :     /* initial buffer is too small for oid + terminating null byte */
        1008         [ -  + ]:          4 :     if (buflen > X509_NAME_MAXLEN - 1) {
        1009                 :            :         /* make OBJ_obj2txt() calculate the required buflen */
        1010                 :          0 :         buflen = OBJ_obj2txt(NULL, 0, name, no_name);
        1011                 :            :         /* allocate len + 1 for terminating NULL byte */
        1012                 :          0 :         namebuf = PyMem_Malloc(buflen + 1);
        1013         [ #  # ]:          0 :         if (namebuf == NULL) {
        1014                 :          0 :             PyErr_NoMemory();
        1015                 :          0 :             return NULL;
        1016                 :            :         }
        1017                 :          0 :         buflen = OBJ_obj2txt(namebuf, buflen + 1, name, no_name);
        1018         [ #  # ]:          0 :         if (buflen < 0) {
        1019                 :          0 :             _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1020                 :          0 :             goto done;
        1021                 :            :         }
        1022                 :            :     }
        1023   [ -  +  -  - ]:          4 :     if (!buflen && no_name) {
        1024                 :          0 :         name_obj = Py_NewRef(Py_None);
        1025                 :            :     }
        1026                 :            :     else {
        1027                 :          4 :         name_obj = PyUnicode_FromStringAndSize(namebuf, buflen);
        1028                 :            :     }
        1029                 :            :
        1030                 :          4 :   done:
        1031         [ -  + ]:          4 :     if (buf != namebuf) {
        1032                 :          0 :         PyMem_Free(namebuf);
        1033                 :            :     }
        1034                 :          4 :     return name_obj;
        1035                 :            : }
        1036                 :            :
        1037                 :            : static PyObject *
        1038                 :          0 : _create_tuple_for_attribute(_sslmodulestate *state,
        1039                 :            :                             ASN1_OBJECT *name, ASN1_STRING *value)
        1040                 :            : {
        1041                 :            :     Py_ssize_t buflen;
        1042                 :            :     PyObject *pyattr;
        1043                 :          0 :     PyObject *pyname = _asn1obj2py(state, name, 0);
        1044                 :            :
        1045         [ #  # ]:          0 :     if (pyname == NULL) {
        1046                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1047                 :          0 :         return NULL;
        1048                 :            :     }
        1049                 :            :
        1050         [ #  # ]:          0 :     if (ASN1_STRING_type(value) == V_ASN1_BIT_STRING) {
        1051                 :          0 :         buflen = ASN1_STRING_length(value);
        1052                 :          0 :         pyattr = Py_BuildValue("Ny#", pyname, ASN1_STRING_get0_data(value), buflen);
        1053                 :            :     } else {
        1054                 :          0 :         unsigned char *valuebuf = NULL;
        1055                 :          0 :         buflen = ASN1_STRING_to_UTF8(&valuebuf, value);
        1056         [ #  # ]:          0 :         if (buflen < 0) {
        1057                 :          0 :             _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1058                 :          0 :             Py_DECREF(pyname);
        1059                 :          0 :             return NULL;
        1060                 :            :         }
        1061                 :          0 :         pyattr = Py_BuildValue("Ns#", pyname, valuebuf, buflen);
        1062                 :          0 :         OPENSSL_free(valuebuf);
        1063                 :            :     }
        1064                 :          0 :     return pyattr;
        1065                 :            : }
        1066                 :            :
        1067                 :            : static PyObject *
        1068                 :          0 : _create_tuple_for_X509_NAME (_sslmodulestate *state, X509_NAME *xname)
        1069                 :            : {
        1070                 :          0 :     PyObject *dn = NULL;    /* tuple which represents the "distinguished name" */
        1071                 :          0 :     PyObject *rdn = NULL;   /* tuple to hold a "relative distinguished name" */
        1072                 :            :     PyObject *rdnt;
        1073                 :          0 :     PyObject *attr = NULL;   /* tuple to hold an attribute */
        1074                 :          0 :     int entry_count = X509_NAME_entry_count(xname);
        1075                 :            :     X509_NAME_ENTRY *entry;
        1076                 :            :     ASN1_OBJECT *name;
        1077                 :            :     ASN1_STRING *value;
        1078                 :            :     int index_counter;
        1079                 :          0 :     int rdn_level = -1;
        1080                 :            :     int retcode;
        1081                 :            :
        1082                 :          0 :     dn = PyList_New(0);
        1083         [ #  # ]:          0 :     if (dn == NULL)
        1084                 :          0 :         return NULL;
        1085                 :            :     /* now create another tuple to hold the top-level RDN */
        1086                 :          0 :     rdn = PyList_New(0);
        1087         [ #  # ]:          0 :     if (rdn == NULL)
        1088                 :          0 :         goto fail0;
        1089                 :            :
        1090         [ #  # ]:          0 :     for (index_counter = 0;
        1091                 :            :          index_counter < entry_count;
        1092                 :          0 :          index_counter++)
        1093                 :            :     {
        1094                 :          0 :         entry = X509_NAME_get_entry(xname, index_counter);
        1095                 :            :
        1096                 :            :         /* check to see if we've gotten to a new RDN */
        1097         [ #  # ]:          0 :         if (rdn_level >= 0) {
        1098         [ #  # ]:          0 :             if (rdn_level != X509_NAME_ENTRY_set(entry)) {
        1099                 :            :                 /* yes, new RDN */
        1100                 :            :                 /* add old RDN to DN */
        1101                 :          0 :                 rdnt = PyList_AsTuple(rdn);
        1102                 :          0 :                 Py_DECREF(rdn);
        1103         [ #  # ]:          0 :                 if (rdnt == NULL)
        1104                 :          0 :                     goto fail0;
        1105                 :          0 :                 retcode = PyList_Append(dn, rdnt);
        1106                 :          0 :                 Py_DECREF(rdnt);
        1107         [ #  # ]:          0 :                 if (retcode < 0)
        1108                 :          0 :                     goto fail0;
        1109                 :            :                 /* create new RDN */
        1110                 :          0 :                 rdn = PyList_New(0);
        1111         [ #  # ]:          0 :                 if (rdn == NULL)
        1112                 :          0 :                     goto fail0;
        1113                 :            :             }
        1114                 :            :         }
        1115                 :          0 :         rdn_level = X509_NAME_ENTRY_set(entry);
        1116                 :            :
        1117                 :            :         /* now add this attribute to the current RDN */
        1118                 :          0 :         name = X509_NAME_ENTRY_get_object(entry);
        1119                 :          0 :         value = X509_NAME_ENTRY_get_data(entry);
        1120                 :          0 :         attr = _create_tuple_for_attribute(state, name, value);
        1121                 :            :         /*
        1122                 :            :         fprintf(stderr, "RDN level %d, attribute %s: %s\n",
        1123                 :            :             entry->set,
        1124                 :            :             PyBytes_AS_STRING(PyTuple_GET_ITEM(attr, 0)),
        1125                 :            :             PyBytes_AS_STRING(PyTuple_GET_ITEM(attr, 1)));
        1126                 :            :         */
        1127         [ #  # ]:          0 :         if (attr == NULL)
        1128                 :          0 :             goto fail1;
        1129                 :          0 :         retcode = PyList_Append(rdn, attr);
        1130                 :          0 :         Py_DECREF(attr);
        1131         [ #  # ]:          0 :         if (retcode < 0)
        1132                 :          0 :             goto fail1;
        1133                 :            :     }
        1134                 :            :     /* now, there's typically a dangling RDN */
        1135         [ #  # ]:          0 :     if (rdn != NULL) {
        1136         [ #  # ]:          0 :         if (PyList_GET_SIZE(rdn) > 0) {
        1137                 :          0 :             rdnt = PyList_AsTuple(rdn);
        1138                 :          0 :             Py_DECREF(rdn);
        1139         [ #  # ]:          0 :             if (rdnt == NULL)
        1140                 :          0 :                 goto fail0;
        1141                 :          0 :             retcode = PyList_Append(dn, rdnt);
        1142                 :          0 :             Py_DECREF(rdnt);
        1143         [ #  # ]:          0 :             if (retcode < 0)
        1144                 :          0 :                 goto fail0;
        1145                 :            :         }
        1146                 :            :         else {
        1147                 :          0 :             Py_DECREF(rdn);
        1148                 :            :         }
        1149                 :            :     }
        1150                 :            :
        1151                 :            :     /* convert list to tuple */
        1152                 :          0 :     rdnt = PyList_AsTuple(dn);
        1153                 :          0 :     Py_DECREF(dn);
        1154         [ #  # ]:          0 :     if (rdnt == NULL)
        1155                 :          0 :         return NULL;
        1156                 :          0 :     return rdnt;
        1157                 :            :
        1158                 :          0 :   fail1:
        1159                 :          0 :     Py_XDECREF(rdn);
        1160                 :            :
        1161                 :          0 :   fail0:
        1162                 :          0 :     Py_XDECREF(dn);
        1163                 :          0 :     return NULL;
        1164                 :            : }
        1165                 :            :
        1166                 :            : static PyObject *
        1167                 :          0 : _get_peer_alt_names (_sslmodulestate *state, X509 *certificate) {
        1168                 :            :
        1169                 :            :     /* this code follows the procedure outlined in
        1170                 :            :        OpenSSL's crypto/x509v3/v3_prn.c:X509v3_EXT_print()
        1171                 :            :        function to extract the STACK_OF(GENERAL_NAME),
        1172                 :            :        then iterates through the stack to add the
        1173                 :            :        names. */
        1174                 :            :
        1175                 :            :     int j;
        1176                 :          0 :     PyObject *peer_alt_names = Py_None;
        1177                 :          0 :     PyObject *v = NULL, *t;
        1178                 :          0 :     GENERAL_NAMES *names = NULL;
        1179                 :            :     GENERAL_NAME *name;
        1180                 :          0 :     BIO *biobuf = NULL;
        1181                 :            :     char buf[2048];
        1182                 :            :     char *vptr;
        1183                 :            :     int len;
        1184                 :            :
        1185         [ #  # ]:          0 :     if (certificate == NULL)
        1186                 :          0 :         return peer_alt_names;
        1187                 :            :
        1188                 :            :     /* get a memory buffer */
        1189                 :          0 :     biobuf = BIO_new(BIO_s_mem());
        1190         [ #  # ]:          0 :     if (biobuf == NULL) {
        1191                 :          0 :         PyErr_SetString(state->PySSLErrorObject, "failed to allocate BIO");
        1192                 :          0 :         return NULL;
        1193                 :            :     }
        1194                 :            :
        1195                 :          0 :     names = (GENERAL_NAMES *)X509_get_ext_d2i(
        1196                 :            :         certificate, NID_subject_alt_name, NULL, NULL);
        1197         [ #  # ]:          0 :     if (names != NULL) {
        1198         [ #  # ]:          0 :         if (peer_alt_names == Py_None) {
        1199                 :          0 :             peer_alt_names = PyList_New(0);
        1200         [ #  # ]:          0 :             if (peer_alt_names == NULL)
        1201                 :          0 :                 goto fail;
        1202                 :            :         }
        1203                 :            :
        1204         [ #  # ]:          0 :         for(j = 0; j < sk_GENERAL_NAME_num(names); j++) {
        1205                 :            :             /* get a rendering of each name in the set of names */
        1206                 :            :             int gntype;
        1207                 :          0 :             ASN1_STRING *as = NULL;
        1208                 :            :
        1209                 :          0 :             name = sk_GENERAL_NAME_value(names, j);
        1210                 :          0 :             gntype = name->type;
        1211   [ #  #  #  #  :          0 :             switch (gntype) {
                          # ]
        1212                 :          0 :             case GEN_DIRNAME:
        1213                 :            :                 /* we special-case DirName as a tuple of
        1214                 :            :                    tuples of attributes */
        1215                 :            :
        1216                 :          0 :                 t = PyTuple_New(2);
        1217         [ #  # ]:          0 :                 if (t == NULL) {
        1218                 :          0 :                     goto fail;
        1219                 :            :                 }
        1220                 :            :
        1221                 :          0 :                 v = PyUnicode_FromString("DirName");
        1222         [ #  # ]:          0 :                 if (v == NULL) {
        1223                 :          0 :                     Py_DECREF(t);
        1224                 :          0 :                     goto fail;
        1225                 :            :                 }
        1226                 :          0 :                 PyTuple_SET_ITEM(t, 0, v);
        1227                 :            :
        1228                 :          0 :                 v = _create_tuple_for_X509_NAME(state, name->d.dirn);
        1229         [ #  # ]:          0 :                 if (v == NULL) {
        1230                 :          0 :                     Py_DECREF(t);
        1231                 :          0 :                     goto fail;
        1232                 :            :                 }
        1233                 :          0 :                 PyTuple_SET_ITEM(t, 1, v);
        1234                 :          0 :                 break;
        1235                 :            :
        1236                 :          0 :             case GEN_EMAIL:
        1237                 :            :             case GEN_DNS:
        1238                 :            :             case GEN_URI:
        1239                 :            :                 /* GENERAL_NAME_print() doesn't handle NULL bytes in ASN1_string
        1240                 :            :                    correctly, CVE-2013-4238 */
        1241                 :          0 :                 t = PyTuple_New(2);
        1242         [ #  # ]:          0 :                 if (t == NULL)
        1243                 :          0 :                     goto fail;
        1244                 :            :                 switch (gntype) {
        1245                 :          0 :                 case GEN_EMAIL:
        1246                 :          0 :                     v = PyUnicode_FromString("email");
        1247                 :          0 :                     as = name->d.rfc822Name;
        1248                 :          0 :                     break;
        1249                 :          0 :                 case GEN_DNS:
        1250                 :          0 :                     v = PyUnicode_FromString("DNS");
        1251                 :          0 :                     as = name->d.dNSName;
        1252                 :          0 :                     break;
        1253                 :          0 :                 case GEN_URI:
        1254                 :          0 :                     v = PyUnicode_FromString("URI");
        1255                 :          0 :                     as = name->d.uniformResourceIdentifier;
        1256                 :          0 :                     break;
        1257                 :            :                 }
        1258         [ #  # ]:          0 :                 if (v == NULL) {
        1259                 :          0 :                     Py_DECREF(t);
        1260                 :          0 :                     goto fail;
        1261                 :            :                 }
        1262                 :          0 :                 PyTuple_SET_ITEM(t, 0, v);
        1263                 :          0 :                 v = PyUnicode_FromStringAndSize((char *)ASN1_STRING_get0_data(as),
        1264                 :          0 :                                                 ASN1_STRING_length(as));
        1265         [ #  # ]:          0 :                 if (v == NULL) {
        1266                 :          0 :                     Py_DECREF(t);
        1267                 :          0 :                     goto fail;
        1268                 :            :                 }
        1269                 :          0 :                 PyTuple_SET_ITEM(t, 1, v);
        1270                 :          0 :                 break;
        1271                 :            :
        1272                 :          0 :             case GEN_RID:
        1273                 :          0 :                 t = PyTuple_New(2);
        1274         [ #  # ]:          0 :                 if (t == NULL)
        1275                 :          0 :                     goto fail;
        1276                 :            :
        1277                 :          0 :                 v = PyUnicode_FromString("Registered ID");
        1278         [ #  # ]:          0 :                 if (v == NULL) {
        1279                 :          0 :                     Py_DECREF(t);
        1280                 :          0 :                     goto fail;
        1281                 :            :                 }
        1282                 :          0 :                 PyTuple_SET_ITEM(t, 0, v);
        1283                 :            :
        1284                 :          0 :                 len = i2t_ASN1_OBJECT(buf, sizeof(buf)-1, name->d.rid);
        1285         [ #  # ]:          0 :                 if (len < 0) {
        1286                 :          0 :                     Py_DECREF(t);
        1287                 :          0 :                     _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1288                 :          0 :                     goto fail;
        1289         [ #  # ]:          0 :                 } else if (len >= (int)sizeof(buf)) {
        1290                 :          0 :                     v = PyUnicode_FromString("<INVALID>");
        1291                 :            :                 } else {
        1292                 :          0 :                     v = PyUnicode_FromStringAndSize(buf, len);
        1293                 :            :                 }
        1294         [ #  # ]:          0 :                 if (v == NULL) {
        1295                 :          0 :                     Py_DECREF(t);
        1296                 :          0 :                     goto fail;
        1297                 :            :                 }
        1298                 :          0 :                 PyTuple_SET_ITEM(t, 1, v);
        1299                 :          0 :                 break;
        1300                 :            :
        1301                 :          0 :             case GEN_IPADD:
        1302                 :            :                 /* OpenSSL < 3.0.0 adds a trailing \n to IPv6. 3.0.0 removed
        1303                 :            :                  * the trailing newline. Remove it in all versions
        1304                 :            :                  */
        1305                 :          0 :                 t = PyTuple_New(2);
        1306         [ #  # ]:          0 :                 if (t == NULL)
        1307                 :          0 :                     goto fail;
        1308                 :            :
        1309                 :          0 :                 v = PyUnicode_FromString("IP Address");
        1310         [ #  # ]:          0 :                 if (v == NULL) {
        1311                 :          0 :                     Py_DECREF(t);
        1312                 :          0 :                     goto fail;
        1313                 :            :                 }
        1314                 :          0 :                 PyTuple_SET_ITEM(t, 0, v);
        1315                 :            :
        1316         [ #  # ]:          0 :                 if (name->d.ip->length == 4) {
        1317                 :          0 :                     unsigned char *p = name->d.ip->data;
        1318                 :          0 :                     v = PyUnicode_FromFormat(
        1319                 :            :                         "%d.%d.%d.%d",
        1320                 :          0 :                         p[0], p[1], p[2], p[3]
        1321                 :            :                     );
        1322         [ #  # ]:          0 :                 } else if (name->d.ip->length == 16) {
        1323                 :            :                     /* PyUnicode_FromFormat() does not support %X */
        1324                 :          0 :                     unsigned char *p = name->d.ip->data;
        1325                 :          0 :                     len = sprintf(
        1326                 :            :                         buf,
        1327                 :            :                         "%X:%X:%X:%X:%X:%X:%X:%X",
        1328                 :          0 :                         p[0] << 8 | p[1],
        1329                 :          0 :                         p[2] << 8 | p[3],
        1330                 :          0 :                         p[4] << 8 | p[5],
        1331                 :          0 :                         p[6] << 8 | p[7],
        1332                 :          0 :                         p[8] << 8 | p[9],
        1333                 :          0 :                         p[10] << 8 | p[11],
        1334                 :          0 :                         p[12] << 8 | p[13],
        1335                 :          0 :                         p[14] << 8 | p[15]
        1336                 :            :                     );
        1337                 :          0 :                     v = PyUnicode_FromStringAndSize(buf, len);
        1338                 :            :                 } else {
        1339                 :          0 :                     v = PyUnicode_FromString("<invalid>");
        1340                 :            :                 }
        1341                 :            :
        1342         [ #  # ]:          0 :                 if (v == NULL) {
        1343                 :          0 :                     Py_DECREF(t);
        1344                 :          0 :                     goto fail;
        1345                 :            :                 }
        1346                 :          0 :                 PyTuple_SET_ITEM(t, 1, v);
        1347                 :          0 :                 break;
        1348                 :            :
        1349         [ #  # ]:          0 :             default:
        1350                 :            :                 /* for everything else, we use the OpenSSL print form */
        1351                 :            :                 switch (gntype) {
        1352                 :            :                     /* check for new general name type */
        1353                 :          0 :                     case GEN_OTHERNAME:
        1354                 :            :                     case GEN_X400:
        1355                 :            :                     case GEN_EDIPARTY:
        1356                 :            :                     case GEN_RID:
        1357                 :          0 :                         break;
        1358                 :          0 :                     default:
        1359         [ #  # ]:          0 :                         if (PyErr_WarnFormat(PyExc_RuntimeWarning, 1,
        1360                 :            :                                              "Unknown general name type %d",
        1361                 :            :                                              gntype) == -1) {
        1362                 :          0 :                             goto fail;
        1363                 :            :                         }
        1364                 :          0 :                         break;
        1365                 :            :                 }
        1366                 :          0 :                 (void) BIO_reset(biobuf);
        1367                 :          0 :                 GENERAL_NAME_print(biobuf, name);
        1368                 :          0 :                 len = BIO_gets(biobuf, buf, sizeof(buf)-1);
        1369         [ #  # ]:          0 :                 if (len < 0) {
        1370                 :          0 :                     _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1371                 :          0 :                     goto fail;
        1372                 :            :                 }
        1373                 :          0 :                 vptr = strchr(buf, ':');
        1374         [ #  # ]:          0 :                 if (vptr == NULL) {
        1375                 :          0 :                     PyErr_Format(PyExc_ValueError,
        1376                 :            :                                  "Invalid value %.200s",
        1377                 :            :                                  buf);
        1378                 :          0 :                     goto fail;
        1379                 :            :                 }
        1380                 :          0 :                 t = PyTuple_New(2);
        1381         [ #  # ]:          0 :                 if (t == NULL)
        1382                 :          0 :                     goto fail;
        1383                 :          0 :                 v = PyUnicode_FromStringAndSize(buf, (vptr - buf));
        1384         [ #  # ]:          0 :                 if (v == NULL) {
        1385                 :          0 :                     Py_DECREF(t);
        1386                 :          0 :                     goto fail;
        1387                 :            :                 }
        1388                 :          0 :                 PyTuple_SET_ITEM(t, 0, v);
        1389                 :          0 :                 v = PyUnicode_FromStringAndSize((vptr + 1),
        1390                 :          0 :                                                 (len - (vptr - buf + 1)));
        1391         [ #  # ]:          0 :                 if (v == NULL) {
        1392                 :          0 :                     Py_DECREF(t);
        1393                 :          0 :                     goto fail;
        1394                 :            :                 }
        1395                 :          0 :                 PyTuple_SET_ITEM(t, 1, v);
        1396                 :          0 :                 break;
        1397                 :            :             }
        1398                 :            :
        1399                 :            :             /* and add that rendering to the list */
        1400                 :            :
        1401         [ #  # ]:          0 :             if (PyList_Append(peer_alt_names, t) < 0) {
        1402                 :          0 :                 Py_DECREF(t);
        1403                 :          0 :                 goto fail;
        1404                 :            :             }
        1405                 :          0 :             Py_DECREF(t);
        1406                 :            :         }
        1407                 :          0 :         sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
        1408                 :            :     }
        1409                 :          0 :     BIO_free(biobuf);
        1410         [ #  # ]:          0 :     if (peer_alt_names != Py_None) {
        1411                 :          0 :         v = PyList_AsTuple(peer_alt_names);
        1412                 :          0 :         Py_DECREF(peer_alt_names);
        1413                 :          0 :         return v;
        1414                 :            :     } else {
        1415                 :          0 :         return peer_alt_names;
        1416                 :            :     }
        1417                 :            :
        1418                 :            :
        1419                 :          0 :   fail:
        1420         [ #  # ]:          0 :     if (biobuf != NULL)
        1421                 :          0 :         BIO_free(biobuf);
        1422                 :            :
        1423         [ #  # ]:          0 :     if (peer_alt_names != Py_None) {
        1424                 :          0 :         Py_XDECREF(peer_alt_names);
        1425                 :            :     }
        1426                 :            :
        1427                 :          0 :     return NULL;
        1428                 :            : }
        1429                 :            :
        1430                 :            : static PyObject *
        1431                 :          0 : _get_aia_uri(X509 *certificate, int nid) {
        1432                 :          0 :     PyObject *lst = NULL, *ostr = NULL;
        1433                 :            :     int i, result;
        1434                 :            :     AUTHORITY_INFO_ACCESS *info;
        1435                 :            :
        1436                 :          0 :     info = X509_get_ext_d2i(certificate, NID_info_access, NULL, NULL);
        1437         [ #  # ]:          0 :     if (info == NULL)
        1438                 :          0 :         return Py_None;
        1439         [ #  # ]:          0 :     if (sk_ACCESS_DESCRIPTION_num(info) == 0) {
        1440                 :          0 :         AUTHORITY_INFO_ACCESS_free(info);
        1441                 :          0 :         return Py_None;
        1442                 :            :     }
        1443                 :            :
        1444         [ #  # ]:          0 :     if ((lst = PyList_New(0)) == NULL) {
        1445                 :          0 :         goto fail;
        1446                 :            :     }
        1447                 :            :
        1448         [ #  # ]:          0 :     for (i = 0; i < sk_ACCESS_DESCRIPTION_num(info); i++) {
        1449                 :          0 :         ACCESS_DESCRIPTION *ad = sk_ACCESS_DESCRIPTION_value(info, i);
        1450                 :            :         ASN1_IA5STRING *uri;
        1451                 :            :
        1452         [ #  # ]:          0 :         if ((OBJ_obj2nid(ad->method) != nid) ||
        1453         [ #  # ]:          0 :                 (ad->location->type != GEN_URI)) {
        1454                 :          0 :             continue;
        1455                 :            :         }
        1456                 :          0 :         uri = ad->location->d.uniformResourceIdentifier;
        1457                 :          0 :         ostr = PyUnicode_FromStringAndSize((char *)uri->data,
        1458                 :          0 :                                            uri->length);
        1459         [ #  # ]:          0 :         if (ostr == NULL) {
        1460                 :          0 :             goto fail;
        1461                 :            :         }
        1462                 :          0 :         result = PyList_Append(lst, ostr);
        1463                 :          0 :         Py_DECREF(ostr);
        1464         [ #  # ]:          0 :         if (result < 0) {
        1465                 :          0 :             goto fail;
        1466                 :            :         }
        1467                 :            :     }
        1468                 :          0 :     AUTHORITY_INFO_ACCESS_free(info);
        1469                 :            :
        1470                 :            :     /* convert to tuple or None */
        1471         [ #  # ]:          0 :     if (PyList_Size(lst) == 0) {
        1472                 :          0 :         Py_DECREF(lst);
        1473                 :          0 :         return Py_None;
        1474                 :            :     } else {
        1475                 :            :         PyObject *tup;
        1476                 :          0 :         tup = PyList_AsTuple(lst);
        1477                 :          0 :         Py_DECREF(lst);
        1478                 :          0 :         return tup;
        1479                 :            :     }
        1480                 :            :
        1481                 :          0 :   fail:
        1482                 :          0 :     AUTHORITY_INFO_ACCESS_free(info);
        1483                 :          0 :     Py_XDECREF(lst);
        1484                 :          0 :     return NULL;
        1485                 :            : }
        1486                 :            :
        1487                 :            : static PyObject *
        1488                 :          0 : _get_crl_dp(X509 *certificate) {
        1489                 :            :     STACK_OF(DIST_POINT) *dps;
        1490                 :            :     int i, j;
        1491                 :          0 :     PyObject *lst, *res = NULL;
        1492                 :            :
        1493                 :          0 :     dps = X509_get_ext_d2i(certificate, NID_crl_distribution_points, NULL, NULL);
        1494                 :            :
        1495         [ #  # ]:          0 :     if (dps == NULL)
        1496                 :          0 :         return Py_None;
        1497                 :            :
        1498                 :          0 :     lst = PyList_New(0);
        1499         [ #  # ]:          0 :     if (lst == NULL)
        1500                 :          0 :         goto done;
        1501                 :            :
        1502         [ #  # ]:          0 :     for (i=0; i < sk_DIST_POINT_num(dps); i++) {
        1503                 :            :         DIST_POINT *dp;
        1504                 :            :         STACK_OF(GENERAL_NAME) *gns;
        1505                 :            :
        1506                 :          0 :         dp = sk_DIST_POINT_value(dps, i);
        1507         [ #  # ]:          0 :         if (dp->distpoint == NULL) {
        1508                 :            :             /* Ignore empty DP value, CVE-2019-5010 */
        1509                 :          0 :             continue;
        1510                 :            :         }
        1511                 :          0 :         gns = dp->distpoint->name.fullname;
        1512                 :            :
        1513         [ #  # ]:          0 :         for (j=0; j < sk_GENERAL_NAME_num(gns); j++) {
        1514                 :            :             GENERAL_NAME *gn;
        1515                 :            :             ASN1_IA5STRING *uri;
        1516                 :            :             PyObject *ouri;
        1517                 :            :             int err;
        1518                 :            :
        1519                 :          0 :             gn = sk_GENERAL_NAME_value(gns, j);
        1520         [ #  # ]:          0 :             if (gn->type != GEN_URI) {
        1521                 :          0 :                 continue;
        1522                 :            :             }
        1523                 :          0 :             uri = gn->d.uniformResourceIdentifier;
        1524                 :          0 :             ouri = PyUnicode_FromStringAndSize((char *)uri->data,
        1525                 :          0 :                                                uri->length);
        1526         [ #  # ]:          0 :             if (ouri == NULL)
        1527                 :          0 :                 goto done;
        1528                 :            :
        1529                 :          0 :             err = PyList_Append(lst, ouri);
        1530                 :          0 :             Py_DECREF(ouri);
        1531         [ #  # ]:          0 :             if (err < 0)
        1532                 :          0 :                 goto done;
        1533                 :            :         }
        1534                 :            :     }
        1535                 :            :
        1536                 :            :     /* Convert to tuple. */
        1537         [ #  # ]:          0 :     res = (PyList_GET_SIZE(lst) > 0) ? PyList_AsTuple(lst) : Py_None;
        1538                 :            :
        1539                 :          0 :   done:
        1540                 :          0 :     Py_XDECREF(lst);
        1541                 :          0 :     CRL_DIST_POINTS_free(dps);
        1542                 :          0 :     return res;
        1543                 :            : }
        1544                 :            :
        1545                 :            : static PyObject *
        1546                 :          0 : _decode_certificate(_sslmodulestate *state, X509 *certificate) {
        1547                 :            :
        1548                 :          0 :     PyObject *retval = NULL;
        1549                 :          0 :     BIO *biobuf = NULL;
        1550                 :            :     PyObject *peer;
        1551                 :          0 :     PyObject *peer_alt_names = NULL;
        1552                 :            :     PyObject *issuer;
        1553                 :            :     PyObject *version;
        1554                 :            :     PyObject *sn_obj;
        1555                 :            :     PyObject *obj;
        1556                 :            :     ASN1_INTEGER *serialNumber;
        1557                 :            :     char buf[2048];
        1558                 :            :     int len, result;
        1559                 :            :     const ASN1_TIME *notBefore, *notAfter;
        1560                 :            :     PyObject *pnotBefore, *pnotAfter;
        1561                 :            :
        1562                 :          0 :     retval = PyDict_New();
        1563         [ #  # ]:          0 :     if (retval == NULL)
        1564                 :          0 :         return NULL;
        1565                 :            :
        1566                 :          0 :     peer = _create_tuple_for_X509_NAME(
        1567                 :            :         state,
        1568                 :            :         X509_get_subject_name(certificate));
        1569         [ #  # ]:          0 :     if (peer == NULL)
        1570                 :          0 :         goto fail0;
        1571         [ #  # ]:          0 :     if (PyDict_SetItemString(retval, (const char *) "subject", peer) < 0) {
        1572                 :          0 :         Py_DECREF(peer);
        1573                 :          0 :         goto fail0;
        1574                 :            :     }
        1575                 :          0 :     Py_DECREF(peer);
        1576                 :            :
        1577                 :          0 :     issuer = _create_tuple_for_X509_NAME(
        1578                 :            :         state,
        1579                 :            :         X509_get_issuer_name(certificate));
        1580         [ #  # ]:          0 :     if (issuer == NULL)
        1581                 :          0 :         goto fail0;
        1582         [ #  # ]:          0 :     if (PyDict_SetItemString(retval, (const char *)"issuer", issuer) < 0) {
        1583                 :          0 :         Py_DECREF(issuer);
        1584                 :          0 :         goto fail0;
        1585                 :            :     }
        1586                 :          0 :     Py_DECREF(issuer);
        1587                 :            :
        1588                 :          0 :     version = PyLong_FromLong(X509_get_version(certificate) + 1);
        1589         [ #  # ]:          0 :     if (version == NULL)
        1590                 :          0 :         goto fail0;
        1591         [ #  # ]:          0 :     if (PyDict_SetItemString(retval, "version", version) < 0) {
        1592                 :          0 :         Py_DECREF(version);
        1593                 :          0 :         goto fail0;
        1594                 :            :     }
        1595                 :          0 :     Py_DECREF(version);
        1596                 :            :
        1597                 :            :     /* get a memory buffer */
        1598                 :          0 :     biobuf = BIO_new(BIO_s_mem());
        1599         [ #  # ]:          0 :     if (biobuf == NULL) {
        1600                 :          0 :         PyErr_SetString(state->PySSLErrorObject, "failed to allocate BIO");
        1601                 :          0 :         goto fail0;
        1602                 :            :     }
        1603                 :            :
        1604                 :          0 :     (void) BIO_reset(biobuf);
        1605                 :          0 :     serialNumber = X509_get_serialNumber(certificate);
        1606                 :            :     /* should not exceed 20 octets, 160 bits, so buf is big enough */
        1607                 :          0 :     i2a_ASN1_INTEGER(biobuf, serialNumber);
        1608                 :          0 :     len = BIO_gets(biobuf, buf, sizeof(buf)-1);
        1609         [ #  # ]:          0 :     if (len < 0) {
        1610                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1611                 :          0 :         goto fail1;
        1612                 :            :     }
        1613                 :          0 :     sn_obj = PyUnicode_FromStringAndSize(buf, len);
        1614         [ #  # ]:          0 :     if (sn_obj == NULL)
        1615                 :          0 :         goto fail1;
        1616         [ #  # ]:          0 :     if (PyDict_SetItemString(retval, "serialNumber", sn_obj) < 0) {
        1617                 :          0 :         Py_DECREF(sn_obj);
        1618                 :          0 :         goto fail1;
        1619                 :            :     }
        1620                 :          0 :     Py_DECREF(sn_obj);
        1621                 :            :
        1622                 :          0 :     (void) BIO_reset(biobuf);
        1623                 :          0 :     notBefore = X509_get0_notBefore(certificate);
        1624                 :          0 :     ASN1_TIME_print(biobuf, notBefore);
        1625                 :          0 :     len = BIO_gets(biobuf, buf, sizeof(buf)-1);
        1626         [ #  # ]:          0 :     if (len < 0) {
        1627                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1628                 :          0 :         goto fail1;
        1629                 :            :     }
        1630                 :          0 :     pnotBefore = PyUnicode_FromStringAndSize(buf, len);
        1631         [ #  # ]:          0 :     if (pnotBefore == NULL)
        1632                 :          0 :         goto fail1;
        1633         [ #  # ]:          0 :     if (PyDict_SetItemString(retval, "notBefore", pnotBefore) < 0) {
        1634                 :          0 :         Py_DECREF(pnotBefore);
        1635                 :          0 :         goto fail1;
        1636                 :            :     }
        1637                 :          0 :     Py_DECREF(pnotBefore);
        1638                 :            :
        1639                 :          0 :     (void) BIO_reset(biobuf);
        1640                 :          0 :     notAfter = X509_get0_notAfter(certificate);
        1641                 :          0 :     ASN1_TIME_print(biobuf, notAfter);
        1642                 :          0 :     len = BIO_gets(biobuf, buf, sizeof(buf)-1);
        1643         [ #  # ]:          0 :     if (len < 0) {
        1644                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1645                 :          0 :         goto fail1;
        1646                 :            :     }
        1647                 :          0 :     pnotAfter = PyUnicode_FromStringAndSize(buf, len);
        1648         [ #  # ]:          0 :     if (pnotAfter == NULL)
        1649                 :          0 :         goto fail1;
        1650         [ #  # ]:          0 :     if (PyDict_SetItemString(retval, "notAfter", pnotAfter) < 0) {
        1651                 :          0 :         Py_DECREF(pnotAfter);
        1652                 :          0 :         goto fail1;
        1653                 :            :     }
        1654                 :          0 :     Py_DECREF(pnotAfter);
        1655                 :            :
        1656                 :            :     /* Now look for subjectAltName */
        1657                 :            :
        1658                 :          0 :     peer_alt_names = _get_peer_alt_names(state, certificate);
        1659         [ #  # ]:          0 :     if (peer_alt_names == NULL)
        1660                 :          0 :         goto fail1;
        1661         [ #  # ]:          0 :     else if (peer_alt_names != Py_None) {
        1662         [ #  # ]:          0 :         if (PyDict_SetItemString(retval, "subjectAltName",
        1663                 :            :                                  peer_alt_names) < 0) {
        1664                 :          0 :             Py_DECREF(peer_alt_names);
        1665                 :          0 :             goto fail1;
        1666                 :            :         }
        1667                 :          0 :         Py_DECREF(peer_alt_names);
        1668                 :            :     }
        1669                 :            :
        1670                 :            :     /* Authority Information Access: OCSP URIs */
        1671                 :          0 :     obj = _get_aia_uri(certificate, NID_ad_OCSP);
        1672         [ #  # ]:          0 :     if (obj == NULL) {
        1673                 :          0 :         goto fail1;
        1674         [ #  # ]:          0 :     } else if (obj != Py_None) {
        1675                 :          0 :         result = PyDict_SetItemString(retval, "OCSP", obj);
        1676                 :          0 :         Py_DECREF(obj);
        1677         [ #  # ]:          0 :         if (result < 0) {
        1678                 :          0 :             goto fail1;
        1679                 :            :         }
        1680                 :            :     }
        1681                 :            :
        1682                 :          0 :     obj = _get_aia_uri(certificate, NID_ad_ca_issuers);
        1683         [ #  # ]:          0 :     if (obj == NULL) {
        1684                 :          0 :         goto fail1;
        1685         [ #  # ]:          0 :     } else if (obj != Py_None) {
        1686                 :          0 :         result = PyDict_SetItemString(retval, "caIssuers", obj);
        1687                 :          0 :         Py_DECREF(obj);
        1688         [ #  # ]:          0 :         if (result < 0) {
        1689                 :          0 :             goto fail1;
        1690                 :            :         }
        1691                 :            :     }
        1692                 :            :
        1693                 :            :     /* CDP (CRL distribution points) */
        1694                 :          0 :     obj = _get_crl_dp(certificate);
        1695         [ #  # ]:          0 :     if (obj == NULL) {
        1696                 :          0 :         goto fail1;
        1697         [ #  # ]:          0 :     } else if (obj != Py_None) {
        1698                 :          0 :         result = PyDict_SetItemString(retval, "crlDistributionPoints", obj);
        1699                 :          0 :         Py_DECREF(obj);
        1700         [ #  # ]:          0 :         if (result < 0) {
        1701                 :          0 :             goto fail1;
        1702                 :            :         }
        1703                 :            :     }
        1704                 :            :
        1705                 :          0 :     BIO_free(biobuf);
        1706                 :          0 :     return retval;
        1707                 :            :
        1708                 :          0 :   fail1:
        1709         [ #  # ]:          0 :     if (biobuf != NULL)
        1710                 :          0 :         BIO_free(biobuf);
        1711                 :          0 :   fail0:
        1712                 :          0 :     Py_XDECREF(retval);
        1713                 :          0 :     return NULL;
        1714                 :            : }
        1715                 :            :
        1716                 :            : static PyObject *
        1717                 :          0 : _certificate_to_der(_sslmodulestate *state, X509 *certificate)
        1718                 :            : {
        1719                 :          0 :     unsigned char *bytes_buf = NULL;
        1720                 :            :     int len;
        1721                 :            :     PyObject *retval;
        1722                 :            :
        1723                 :          0 :     bytes_buf = NULL;
        1724                 :          0 :     len = i2d_X509(certificate, &bytes_buf);
        1725         [ #  # ]:          0 :     if (len < 0) {
        1726                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        1727                 :          0 :         return NULL;
        1728                 :            :     }
        1729                 :            :     /* this is actually an immutable bytes sequence */
        1730                 :          0 :     retval = PyBytes_FromStringAndSize((const char *) bytes_buf, len);
        1731                 :          0 :     OPENSSL_free(bytes_buf);
        1732                 :          0 :     return retval;
        1733                 :            : }
        1734                 :            :
        1735                 :            : #include "_ssl/misc.c"
        1736                 :            : #include "_ssl/cert.c"
        1737                 :            :
        1738                 :            : /*[clinic input]
        1739                 :            : _ssl._test_decode_cert
        1740                 :            :     path: object(converter="PyUnicode_FSConverter")
        1741                 :            :     /
        1742                 :            :
        1743                 :            : [clinic start generated code]*/
        1744                 :            :
        1745                 :            : static PyObject *
        1746                 :          0 : _ssl__test_decode_cert_impl(PyObject *module, PyObject *path)
        1747                 :            : /*[clinic end generated code: output=96becb9abb23c091 input=cdeaaf02d4346628]*/
        1748                 :            : {
        1749                 :          0 :     PyObject *retval = NULL;
        1750                 :          0 :     X509 *x=NULL;
        1751                 :            :     BIO *cert;
        1752                 :          0 :     _sslmodulestate *state = get_ssl_state(module);
        1753                 :            :
        1754         [ #  # ]:          0 :     if ((cert=BIO_new(BIO_s_file())) == NULL) {
        1755                 :          0 :         PyErr_SetString(state->PySSLErrorObject,
        1756                 :            :                         "Can't malloc memory to read file");
        1757                 :          0 :         goto fail0;
        1758                 :            :     }
        1759                 :            :
        1760         [ #  # ]:          0 :     if (BIO_read_filename(cert, PyBytes_AsString(path)) <= 0) {
        1761                 :          0 :         PyErr_SetString(state->PySSLErrorObject,
        1762                 :            :                         "Can't open file");
        1763                 :          0 :         goto fail0;
        1764                 :            :     }
        1765                 :            :
        1766                 :          0 :     x = PEM_read_bio_X509(cert, NULL, NULL, NULL);
        1767         [ #  # ]:          0 :     if (x == NULL) {
        1768                 :          0 :         PyErr_SetString(state->PySSLErrorObject,
        1769                 :            :                         "Error decoding PEM-encoded file");
        1770                 :          0 :         goto fail0;
        1771                 :            :     }
        1772                 :            :
        1773                 :          0 :     retval = _decode_certificate(state, x);
        1774                 :          0 :     X509_free(x);
        1775                 :            :
        1776                 :          0 :   fail0:
        1777                 :          0 :     Py_DECREF(path);
        1778         [ #  # ]:          0 :     if (cert != NULL) BIO_free(cert);
        1779                 :          0 :     return retval;
        1780                 :            : }
        1781                 :            :
        1782                 :            :
        1783                 :            : /*[clinic input]
        1784                 :            : _ssl._SSLSocket.getpeercert
        1785                 :            :     der as binary_mode: bool = False
        1786                 :            :     /
        1787                 :            :
        1788                 :            : Returns the certificate for the peer.
        1789                 :            :
        1790                 :            : If no certificate was provided, returns None.  If a certificate was
        1791                 :            : provided, but not validated, returns an empty dictionary.  Otherwise
        1792                 :            : returns a dict containing information about the peer certificate.
        1793                 :            :
        1794                 :            : If the optional argument is True, returns a DER-encoded copy of the
        1795                 :            : peer certificate, or None if no certificate was provided.  This will
        1796                 :            : return the certificate even if it wasn't validated.
        1797                 :            : [clinic start generated code]*/
        1798                 :            :
        1799                 :            : static PyObject *
        1800                 :          0 : _ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode)
        1801                 :            : /*[clinic end generated code: output=1f0ab66dfb693c88 input=c0fbe802e57629b7]*/
        1802                 :            : {
        1803                 :            :     int verification;
        1804                 :            :     X509 *peer_cert;
        1805                 :            :     PyObject *result;
        1806                 :            :
        1807         [ #  # ]:          0 :     if (!SSL_is_init_finished(self->ssl)) {
        1808                 :          0 :         PyErr_SetString(PyExc_ValueError,
        1809                 :            :                         "handshake not done yet");
        1810                 :          0 :         return NULL;
        1811                 :            :     }
        1812                 :          0 :     peer_cert = SSL_get_peer_certificate(self->ssl);
        1813         [ #  # ]:          0 :     if (peer_cert == NULL)
        1814                 :          0 :         Py_RETURN_NONE;
        1815                 :            :
        1816         [ #  # ]:          0 :     if (binary_mode) {
        1817                 :            :         /* return cert in DER-encoded format */
        1818                 :          0 :         result = _certificate_to_der(get_state_sock(self), peer_cert);
        1819                 :            :     } else {
        1820                 :          0 :         verification = SSL_CTX_get_verify_mode(SSL_get_SSL_CTX(self->ssl));
        1821         [ #  # ]:          0 :         if ((verification & SSL_VERIFY_PEER) == 0)
        1822                 :          0 :             result = PyDict_New();
        1823                 :            :         else
        1824                 :          0 :             result = _decode_certificate(get_state_sock(self), peer_cert);
        1825                 :            :     }
        1826                 :          0 :     X509_free(peer_cert);
        1827                 :          0 :     return result;
        1828                 :            : }
        1829                 :            :
        1830                 :            : /*[clinic input]
        1831                 :            : _ssl._SSLSocket.get_verified_chain
        1832                 :            :
        1833                 :            : [clinic start generated code]*/
        1834                 :            :
        1835                 :            : static PyObject *
        1836                 :          0 : _ssl__SSLSocket_get_verified_chain_impl(PySSLSocket *self)
        1837                 :            : /*[clinic end generated code: output=802421163cdc3110 input=5fb0714f77e2bd51]*/
        1838                 :            : {
        1839                 :            :     /* borrowed reference */
        1840                 :          0 :     STACK_OF(X509) *chain = SSL_get0_verified_chain(self->ssl);
        1841         [ #  # ]:          0 :     if (chain == NULL) {
        1842                 :          0 :         Py_RETURN_NONE;
        1843                 :            :     }
        1844                 :          0 :     return _PySSL_CertificateFromX509Stack(self->ctx->state, chain, 1);
        1845                 :            : }
        1846                 :            :
        1847                 :            : /*[clinic input]
        1848                 :            : _ssl._SSLSocket.get_unverified_chain
        1849                 :            :
        1850                 :            : [clinic start generated code]*/
        1851                 :            :
        1852                 :            : static PyObject *
        1853                 :          0 : _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self)
        1854                 :            : /*[clinic end generated code: output=5acdae414e13f913 input=78c33c360c635cb5]*/
        1855                 :            : {
        1856                 :            :     PyObject *retval;
        1857                 :            :     /* borrowed reference */
        1858                 :            :     /* TODO: include SSL_get_peer_certificate() for server-side sockets */
        1859                 :          0 :     STACK_OF(X509) *chain = SSL_get_peer_cert_chain(self->ssl);
        1860         [ #  # ]:          0 :     if (chain == NULL) {
        1861                 :          0 :         Py_RETURN_NONE;
        1862                 :            :     }
        1863                 :          0 :     retval = _PySSL_CertificateFromX509Stack(self->ctx->state, chain, 1);
        1864         [ #  # ]:          0 :     if (retval == NULL) {
        1865                 :          0 :         return NULL;
        1866                 :            :     }
        1867                 :            :     /* OpenSSL does not include peer cert for server side connections */
        1868         [ #  # ]:          0 :     if (self->socket_type == PY_SSL_SERVER) {
        1869                 :          0 :         PyObject *peerobj = NULL;
        1870                 :          0 :         X509 *peer = SSL_get_peer_certificate(self->ssl);
        1871                 :            :
        1872         [ #  # ]:          0 :         if (peer == NULL) {
        1873                 :          0 :             peerobj = Py_NewRef(Py_None);
        1874                 :            :         } else {
        1875                 :            :             /* consume X509 reference on success */
        1876                 :          0 :             peerobj = _PySSL_CertificateFromX509(self->ctx->state, peer, 0);
        1877         [ #  # ]:          0 :             if (peerobj == NULL) {
        1878                 :          0 :                 X509_free(peer);
        1879                 :          0 :                 Py_DECREF(retval);
        1880                 :          0 :                 return NULL;
        1881                 :            :             }
        1882                 :            :         }
        1883                 :          0 :         int res = PyList_Insert(retval, 0, peerobj);
        1884                 :          0 :         Py_DECREF(peerobj);
        1885         [ #  # ]:          0 :         if (res < 0) {
        1886                 :          0 :             Py_DECREF(retval);
        1887                 :          0 :             return NULL;
        1888                 :            :         }
        1889                 :            :     }
        1890                 :          0 :     return retval;
        1891                 :            : }
        1892                 :            :
        1893                 :            : static PyObject *
        1894                 :          0 : cipher_to_tuple(const SSL_CIPHER *cipher)
        1895                 :            : {
        1896                 :            :     const char *cipher_name, *cipher_protocol;
        1897                 :          0 :     PyObject *v, *retval = PyTuple_New(3);
        1898         [ #  # ]:          0 :     if (retval == NULL)
        1899                 :          0 :         return NULL;
        1900                 :            :
        1901                 :          0 :     cipher_name = SSL_CIPHER_get_name(cipher);
        1902         [ #  # ]:          0 :     if (cipher_name == NULL) {
        1903                 :          0 :         PyTuple_SET_ITEM(retval, 0, Py_NewRef(Py_None));
        1904                 :            :     } else {
        1905                 :          0 :         v = PyUnicode_FromString(cipher_name);
        1906         [ #  # ]:          0 :         if (v == NULL)
        1907                 :          0 :             goto fail;
        1908                 :          0 :         PyTuple_SET_ITEM(retval, 0, v);
        1909                 :            :     }
        1910                 :            :
        1911                 :          0 :     cipher_protocol = SSL_CIPHER_get_version(cipher);
        1912         [ #  # ]:          0 :     if (cipher_protocol == NULL) {
        1913                 :          0 :         PyTuple_SET_ITEM(retval, 1, Py_NewRef(Py_None));
        1914                 :            :     } else {
        1915                 :          0 :         v = PyUnicode_FromString(cipher_protocol);
        1916         [ #  # ]:          0 :         if (v == NULL)
        1917                 :          0 :             goto fail;
        1918                 :          0 :         PyTuple_SET_ITEM(retval, 1, v);
        1919                 :            :     }
        1920                 :            :
        1921                 :          0 :     v = PyLong_FromLong(SSL_CIPHER_get_bits(cipher, NULL));
        1922         [ #  # ]:          0 :     if (v == NULL)
        1923                 :          0 :         goto fail;
        1924                 :          0 :     PyTuple_SET_ITEM(retval, 2, v);
        1925                 :            :
        1926                 :          0 :     return retval;
        1927                 :            :
        1928                 :          0 :   fail:
        1929                 :          0 :     Py_DECREF(retval);
        1930                 :          0 :     return NULL;
        1931                 :            : }
        1932                 :            :
        1933                 :            : static PyObject *
        1934                 :          0 : cipher_to_dict(const SSL_CIPHER *cipher)
        1935                 :            : {
        1936                 :            :     const char *cipher_name, *cipher_protocol;
        1937                 :            :
        1938                 :            :     unsigned long cipher_id;
        1939                 :            :     int alg_bits, strength_bits, len;
        1940                 :          0 :     char buf[512] = {0};
        1941                 :            :     int aead, nid;
        1942                 :          0 :     const char *skcipher = NULL, *digest = NULL, *kx = NULL, *auth = NULL;
        1943                 :            :
        1944                 :            :     /* can be NULL */
        1945                 :          0 :     cipher_name = SSL_CIPHER_get_name(cipher);
        1946                 :          0 :     cipher_protocol = SSL_CIPHER_get_version(cipher);
        1947                 :          0 :     cipher_id = SSL_CIPHER_get_id(cipher);
        1948                 :          0 :     SSL_CIPHER_description(cipher, buf, sizeof(buf) - 1);
        1949                 :            :     /* Downcast to avoid a warning. Safe since buf is always 512 bytes */
        1950                 :          0 :     len = (int)strlen(buf);
        1951   [ #  #  #  # ]:          0 :     if (len > 1 && buf[len-1] == '\n')
        1952                 :          0 :         buf[len-1] = '\0';
        1953                 :          0 :     strength_bits = SSL_CIPHER_get_bits(cipher, &alg_bits);
        1954                 :            :
        1955                 :          0 :     aead = SSL_CIPHER_is_aead(cipher);
        1956                 :          0 :     nid = SSL_CIPHER_get_cipher_nid(cipher);
        1957         [ #  # ]:          0 :     skcipher = nid != NID_undef ? OBJ_nid2ln(nid) : NULL;
        1958                 :          0 :     nid = SSL_CIPHER_get_digest_nid(cipher);
        1959         [ #  # ]:          0 :     digest = nid != NID_undef ? OBJ_nid2ln(nid) : NULL;
        1960                 :          0 :     nid = SSL_CIPHER_get_kx_nid(cipher);
        1961         [ #  # ]:          0 :     kx = nid != NID_undef ? OBJ_nid2ln(nid) : NULL;
        1962                 :          0 :     nid = SSL_CIPHER_get_auth_nid(cipher);
        1963         [ #  # ]:          0 :     auth = nid != NID_undef ? OBJ_nid2ln(nid) : NULL;
        1964                 :            :
        1965         [ #  # ]:          0 :     return Py_BuildValue(
        1966                 :            :         "{sksssssssisi"
        1967                 :            :         "sOssssssss"
        1968                 :            :         "}",
        1969                 :            :         "id", cipher_id,
        1970                 :            :         "name", cipher_name,
        1971                 :            :         "protocol", cipher_protocol,
        1972                 :            :         "description", buf,
        1973                 :            :         "strength_bits", strength_bits,
        1974                 :            :         "alg_bits", alg_bits
        1975                 :            :         ,"aead", aead ? Py_True : Py_False,
        1976                 :            :         "symmetric", skcipher,
        1977                 :            :         "digest", digest,
        1978                 :            :         "kea", kx,
        1979                 :            :         "auth", auth
        1980                 :            :        );
        1981                 :            : }
        1982                 :            :
        1983                 :            : /*[clinic input]
        1984                 :            : _ssl._SSLSocket.shared_ciphers
        1985                 :            : [clinic start generated code]*/
        1986                 :            :
        1987                 :            : static PyObject *
        1988                 :          0 : _ssl__SSLSocket_shared_ciphers_impl(PySSLSocket *self)
        1989                 :            : /*[clinic end generated code: output=3d174ead2e42c4fd input=0bfe149da8fe6306]*/
        1990                 :            : {
        1991                 :            :     STACK_OF(SSL_CIPHER) *ciphers;
        1992                 :            :     int i;
        1993                 :            :     PyObject *res;
        1994                 :            :
        1995                 :          0 :     ciphers = SSL_get_ciphers(self->ssl);
        1996         [ #  # ]:          0 :     if (!ciphers)
        1997                 :          0 :         Py_RETURN_NONE;
        1998                 :          0 :     res = PyList_New(sk_SSL_CIPHER_num(ciphers));
        1999         [ #  # ]:          0 :     if (!res)
        2000                 :          0 :         return NULL;
        2001         [ #  # ]:          0 :     for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
        2002                 :          0 :         PyObject *tup = cipher_to_tuple(sk_SSL_CIPHER_value(ciphers, i));
        2003         [ #  # ]:          0 :         if (!tup) {
        2004                 :          0 :             Py_DECREF(res);
        2005                 :          0 :             return NULL;
        2006                 :            :         }
        2007                 :          0 :         PyList_SET_ITEM(res, i, tup);
        2008                 :            :     }
        2009                 :          0 :     return res;
        2010                 :            : }
        2011                 :            :
        2012                 :            : /*[clinic input]
        2013                 :            : _ssl._SSLSocket.cipher
        2014                 :            : [clinic start generated code]*/
        2015                 :            :
        2016                 :            : static PyObject *
        2017                 :          0 : _ssl__SSLSocket_cipher_impl(PySSLSocket *self)
        2018                 :            : /*[clinic end generated code: output=376417c16d0e5815 input=548fb0e27243796d]*/
        2019                 :            : {
        2020                 :            :     const SSL_CIPHER *current;
        2021                 :            :
        2022         [ #  # ]:          0 :     if (self->ssl == NULL)
        2023                 :          0 :         Py_RETURN_NONE;
        2024                 :          0 :     current = SSL_get_current_cipher(self->ssl);
        2025         [ #  # ]:          0 :     if (current == NULL)
        2026                 :          0 :         Py_RETURN_NONE;
        2027                 :          0 :     return cipher_to_tuple(current);
        2028                 :            : }
        2029                 :            :
        2030                 :            : /*[clinic input]
        2031                 :            : _ssl._SSLSocket.version
        2032                 :            : [clinic start generated code]*/
        2033                 :            :
        2034                 :            : static PyObject *
        2035                 :          0 : _ssl__SSLSocket_version_impl(PySSLSocket *self)
        2036                 :            : /*[clinic end generated code: output=178aed33193b2cdb input=900186a503436fd6]*/
        2037                 :            : {
        2038                 :            :     const char *version;
        2039                 :            :
        2040         [ #  # ]:          0 :     if (self->ssl == NULL)
        2041                 :          0 :         Py_RETURN_NONE;
        2042         [ #  # ]:          0 :     if (!SSL_is_init_finished(self->ssl)) {
        2043                 :            :         /* handshake not finished */
        2044                 :          0 :         Py_RETURN_NONE;
        2045                 :            :     }
        2046                 :          0 :     version = SSL_get_version(self->ssl);
        2047         [ #  # ]:          0 :     if (!strcmp(version, "unknown"))
        2048                 :          0 :         Py_RETURN_NONE;
        2049                 :          0 :     return PyUnicode_FromString(version);
        2050                 :            : }
        2051                 :            :
        2052                 :            : /*[clinic input]
        2053                 :            : _ssl._SSLSocket.selected_alpn_protocol
        2054                 :            : [clinic start generated code]*/
        2055                 :            :
        2056                 :            : static PyObject *
        2057                 :          0 : _ssl__SSLSocket_selected_alpn_protocol_impl(PySSLSocket *self)
        2058                 :            : /*[clinic end generated code: output=ec33688b303d250f input=442de30e35bc2913]*/
        2059                 :            : {
        2060                 :            :     const unsigned char *out;
        2061                 :            :     unsigned int outlen;
        2062                 :            :
        2063                 :          0 :     SSL_get0_alpn_selected(self->ssl, &out, &outlen);
        2064                 :            :
        2065         [ #  # ]:          0 :     if (out == NULL)
        2066                 :          0 :         Py_RETURN_NONE;
        2067                 :          0 :     return PyUnicode_FromStringAndSize((char *)out, outlen);
        2068                 :            : }
        2069                 :            :
        2070                 :            : /*[clinic input]
        2071                 :            : _ssl._SSLSocket.compression
        2072                 :            : [clinic start generated code]*/
        2073                 :            :
        2074                 :            : static PyObject *
        2075                 :          0 : _ssl__SSLSocket_compression_impl(PySSLSocket *self)
        2076                 :            : /*[clinic end generated code: output=bd16cb1bb4646ae7 input=5d059d0a2bbc32c8]*/
        2077                 :            : {
        2078                 :            : #ifdef OPENSSL_NO_COMP
        2079                 :            :     Py_RETURN_NONE;
        2080                 :            : #else
        2081                 :            :     const COMP_METHOD *comp_method;
        2082                 :            :     const char *short_name;
        2083                 :            :
        2084         [ #  # ]:          0 :     if (self->ssl == NULL)
        2085                 :          0 :         Py_RETURN_NONE;
        2086                 :          0 :     comp_method = SSL_get_current_compression(self->ssl);
        2087   [ #  #  #  # ]:          0 :     if (comp_method == NULL || COMP_get_type(comp_method) == NID_undef)
        2088                 :          0 :         Py_RETURN_NONE;
        2089                 :          0 :     short_name = OBJ_nid2sn(COMP_get_type(comp_method));
        2090         [ #  # ]:          0 :     if (short_name == NULL)
        2091                 :          0 :         Py_RETURN_NONE;
        2092                 :          0 :     return PyUnicode_DecodeFSDefault(short_name);
        2093                 :            : #endif
        2094                 :            : }
        2095                 :            :
        2096                 :          0 : static PySSLContext *PySSL_get_context(PySSLSocket *self, void *closure) {
        2097                 :          0 :     return (PySSLContext*)Py_NewRef(self->ctx);
        2098                 :            : }
        2099                 :            :
        2100                 :          0 : static int PySSL_set_context(PySSLSocket *self, PyObject *value,
        2101                 :            :                                    void *closure) {
        2102                 :            :
        2103         [ #  # ]:          0 :     if (PyObject_TypeCheck(value, self->ctx->state->PySSLContext_Type)) {
        2104                 :          0 :         Py_SETREF(self->ctx, (PySSLContext *)Py_NewRef(value));
        2105                 :          0 :         SSL_set_SSL_CTX(self->ssl, self->ctx->ctx);
        2106                 :            :         /* Set SSL* internal msg_callback to state of new context's state */
        2107                 :          0 :         SSL_set_msg_callback(
        2108                 :            :             self->ssl,
        2109         [ #  # ]:          0 :             self->ctx->msg_cb ? _PySSL_msg_callback : NULL
        2110                 :            :         );
        2111                 :            :     } else {
        2112                 :          0 :         PyErr_SetString(PyExc_TypeError, "The value must be a SSLContext");
        2113                 :          0 :         return -1;
        2114                 :            :     }
        2115                 :            :
        2116                 :          0 :     return 0;
        2117                 :            : }
        2118                 :            :
        2119                 :            : PyDoc_STRVAR(PySSL_set_context_doc,
        2120                 :            : "_setter_context(ctx)\n\
        2121                 :            : \
        2122                 :            : This changes the context associated with the SSLSocket. This is typically\n\
        2123                 :            : used from within a callback function set by the sni_callback\n\
        2124                 :            : on the SSLContext to change the certificate information associated with the\n\
        2125                 :            : SSLSocket before the cryptographic exchange handshake messages\n");
        2126                 :            :
        2127                 :            :
        2128                 :            : static PyObject *
        2129                 :          0 : PySSL_get_server_side(PySSLSocket *self, void *c)
        2130                 :            : {
        2131                 :          0 :     return PyBool_FromLong(self->socket_type == PY_SSL_SERVER);
        2132                 :            : }
        2133                 :            :
        2134                 :            : PyDoc_STRVAR(PySSL_get_server_side_doc,
        2135                 :            : "Whether this is a server-side socket.");
        2136                 :            :
        2137                 :            : static PyObject *
        2138                 :          0 : PySSL_get_server_hostname(PySSLSocket *self, void *c)
        2139                 :            : {
        2140         [ #  # ]:          0 :     if (self->server_hostname == NULL)
        2141                 :          0 :         Py_RETURN_NONE;
        2142                 :          0 :     return Py_NewRef(self->server_hostname);
        2143                 :            : }
        2144                 :            :
        2145                 :            : PyDoc_STRVAR(PySSL_get_server_hostname_doc,
        2146                 :            : "The currently set server hostname (for SNI).");
        2147                 :            :
        2148                 :            : static PyObject *
        2149                 :          0 : PySSL_get_owner(PySSLSocket *self, void *c)
        2150                 :            : {
        2151                 :            :     PyObject *owner;
        2152                 :            :
        2153         [ #  # ]:          0 :     if (self->owner == NULL)
        2154                 :          0 :         Py_RETURN_NONE;
        2155                 :            :
        2156                 :          0 :     owner = PyWeakref_GetObject(self->owner);
        2157                 :          0 :     return Py_NewRef(owner);
        2158                 :            : }
        2159                 :            :
        2160                 :            : static int
        2161                 :          0 : PySSL_set_owner(PySSLSocket *self, PyObject *value, void *c)
        2162                 :            : {
        2163                 :          0 :     Py_XSETREF(self->owner, PyWeakref_NewRef(value, NULL));
        2164         [ #  # ]:          0 :     if (self->owner == NULL)
        2165                 :          0 :         return -1;
        2166                 :          0 :     return 0;
        2167                 :            : }
        2168                 :            :
        2169                 :            : PyDoc_STRVAR(PySSL_get_owner_doc,
        2170                 :            : "The Python-level owner of this object.\
        2171                 :            : Passed as \"self\" in servername callback.");
        2172                 :            :
        2173                 :            : static int
        2174                 :          0 : PySSL_traverse(PySSLSocket *self, visitproc visit, void *arg)
        2175                 :            : {
        2176   [ #  #  #  # ]:          0 :     Py_VISIT(self->exc);
        2177   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
        2178                 :          0 :     return 0;
        2179                 :            : }
        2180                 :            :
        2181                 :            : static int
        2182                 :          0 : PySSL_clear(PySSLSocket *self)
        2183                 :            : {
        2184         [ #  # ]:          0 :     Py_CLEAR(self->exc);
        2185                 :          0 :     return 0;
        2186                 :            : }
        2187                 :            :
        2188                 :            : static void
        2189                 :          0 : PySSL_dealloc(PySSLSocket *self)
        2190                 :            : {
        2191                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
        2192                 :          0 :     PyObject_GC_UnTrack(self);
        2193         [ #  # ]:          0 :     if (self->ssl) {
        2194                 :          0 :         SSL_free(self->ssl);
        2195                 :            :     }
        2196                 :          0 :     Py_XDECREF(self->Socket);
        2197                 :          0 :     Py_XDECREF(self->ctx);
        2198                 :          0 :     Py_XDECREF(self->server_hostname);
        2199                 :          0 :     Py_XDECREF(self->owner);
        2200                 :          0 :     PyObject_GC_Del(self);
        2201                 :          0 :     Py_DECREF(tp);
        2202                 :          0 : }
        2203                 :            :
        2204                 :            : /* If the socket has a timeout, do a select()/poll() on the socket.
        2205                 :            :    The argument writing indicates the direction.
        2206                 :            :    Returns one of the possibilities in the timeout_state enum (above).
        2207                 :            :  */
        2208                 :            :
        2209                 :            : static int
        2210                 :          0 : PySSL_select(PySocketSockObject *s, int writing, _PyTime_t timeout)
        2211                 :            : {
        2212                 :            :     int rc;
        2213                 :            : #ifdef HAVE_POLL
        2214                 :            :     struct pollfd pollfd;
        2215                 :            :     _PyTime_t ms;
        2216                 :            : #else
        2217                 :            :     int nfds;
        2218                 :            :     fd_set fds;
        2219                 :            :     struct timeval tv;
        2220                 :            : #endif
        2221                 :            :
        2222                 :            :     /* Nothing to do unless we're in timeout mode (not non-blocking) */
        2223   [ #  #  #  # ]:          0 :     if ((s == NULL) || (timeout == 0))
        2224                 :          0 :         return SOCKET_IS_NONBLOCKING;
        2225         [ #  # ]:          0 :     else if (timeout < 0) {
        2226         [ #  # ]:          0 :         if (s->sock_timeout > 0)
        2227                 :          0 :             return SOCKET_HAS_TIMED_OUT;
        2228                 :            :         else
        2229                 :          0 :             return SOCKET_IS_BLOCKING;
        2230                 :            :     }
        2231                 :            :
        2232                 :            :     /* Guard against closed socket */
        2233         [ #  # ]:          0 :     if (s->sock_fd == INVALID_SOCKET)
        2234                 :          0 :         return SOCKET_HAS_BEEN_CLOSED;
        2235                 :            :
        2236                 :            :     /* Prefer poll, if available, since you can poll() any fd
        2237                 :            :      * which can't be done with select(). */
        2238                 :            : #ifdef HAVE_POLL
        2239                 :          0 :     pollfd.fd = s->sock_fd;
        2240         [ #  # ]:          0 :     pollfd.events = writing ? POLLOUT : POLLIN;
        2241                 :            :
        2242                 :            :     /* timeout is in seconds, poll() uses milliseconds */
        2243                 :          0 :     ms = (int)_PyTime_AsMilliseconds(timeout, _PyTime_ROUND_CEILING);
        2244                 :            :     assert(ms <= INT_MAX);
        2245                 :            :
        2246                 :          0 :     PySSL_BEGIN_ALLOW_THREADS
        2247                 :          0 :     rc = poll(&pollfd, 1, (int)ms);
        2248                 :          0 :     PySSL_END_ALLOW_THREADS
        2249                 :            : #else
        2250                 :            :     /* Guard against socket too large for select*/
        2251                 :            :     if (!_PyIsSelectable_fd(s->sock_fd))
        2252                 :            :         return SOCKET_TOO_LARGE_FOR_SELECT;
        2253                 :            :
        2254                 :            :     _PyTime_AsTimeval_clamp(timeout, &tv, _PyTime_ROUND_CEILING);
        2255                 :            :
        2256                 :            :     FD_ZERO(&fds);
        2257                 :            :     FD_SET(s->sock_fd, &fds);
        2258                 :            :
        2259                 :            :     /* Wait until the socket becomes ready */
        2260                 :            :     PySSL_BEGIN_ALLOW_THREADS
        2261                 :            :     nfds = Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int);
        2262                 :            :     if (writing)
        2263                 :            :         rc = select(nfds, NULL, &fds, NULL, &tv);
        2264                 :            :     else
        2265                 :            :         rc = select(nfds, &fds, NULL, NULL, &tv);
        2266                 :            :     PySSL_END_ALLOW_THREADS
        2267                 :            : #endif
        2268                 :            :
        2269                 :            :     /* Return SOCKET_TIMED_OUT on timeout, SOCKET_OPERATION_OK otherwise
        2270                 :            :        (when we are able to write or when there's something to read) */
        2271         [ #  # ]:          0 :     return rc == 0 ? SOCKET_HAS_TIMED_OUT : SOCKET_OPERATION_OK;
        2272                 :            : }
        2273                 :            :
        2274                 :            : /*[clinic input]
        2275                 :            : _ssl._SSLSocket.write
        2276                 :            :     b: Py_buffer
        2277                 :            :     /
        2278                 :            :
        2279                 :            : Writes the bytes-like object b into the SSL object.
        2280                 :            :
        2281                 :            : Returns the number of bytes written.
        2282                 :            : [clinic start generated code]*/
        2283                 :            :
        2284                 :            : static PyObject *
        2285                 :          0 : _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b)
        2286                 :            : /*[clinic end generated code: output=aa7a6be5527358d8 input=77262d994fe5100a]*/
        2287                 :            : {
        2288                 :          0 :     size_t count = 0;
        2289                 :            :     int retval;
        2290                 :            :     int sockstate;
        2291                 :            :     _PySSLError err;
        2292                 :            :     int nonblocking;
        2293         [ #  # ]:          0 :     PySocketSockObject *sock = GET_SOCKET(self);
        2294                 :          0 :     _PyTime_t timeout, deadline = 0;
        2295                 :            :     int has_timeout;
        2296                 :            :
        2297         [ #  # ]:          0 :     if (sock != NULL) {
        2298         [ #  # ]:          0 :         if (((PyObject*)sock) == Py_None) {
        2299                 :          0 :             _setSSLError(get_state_sock(self),
        2300                 :            :                          "Underlying socket connection gone",
        2301                 :            :                          PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);
        2302                 :          0 :             return NULL;
        2303                 :            :         }
        2304                 :          0 :         Py_INCREF(sock);
        2305                 :            :     }
        2306                 :            :
        2307         [ #  # ]:          0 :     if (sock != NULL) {
        2308                 :            :         /* just in case the blocking state of the socket has been changed */
        2309                 :          0 :         nonblocking = (sock->sock_timeout >= 0);
        2310                 :          0 :         BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
        2311                 :          0 :         BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
        2312                 :            :     }
        2313                 :            :
        2314         [ #  # ]:          0 :     timeout = GET_SOCKET_TIMEOUT(sock);
        2315                 :          0 :     has_timeout = (timeout > 0);
        2316         [ #  # ]:          0 :     if (has_timeout) {
        2317                 :          0 :         deadline = _PyDeadline_Init(timeout);
        2318                 :            :     }
        2319                 :            :
        2320                 :          0 :     sockstate = PySSL_select(sock, 1, timeout);
        2321         [ #  # ]:          0 :     if (sockstate == SOCKET_HAS_TIMED_OUT) {
        2322                 :          0 :         PyErr_SetString(PyExc_TimeoutError,
        2323                 :            :                         "The write operation timed out");
        2324                 :          0 :         goto error;
        2325         [ #  # ]:          0 :     } else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
        2326                 :          0 :         PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
        2327                 :            :                         "Underlying socket has been closed.");
        2328                 :          0 :         goto error;
        2329         [ #  # ]:          0 :     } else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {
        2330                 :          0 :         PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
        2331                 :            :                         "Underlying socket too large for select().");
        2332                 :          0 :         goto error;
        2333                 :            :     }
        2334                 :            :
        2335                 :            :     do {
        2336                 :          0 :         PySSL_BEGIN_ALLOW_THREADS
        2337                 :          0 :         retval = SSL_write_ex(self->ssl, b->buf, (size_t)b->len, &count);
        2338                 :          0 :         err = _PySSL_errno(retval == 0, self->ssl, retval);
        2339                 :          0 :         PySSL_END_ALLOW_THREADS
        2340                 :          0 :         self->err = err;
        2341                 :            :
        2342         [ #  # ]:          0 :         if (PyErr_CheckSignals())
        2343                 :          0 :             goto error;
        2344                 :            :
        2345         [ #  # ]:          0 :         if (has_timeout) {
        2346                 :          0 :             timeout = _PyDeadline_Get(deadline);
        2347                 :            :         }
        2348                 :            :
        2349         [ #  # ]:          0 :         if (err.ssl == SSL_ERROR_WANT_READ) {
        2350                 :          0 :             sockstate = PySSL_select(sock, 0, timeout);
        2351         [ #  # ]:          0 :         } else if (err.ssl == SSL_ERROR_WANT_WRITE) {
        2352                 :          0 :             sockstate = PySSL_select(sock, 1, timeout);
        2353                 :            :         } else {
        2354                 :          0 :             sockstate = SOCKET_OPERATION_OK;
        2355                 :            :         }
        2356                 :            :
        2357         [ #  # ]:          0 :         if (sockstate == SOCKET_HAS_TIMED_OUT) {
        2358                 :          0 :             PyErr_SetString(PyExc_TimeoutError,
        2359                 :            :                             "The write operation timed out");
        2360                 :          0 :             goto error;
        2361         [ #  # ]:          0 :         } else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
        2362                 :          0 :             PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
        2363                 :            :                             "Underlying socket has been closed.");
        2364                 :          0 :             goto error;
        2365         [ #  # ]:          0 :         } else if (sockstate == SOCKET_IS_NONBLOCKING) {
        2366                 :          0 :             break;
        2367                 :            :         }
        2368                 :          0 :     } while (err.ssl == SSL_ERROR_WANT_READ ||
        2369   [ #  #  #  # ]:          0 :              err.ssl == SSL_ERROR_WANT_WRITE);
        2370                 :            :
        2371                 :          0 :     Py_XDECREF(sock);
        2372         [ #  # ]:          0 :     if (retval == 0)
        2373                 :          0 :         return PySSL_SetError(self, retval, __FILE__, __LINE__);
        2374         [ #  # ]:          0 :     if (PySSL_ChainExceptions(self) < 0)
        2375                 :          0 :         return NULL;
        2376                 :          0 :     return PyLong_FromSize_t(count);
        2377                 :          0 : error:
        2378                 :          0 :     Py_XDECREF(sock);
        2379                 :          0 :     PySSL_ChainExceptions(self);
        2380                 :          0 :     return NULL;
        2381                 :            : }
        2382                 :            :
        2383                 :            : /*[clinic input]
        2384                 :            : _ssl._SSLSocket.pending
        2385                 :            :
        2386                 :            : Returns the number of already decrypted bytes available for read, pending on the connection.
        2387                 :            : [clinic start generated code]*/
        2388                 :            :
        2389                 :            : static PyObject *
        2390                 :          0 : _ssl__SSLSocket_pending_impl(PySSLSocket *self)
        2391                 :            : /*[clinic end generated code: output=983d9fecdc308a83 input=2b77487d6dfd597f]*/
        2392                 :            : {
        2393                 :          0 :     int count = 0;
        2394                 :            :     _PySSLError err;
        2395                 :            :
        2396                 :          0 :     PySSL_BEGIN_ALLOW_THREADS
        2397                 :          0 :     count = SSL_pending(self->ssl);
        2398                 :          0 :     err = _PySSL_errno(count < 0, self->ssl, count);
        2399                 :          0 :     PySSL_END_ALLOW_THREADS
        2400                 :          0 :     self->err = err;
        2401                 :            :
        2402         [ #  # ]:          0 :     if (count < 0)
        2403                 :          0 :         return PySSL_SetError(self, count, __FILE__, __LINE__);
        2404                 :            :     else
        2405                 :          0 :         return PyLong_FromLong(count);
        2406                 :            : }
        2407                 :            :
        2408                 :            : /*[clinic input]
        2409                 :            : _ssl._SSLSocket.read
        2410                 :            :     size as len: Py_ssize_t
        2411                 :            :     [
        2412                 :            :     buffer: Py_buffer(accept={rwbuffer})
        2413                 :            :     ]
        2414                 :            :     /
        2415                 :            :
        2416                 :            : Read up to size bytes from the SSL socket.
        2417                 :            : [clinic start generated code]*/
        2418                 :            :
        2419                 :            : static PyObject *
        2420                 :          0 : _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len,
        2421                 :            :                           int group_right_1, Py_buffer *buffer)
        2422                 :            : /*[clinic end generated code: output=49b16e6406023734 input=ec48bf622be1c4a1]*/
        2423                 :            : {
        2424                 :          0 :     PyObject *dest = NULL;
        2425                 :            :     char *mem;
        2426                 :          0 :     size_t count = 0;
        2427                 :            :     int retval;
        2428                 :            :     int sockstate;
        2429                 :            :     _PySSLError err;
        2430                 :            :     int nonblocking;
        2431         [ #  # ]:          0 :     PySocketSockObject *sock = GET_SOCKET(self);
        2432                 :          0 :     _PyTime_t timeout, deadline = 0;
        2433                 :            :     int has_timeout;
        2434                 :            :
        2435   [ #  #  #  # ]:          0 :     if (!group_right_1 && len < 0) {
        2436                 :          0 :         PyErr_SetString(PyExc_ValueError, "size should not be negative");
        2437                 :          0 :         return NULL;
        2438                 :            :     }
        2439                 :            :
        2440         [ #  # ]:          0 :     if (sock != NULL) {
        2441         [ #  # ]:          0 :         if (((PyObject*)sock) == Py_None) {
        2442                 :          0 :             _setSSLError(get_state_sock(self),
        2443                 :            :                          "Underlying socket connection gone",
        2444                 :            :                          PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);
        2445                 :          0 :             return NULL;
        2446                 :            :         }
        2447                 :          0 :         Py_INCREF(sock);
        2448                 :            :     }
        2449                 :            :
        2450         [ #  # ]:          0 :     if (!group_right_1) {
        2451                 :          0 :         dest = PyBytes_FromStringAndSize(NULL, len);
        2452         [ #  # ]:          0 :         if (dest == NULL)
        2453                 :          0 :             goto error;
        2454         [ #  # ]:          0 :         if (len == 0) {
        2455                 :          0 :             Py_XDECREF(sock);
        2456                 :          0 :             return dest;
        2457                 :            :         }
        2458                 :          0 :         mem = PyBytes_AS_STRING(dest);
        2459                 :            :     }
        2460                 :            :     else {
        2461                 :          0 :         mem = buffer->buf;
        2462   [ #  #  #  # ]:          0 :         if (len <= 0 || len > buffer->len) {
        2463                 :          0 :             len = (int) buffer->len;
        2464         [ #  # ]:          0 :             if (buffer->len != len) {
        2465                 :          0 :                 PyErr_SetString(PyExc_OverflowError,
        2466                 :            :                                 "maximum length can't fit in a C 'int'");
        2467                 :          0 :                 goto error;
        2468                 :            :             }
        2469         [ #  # ]:          0 :             if (len == 0) {
        2470                 :          0 :                 count = 0;
        2471                 :          0 :                 goto done;
        2472                 :            :             }
        2473                 :            :         }
        2474                 :            :     }
        2475                 :            :
        2476         [ #  # ]:          0 :     if (sock != NULL) {
        2477                 :            :         /* just in case the blocking state of the socket has been changed */
        2478                 :          0 :         nonblocking = (sock->sock_timeout >= 0);
        2479                 :          0 :         BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
        2480                 :          0 :         BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
        2481                 :            :     }
        2482                 :            :
        2483         [ #  # ]:          0 :     timeout = GET_SOCKET_TIMEOUT(sock);
        2484                 :          0 :     has_timeout = (timeout > 0);
        2485         [ #  # ]:          0 :     if (has_timeout)
        2486                 :          0 :         deadline = _PyDeadline_Init(timeout);
        2487                 :            :
        2488                 :            :     do {
        2489                 :          0 :         PySSL_BEGIN_ALLOW_THREADS
        2490                 :          0 :         retval = SSL_read_ex(self->ssl, mem, (size_t)len, &count);
        2491                 :          0 :         err = _PySSL_errno(retval == 0, self->ssl, retval);
        2492                 :          0 :         PySSL_END_ALLOW_THREADS
        2493                 :          0 :         self->err = err;
        2494                 :            :
        2495         [ #  # ]:          0 :         if (PyErr_CheckSignals())
        2496                 :          0 :             goto error;
        2497                 :            :
        2498         [ #  # ]:          0 :         if (has_timeout) {
        2499                 :          0 :             timeout = _PyDeadline_Get(deadline);
        2500                 :            :         }
        2501                 :            :
        2502         [ #  # ]:          0 :         if (err.ssl == SSL_ERROR_WANT_READ) {
        2503                 :          0 :             sockstate = PySSL_select(sock, 0, timeout);
        2504         [ #  # ]:          0 :         } else if (err.ssl == SSL_ERROR_WANT_WRITE) {
        2505                 :          0 :             sockstate = PySSL_select(sock, 1, timeout);
        2506   [ #  #  #  # ]:          0 :         } else if (err.ssl == SSL_ERROR_ZERO_RETURN &&
        2507                 :          0 :                    SSL_get_shutdown(self->ssl) == SSL_RECEIVED_SHUTDOWN)
        2508                 :            :         {
        2509                 :          0 :             count = 0;
        2510                 :          0 :             goto done;
        2511                 :            :         }
        2512                 :            :         else
        2513                 :          0 :             sockstate = SOCKET_OPERATION_OK;
        2514                 :            :
        2515         [ #  # ]:          0 :         if (sockstate == SOCKET_HAS_TIMED_OUT) {
        2516                 :          0 :             PyErr_SetString(PyExc_TimeoutError,
        2517                 :            :                             "The read operation timed out");
        2518                 :          0 :             goto error;
        2519         [ #  # ]:          0 :         } else if (sockstate == SOCKET_IS_NONBLOCKING) {
        2520                 :          0 :             break;
        2521                 :            :         }
        2522                 :          0 :     } while (err.ssl == SSL_ERROR_WANT_READ ||
        2523   [ #  #  #  # ]:          0 :              err.ssl == SSL_ERROR_WANT_WRITE);
        2524                 :            :
        2525         [ #  # ]:          0 :     if (retval == 0) {
        2526                 :          0 :         PySSL_SetError(self, retval, __FILE__, __LINE__);
        2527                 :          0 :         goto error;
        2528                 :            :     }
        2529         [ #  # ]:          0 :     if (self->exc != NULL)
        2530                 :          0 :         goto error;
        2531                 :            :
        2532                 :          0 : done:
        2533                 :          0 :     Py_XDECREF(sock);
        2534         [ #  # ]:          0 :     if (!group_right_1) {
        2535                 :          0 :         _PyBytes_Resize(&dest, count);
        2536                 :          0 :         return dest;
        2537                 :            :     }
        2538                 :            :     else {
        2539                 :          0 :         return PyLong_FromSize_t(count);
        2540                 :            :     }
        2541                 :            :
        2542                 :          0 : error:
        2543                 :          0 :     PySSL_ChainExceptions(self);
        2544                 :          0 :     Py_XDECREF(sock);
        2545         [ #  # ]:          0 :     if (!group_right_1)
        2546                 :          0 :         Py_XDECREF(dest);
        2547                 :          0 :     return NULL;
        2548                 :            : }
        2549                 :            :
        2550                 :            : /*[clinic input]
        2551                 :            : _ssl._SSLSocket.shutdown
        2552                 :            :
        2553                 :            : Does the SSL shutdown handshake with the remote end.
        2554                 :            : [clinic start generated code]*/
        2555                 :            :
        2556                 :            : static PyObject *
        2557                 :          0 : _ssl__SSLSocket_shutdown_impl(PySSLSocket *self)
        2558                 :            : /*[clinic end generated code: output=ca1aa7ed9d25ca42 input=11d39e69b0a2bf4a]*/
        2559                 :            : {
        2560                 :            :     _PySSLError err;
        2561                 :            :     int sockstate, nonblocking, ret;
        2562                 :          0 :     int zeros = 0;
        2563         [ #  # ]:          0 :     PySocketSockObject *sock = GET_SOCKET(self);
        2564                 :          0 :     _PyTime_t timeout, deadline = 0;
        2565                 :            :     int has_timeout;
        2566                 :            :
        2567         [ #  # ]:          0 :     if (sock != NULL) {
        2568                 :            :         /* Guard against closed socket */
        2569   [ #  #  #  # ]:          0 :         if ((((PyObject*)sock) == Py_None) || (sock->sock_fd == INVALID_SOCKET)) {
        2570                 :          0 :             _setSSLError(get_state_sock(self),
        2571                 :            :                          "Underlying socket connection gone",
        2572                 :            :                          PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);
        2573                 :          0 :             return NULL;
        2574                 :            :         }
        2575                 :          0 :         Py_INCREF(sock);
        2576                 :            :
        2577                 :            :         /* Just in case the blocking state of the socket has been changed */
        2578                 :          0 :         nonblocking = (sock->sock_timeout >= 0);
        2579                 :          0 :         BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
        2580                 :          0 :         BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
        2581                 :            :     }
        2582                 :            :
        2583         [ #  # ]:          0 :     timeout = GET_SOCKET_TIMEOUT(sock);
        2584                 :          0 :     has_timeout = (timeout > 0);
        2585         [ #  # ]:          0 :     if (has_timeout) {
        2586                 :          0 :         deadline = _PyDeadline_Init(timeout);
        2587                 :            :     }
        2588                 :            :
        2589                 :            :     while (1) {
        2590                 :          0 :         PySSL_BEGIN_ALLOW_THREADS
        2591                 :            :         /* Disable read-ahead so that unwrap can work correctly.
        2592                 :            :          * Otherwise OpenSSL might read in too much data,
        2593                 :            :          * eating clear text data that happens to be
        2594                 :            :          * transmitted after the SSL shutdown.
        2595                 :            :          * Should be safe to call repeatedly every time this
        2596                 :            :          * function is used and the shutdown_seen_zero != 0
        2597                 :            :          * condition is met.
        2598                 :            :          */
        2599         [ #  # ]:          0 :         if (self->shutdown_seen_zero)
        2600                 :          0 :             SSL_set_read_ahead(self->ssl, 0);
        2601                 :          0 :         ret = SSL_shutdown(self->ssl);
        2602                 :          0 :         err = _PySSL_errno(ret < 0, self->ssl, ret);
        2603                 :          0 :         PySSL_END_ALLOW_THREADS
        2604                 :          0 :         self->err = err;
        2605                 :            :
        2606                 :            :         /* If err == 1, a secure shutdown with SSL_shutdown() is complete */
        2607         [ #  # ]:          0 :         if (ret > 0)
        2608                 :          0 :             break;
        2609         [ #  # ]:          0 :         if (ret == 0) {
        2610                 :            :             /* Don't loop endlessly; instead preserve legacy
        2611                 :            :                behaviour of trying SSL_shutdown() only twice.
        2612                 :            :                This looks necessary for OpenSSL < 0.9.8m */
        2613         [ #  # ]:          0 :             if (++zeros > 1)
        2614                 :          0 :                 break;
        2615                 :            :             /* Shutdown was sent, now try receiving */
        2616                 :          0 :             self->shutdown_seen_zero = 1;
        2617                 :          0 :             continue;
        2618                 :            :         }
        2619                 :            :
        2620         [ #  # ]:          0 :         if (has_timeout) {
        2621                 :          0 :             timeout = _PyDeadline_Get(deadline);
        2622                 :            :         }
        2623                 :            :
        2624                 :            :         /* Possibly retry shutdown until timeout or failure */
        2625         [ #  # ]:          0 :         if (err.ssl == SSL_ERROR_WANT_READ)
        2626                 :          0 :             sockstate = PySSL_select(sock, 0, timeout);
        2627         [ #  # ]:          0 :         else if (err.ssl == SSL_ERROR_WANT_WRITE)
        2628                 :          0 :             sockstate = PySSL_select(sock, 1, timeout);
        2629                 :            :         else
        2630                 :          0 :             break;
        2631                 :            :
        2632         [ #  # ]:          0 :         if (sockstate == SOCKET_HAS_TIMED_OUT) {
        2633         [ #  # ]:          0 :             if (err.ssl == SSL_ERROR_WANT_READ)
        2634                 :          0 :                 PyErr_SetString(PyExc_TimeoutError,
        2635                 :            :                                 "The read operation timed out");
        2636                 :            :             else
        2637                 :          0 :                 PyErr_SetString(PyExc_TimeoutError,
        2638                 :            :                                 "The write operation timed out");
        2639                 :          0 :             goto error;
        2640                 :            :         }
        2641         [ #  # ]:          0 :         else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {
        2642                 :          0 :             PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
        2643                 :            :                             "Underlying socket too large for select().");
        2644                 :          0 :             goto error;
        2645                 :            :         }
        2646         [ #  # ]:          0 :         else if (sockstate != SOCKET_OPERATION_OK)
        2647                 :            :             /* Retain the SSL error code */
        2648                 :          0 :             break;
        2649                 :            :     }
        2650         [ #  # ]:          0 :     if (ret < 0) {
        2651                 :          0 :         Py_XDECREF(sock);
        2652                 :          0 :         PySSL_SetError(self, ret, __FILE__, __LINE__);
        2653                 :          0 :         return NULL;
        2654                 :            :     }
        2655         [ #  # ]:          0 :     if (self->exc != NULL)
        2656                 :          0 :         goto error;
        2657         [ #  # ]:          0 :     if (sock)
        2658                 :            :         /* It's already INCREF'ed */
        2659                 :          0 :         return (PyObject *) sock;
        2660                 :            :     else
        2661                 :          0 :         Py_RETURN_NONE;
        2662                 :            :
        2663                 :          0 : error:
        2664                 :          0 :     Py_XDECREF(sock);
        2665                 :          0 :     PySSL_ChainExceptions(self);
        2666                 :          0 :     return NULL;
        2667                 :            : }
        2668                 :            :
        2669                 :            : /*[clinic input]
        2670                 :            : _ssl._SSLSocket.get_channel_binding
        2671                 :            :    cb_type: str = "tls-unique"
        2672                 :            :
        2673                 :            : Get channel binding data for current connection.
        2674                 :            :
        2675                 :            : Raise ValueError if the requested `cb_type` is not supported.  Return bytes
        2676                 :            : of the data or None if the data is not available (e.g. before the handshake).
        2677                 :            : Only 'tls-unique' channel binding data from RFC 5929 is supported.
        2678                 :            : [clinic start generated code]*/
        2679                 :            :
        2680                 :            : static PyObject *
        2681                 :          0 : _ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
        2682                 :            :                                          const char *cb_type)
        2683                 :            : /*[clinic end generated code: output=34bac9acb6a61d31 input=08b7e43b99c17d41]*/
        2684                 :            : {
        2685                 :            :     char buf[PySSL_CB_MAXLEN];
        2686                 :            :     size_t len;
        2687                 :            :
        2688         [ #  # ]:          0 :     if (strcmp(cb_type, "tls-unique") == 0) {
        2689         [ #  # ]:          0 :         if (SSL_session_reused(self->ssl) ^ !self->socket_type) {
        2690                 :            :             /* if session is resumed XOR we are the client */
        2691                 :          0 :             len = SSL_get_finished(self->ssl, buf, PySSL_CB_MAXLEN);
        2692                 :            :         }
        2693                 :            :         else {
        2694                 :            :             /* if a new session XOR we are the server */
        2695                 :          0 :             len = SSL_get_peer_finished(self->ssl, buf, PySSL_CB_MAXLEN);
        2696                 :            :         }
        2697                 :            :     }
        2698                 :            :     else {
        2699                 :          0 :         PyErr_Format(
        2700                 :            :             PyExc_ValueError,
        2701                 :            :             "'%s' channel binding type not implemented",
        2702                 :            :             cb_type
        2703                 :            :         );
        2704                 :          0 :         return NULL;
        2705                 :            :     }
        2706                 :            :
        2707                 :            :     /* It cannot be negative in current OpenSSL version as of July 2011 */
        2708         [ #  # ]:          0 :     if (len == 0)
        2709                 :          0 :         Py_RETURN_NONE;
        2710                 :            :
        2711                 :          0 :     return PyBytes_FromStringAndSize(buf, len);
        2712                 :            : }
        2713                 :            :
        2714                 :            : /*[clinic input]
        2715                 :            : _ssl._SSLSocket.verify_client_post_handshake
        2716                 :            :
        2717                 :            : Initiate TLS 1.3 post-handshake authentication
        2718                 :            : [clinic start generated code]*/
        2719                 :            :
        2720                 :            : static PyObject *
        2721                 :          0 : _ssl__SSLSocket_verify_client_post_handshake_impl(PySSLSocket *self)
        2722                 :            : /*[clinic end generated code: output=532147f3b1341425 input=6bfa874810a3d889]*/
        2723                 :            : {
        2724                 :            : #ifdef TLS1_3_VERSION
        2725                 :          0 :     int err = SSL_verify_client_post_handshake(self->ssl);
        2726         [ #  # ]:          0 :     if (err == 0)
        2727                 :          0 :         return _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
        2728                 :            :     else
        2729                 :          0 :         Py_RETURN_NONE;
        2730                 :            : #else
        2731                 :            :     PyErr_SetString(PyExc_NotImplementedError,
        2732                 :            :                     "Post-handshake auth is not supported by your "
        2733                 :            :                     "OpenSSL version.");
        2734                 :            :     return NULL;
        2735                 :            : #endif
        2736                 :            : }
        2737                 :            :
        2738                 :            : static SSL_SESSION*
        2739                 :          0 : _ssl_session_dup(SSL_SESSION *session) {
        2740                 :          0 :     SSL_SESSION *newsession = NULL;
        2741                 :            :     int slen;
        2742                 :          0 :     unsigned char *senc = NULL, *p;
        2743                 :            :     const unsigned char *const_p;
        2744                 :            :
        2745         [ #  # ]:          0 :     if (session == NULL) {
        2746                 :          0 :         PyErr_SetString(PyExc_ValueError, "Invalid session");
        2747                 :          0 :         goto error;
        2748                 :            :     }
        2749                 :            :
        2750                 :            :     /* get length */
        2751                 :          0 :     slen = i2d_SSL_SESSION(session, NULL);
        2752   [ #  #  #  # ]:          0 :     if (slen == 0 || slen > 0xFF00) {
        2753                 :          0 :         PyErr_SetString(PyExc_ValueError, "i2d() failed.");
        2754                 :          0 :         goto error;
        2755                 :            :     }
        2756         [ #  # ]:          0 :     if ((senc = PyMem_Malloc(slen)) == NULL) {
        2757                 :          0 :         PyErr_NoMemory();
        2758                 :          0 :         goto error;
        2759                 :            :     }
        2760                 :          0 :     p = senc;
        2761         [ #  # ]:          0 :     if (!i2d_SSL_SESSION(session, &p)) {
        2762                 :          0 :         PyErr_SetString(PyExc_ValueError, "i2d() failed.");
        2763                 :          0 :         goto error;
        2764                 :            :     }
        2765                 :          0 :     const_p = senc;
        2766                 :          0 :     newsession = d2i_SSL_SESSION(NULL, &const_p, slen);
        2767         [ #  # ]:          0 :     if (session == NULL) {
        2768                 :          0 :         goto error;
        2769                 :            :     }
        2770                 :          0 :     PyMem_Free(senc);
        2771                 :          0 :     return newsession;
        2772                 :          0 :   error:
        2773         [ #  # ]:          0 :     if (senc != NULL) {
        2774                 :          0 :         PyMem_Free(senc);
        2775                 :            :     }
        2776                 :          0 :     return NULL;
        2777                 :            : }
        2778                 :            :
        2779                 :            : static PyObject *
        2780                 :          0 : PySSL_get_session(PySSLSocket *self, void *closure) {
        2781                 :            :     /* get_session can return sessions from a server-side connection,
        2782                 :            :      * it does not check for handshake done or client socket. */
        2783                 :            :     PySSLSession *pysess;
        2784                 :            :     SSL_SESSION *session;
        2785                 :            :
        2786                 :            :     /* duplicate session as workaround for session bug in OpenSSL 1.1.0,
        2787                 :            :      * https://github.com/openssl/openssl/issues/1550 */
        2788                 :          0 :     session = SSL_get0_session(self->ssl);  /* borrowed reference */
        2789         [ #  # ]:          0 :     if (session == NULL) {
        2790                 :          0 :         Py_RETURN_NONE;
        2791                 :            :     }
        2792         [ #  # ]:          0 :     if ((session = _ssl_session_dup(session)) == NULL) {
        2793                 :          0 :         return NULL;
        2794                 :            :     }
        2795                 :          0 :     session = SSL_get1_session(self->ssl);
        2796         [ #  # ]:          0 :     if (session == NULL) {
        2797                 :          0 :         Py_RETURN_NONE;
        2798                 :            :     }
        2799                 :          0 :     pysess = PyObject_GC_New(PySSLSession, self->ctx->state->PySSLSession_Type);
        2800         [ #  # ]:          0 :     if (pysess == NULL) {
        2801                 :          0 :         SSL_SESSION_free(session);
        2802                 :          0 :         return NULL;
        2803                 :            :     }
        2804                 :            :
        2805                 :            :     assert(self->ctx);
        2806                 :          0 :     pysess->ctx = (PySSLContext*)Py_NewRef(self->ctx);
        2807                 :          0 :     pysess->session = session;
        2808                 :          0 :     PyObject_GC_Track(pysess);
        2809                 :          0 :     return (PyObject *)pysess;
        2810                 :            : }
        2811                 :            :
        2812                 :          0 : static int PySSL_set_session(PySSLSocket *self, PyObject *value,
        2813                 :            :                              void *closure)
        2814                 :            :                               {
        2815                 :            :     PySSLSession *pysess;
        2816                 :            :     SSL_SESSION *session;
        2817                 :            :     int result;
        2818                 :            :
        2819         [ #  # ]:          0 :     if (!Py_IS_TYPE(value, get_state_sock(self)->PySSLSession_Type)) {
        2820                 :          0 :         PyErr_SetString(PyExc_TypeError, "Value is not a SSLSession.");
        2821                 :          0 :         return -1;
        2822                 :            :     }
        2823                 :          0 :     pysess = (PySSLSession *)value;
        2824                 :            :
        2825         [ #  # ]:          0 :     if (self->ctx->ctx != pysess->ctx->ctx) {
        2826                 :          0 :         PyErr_SetString(PyExc_ValueError,
        2827                 :            :                         "Session refers to a different SSLContext.");
        2828                 :          0 :         return -1;
        2829                 :            :     }
        2830         [ #  # ]:          0 :     if (self->socket_type != PY_SSL_CLIENT) {
        2831                 :          0 :         PyErr_SetString(PyExc_ValueError,
        2832                 :            :                         "Cannot set session for server-side SSLSocket.");
        2833                 :          0 :         return -1;
        2834                 :            :     }
        2835         [ #  # ]:          0 :     if (SSL_is_init_finished(self->ssl)) {
        2836                 :          0 :         PyErr_SetString(PyExc_ValueError,
        2837                 :            :                         "Cannot set session after handshake.");
        2838                 :          0 :         return -1;
        2839                 :            :     }
        2840                 :            :     /* duplicate session */
        2841         [ #  # ]:          0 :     if ((session = _ssl_session_dup(pysess->session)) == NULL) {
        2842                 :          0 :         return -1;
        2843                 :            :     }
        2844                 :          0 :     result = SSL_set_session(self->ssl, session);
        2845                 :            :     /* free duplicate, SSL_set_session() bumps ref count */
        2846                 :          0 :     SSL_SESSION_free(session);
        2847         [ #  # ]:          0 :     if (result == 0) {
        2848                 :          0 :         _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
        2849                 :          0 :         return -1;
        2850                 :            :     }
        2851                 :          0 :     return 0;
        2852                 :            : }
        2853                 :            :
        2854                 :            : PyDoc_STRVAR(PySSL_set_session_doc,
        2855                 :            : "_setter_session(session)\n\
        2856                 :            : \
        2857                 :            : Get / set SSLSession.");
        2858                 :            :
        2859                 :            : static PyObject *
        2860                 :          0 : PySSL_get_session_reused(PySSLSocket *self, void *closure) {
        2861         [ #  # ]:          0 :     if (SSL_session_reused(self->ssl)) {
        2862                 :          0 :         Py_RETURN_TRUE;
        2863                 :            :     } else {
        2864                 :          0 :         Py_RETURN_FALSE;
        2865                 :            :     }
        2866                 :            : }
        2867                 :            :
        2868                 :            : PyDoc_STRVAR(PySSL_get_session_reused_doc,
        2869                 :            : "Was the client session reused during handshake?");
        2870                 :            :
        2871                 :            : static PyGetSetDef ssl_getsetlist[] = {
        2872                 :            :     {"context", (getter) PySSL_get_context,
        2873                 :            :                 (setter) PySSL_set_context, PySSL_set_context_doc},
        2874                 :            :     {"server_side", (getter) PySSL_get_server_side, NULL,
        2875                 :            :                     PySSL_get_server_side_doc},
        2876                 :            :     {"server_hostname", (getter) PySSL_get_server_hostname, NULL,
        2877                 :            :                         PySSL_get_server_hostname_doc},
        2878                 :            :     {"owner", (getter) PySSL_get_owner, (setter) PySSL_set_owner,
        2879                 :            :               PySSL_get_owner_doc},
        2880                 :            :     {"session", (getter) PySSL_get_session,
        2881                 :            :                 (setter) PySSL_set_session, PySSL_set_session_doc},
        2882                 :            :     {"session_reused", (getter) PySSL_get_session_reused, NULL,
        2883                 :            :               PySSL_get_session_reused_doc},
        2884                 :            :     {NULL},            /* sentinel */
        2885                 :            : };
        2886                 :            :
        2887                 :            : static PyMethodDef PySSLMethods[] = {
        2888                 :            :     _SSL__SSLSOCKET_DO_HANDSHAKE_METHODDEF
        2889                 :            :     _SSL__SSLSOCKET_WRITE_METHODDEF
        2890                 :            :     _SSL__SSLSOCKET_READ_METHODDEF
        2891                 :            :     _SSL__SSLSOCKET_PENDING_METHODDEF
        2892                 :            :     _SSL__SSLSOCKET_GETPEERCERT_METHODDEF
        2893                 :            :     _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF
        2894                 :            :     _SSL__SSLSOCKET_CIPHER_METHODDEF
        2895                 :            :     _SSL__SSLSOCKET_SHARED_CIPHERS_METHODDEF
        2896                 :            :     _SSL__SSLSOCKET_VERSION_METHODDEF
        2897                 :            :     _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF
        2898                 :            :     _SSL__SSLSOCKET_COMPRESSION_METHODDEF
        2899                 :            :     _SSL__SSLSOCKET_SHUTDOWN_METHODDEF
        2900                 :            :     _SSL__SSLSOCKET_VERIFY_CLIENT_POST_HANDSHAKE_METHODDEF
        2901                 :            :     _SSL__SSLSOCKET_GET_UNVERIFIED_CHAIN_METHODDEF
        2902                 :            :     _SSL__SSLSOCKET_GET_VERIFIED_CHAIN_METHODDEF
        2903                 :            :     {NULL, NULL}
        2904                 :            : };
        2905                 :            :
        2906                 :            : static PyType_Slot PySSLSocket_slots[] = {
        2907                 :            :     {Py_tp_methods, PySSLMethods},
        2908                 :            :     {Py_tp_getset, ssl_getsetlist},
        2909                 :            :     {Py_tp_dealloc, PySSL_dealloc},
        2910                 :            :     {Py_tp_traverse, PySSL_traverse},
        2911                 :            :     {Py_tp_clear, PySSL_clear},
        2912                 :            :     {0, 0},
        2913                 :            : };
        2914                 :            :
        2915                 :            : static PyType_Spec PySSLSocket_spec = {
        2916                 :            :     .name = "_ssl._SSLSocket",
        2917                 :            :     .basicsize = sizeof(PySSLSocket),
        2918                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |
        2919                 :            :               Py_TPFLAGS_HAVE_GC),
        2920                 :            :     .slots = PySSLSocket_slots,
        2921                 :            : };
        2922                 :            :
        2923                 :            : /*
        2924                 :            :  * _SSLContext objects
        2925                 :            :  */
        2926                 :            :
        2927                 :            : static int
        2928                 :          0 : _set_verify_mode(PySSLContext *self, enum py_ssl_cert_requirements n)
        2929                 :            : {
        2930                 :            :     int mode;
        2931                 :          0 :     int (*verify_cb)(int, X509_STORE_CTX *) = NULL;
        2932                 :            :
        2933   [ #  #  #  # ]:          0 :     switch(n) {
        2934                 :          0 :     case PY_SSL_CERT_NONE:
        2935                 :          0 :         mode = SSL_VERIFY_NONE;
        2936                 :          0 :         break;
        2937                 :          0 :     case PY_SSL_CERT_OPTIONAL:
        2938                 :          0 :         mode = SSL_VERIFY_PEER;
        2939                 :          0 :         break;
        2940                 :          0 :     case PY_SSL_CERT_REQUIRED:
        2941                 :          0 :         mode = SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
        2942                 :          0 :         break;
        2943                 :          0 :     default:
        2944                 :          0 :          PyErr_SetString(PyExc_ValueError,
        2945                 :            :                         "invalid value for verify_mode");
        2946                 :          0 :         return -1;
        2947                 :            :     }
        2948                 :            :
        2949                 :            :     /* bpo-37428: newPySSLSocket() sets SSL_VERIFY_POST_HANDSHAKE flag for
        2950                 :            :      * server sockets and SSL_set_post_handshake_auth() for client. */
        2951                 :            :
        2952                 :            :     /* keep current verify cb */
        2953                 :          0 :     verify_cb = SSL_CTX_get_verify_callback(self->ctx);
        2954                 :          0 :     SSL_CTX_set_verify(self->ctx, mode, verify_cb);
        2955                 :          0 :     return 0;
        2956                 :            : }
        2957                 :            :
        2958                 :            : /*[clinic input]
        2959                 :            : @classmethod
        2960                 :            : _ssl._SSLContext.__new__
        2961                 :            :     protocol as proto_version: int
        2962                 :            :     /
        2963                 :            : [clinic start generated code]*/
        2964                 :            :
        2965                 :            : static PyObject *
        2966                 :          0 : _ssl__SSLContext_impl(PyTypeObject *type, int proto_version)
        2967                 :            : /*[clinic end generated code: output=2cf0d7a0741b6bd1 input=8d58a805b95fc534]*/
        2968                 :            : {
        2969                 :            :     PySSLContext *self;
        2970                 :            :     long options;
        2971                 :          0 :     const SSL_METHOD *method = NULL;
        2972                 :          0 :     SSL_CTX *ctx = NULL;
        2973                 :            :     X509_VERIFY_PARAM *params;
        2974                 :            :     int result;
        2975                 :            :
        2976                 :            :    /* slower approach, walk MRO and get borrowed reference to module.
        2977                 :            :     * PyType_GetModuleByDef is required for SSLContext subclasses */
        2978                 :          0 :     PyObject *module = PyType_GetModuleByDef(type, &_sslmodule_def);
        2979         [ #  # ]:          0 :     if (module == NULL) {
        2980                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
        2981                 :            :                         "Cannot find internal module state");
        2982                 :          0 :         return NULL;
        2983                 :            :     }
        2984                 :            :
        2985   [ #  #  #  #  :          0 :     switch(proto_version) {
                    #  #  # ]
        2986                 :            : #if defined(SSL3_VERSION) && !defined(OPENSSL_NO_SSL3)
        2987                 :            :     case PY_SSL_VERSION_SSL3:
        2988                 :            :         PY_SSL_DEPRECATED("ssl.PROTOCOL_SSLv3 is deprecated", 2, NULL);
        2989                 :            :         method = SSLv3_method();
        2990                 :            :         break;
        2991                 :            : #endif
        2992                 :            : #if (defined(TLS1_VERSION) && \
        2993                 :            :         !defined(OPENSSL_NO_TLS1) && \
        2994                 :            :         !defined(OPENSSL_NO_TLS1_METHOD))
        2995                 :          0 :     case PY_SSL_VERSION_TLS1:
        2996         [ #  # ]:          0 :         PY_SSL_DEPRECATED("ssl.PROTOCOL_TLSv1 is deprecated", 2, NULL);
        2997                 :          0 :         method = TLSv1_method();
        2998                 :          0 :         break;
        2999                 :            : #endif
        3000                 :            : #if (defined(TLS1_1_VERSION) && \
        3001                 :            :         !defined(OPENSSL_NO_TLS1_1) && \
        3002                 :            :         !defined(OPENSSL_NO_TLS1_1_METHOD))
        3003                 :          0 :     case PY_SSL_VERSION_TLS1_1:
        3004         [ #  # ]:          0 :         PY_SSL_DEPRECATED("ssl.PROTOCOL_TLSv1_1 is deprecated", 2, NULL);
        3005                 :          0 :         method = TLSv1_1_method();
        3006                 :          0 :         break;
        3007                 :            : #endif
        3008                 :            : #if (defined(TLS1_2_VERSION) && \
        3009                 :            :         !defined(OPENSSL_NO_TLS1_2) && \
        3010                 :            :         !defined(OPENSSL_NO_TLS1_2_METHOD))
        3011                 :          0 :     case PY_SSL_VERSION_TLS1_2:
        3012         [ #  # ]:          0 :         PY_SSL_DEPRECATED("ssl.PROTOCOL_TLSv1_2 is deprecated", 2, NULL);
        3013                 :          0 :         method = TLSv1_2_method();
        3014                 :          0 :         break;
        3015                 :            : #endif
        3016                 :          0 :     case PY_SSL_VERSION_TLS:
        3017         [ #  # ]:          0 :         PY_SSL_DEPRECATED("ssl.PROTOCOL_TLS is deprecated", 2, NULL);
        3018                 :          0 :         method = TLS_method();
        3019                 :          0 :         break;
        3020                 :          0 :     case PY_SSL_VERSION_TLS_CLIENT:
        3021                 :          0 :         method = TLS_client_method();
        3022                 :          0 :         break;
        3023                 :          0 :     case PY_SSL_VERSION_TLS_SERVER:
        3024                 :          0 :         method = TLS_server_method();
        3025                 :          0 :         break;
        3026                 :          0 :     default:
        3027                 :          0 :         method = NULL;
        3028                 :            :     }
        3029                 :            :
        3030         [ #  # ]:          0 :     if (method == NULL) {
        3031                 :          0 :         PyErr_Format(PyExc_ValueError,
        3032                 :            :                      "invalid or unsupported protocol version %i",
        3033                 :            :                      proto_version);
        3034                 :          0 :         return NULL;
        3035                 :            :     }
        3036                 :            :
        3037                 :          0 :     PySSL_BEGIN_ALLOW_THREADS
        3038                 :          0 :     ctx = SSL_CTX_new(method);
        3039                 :          0 :     PySSL_END_ALLOW_THREADS
        3040                 :            :
        3041         [ #  # ]:          0 :     if (ctx == NULL) {
        3042                 :          0 :         _setSSLError(get_ssl_state(module), NULL, 0, __FILE__, __LINE__);
        3043                 :          0 :         return NULL;
        3044                 :            :     }
        3045                 :            :
        3046                 :            :     assert(type != NULL && type->tp_alloc != NULL);
        3047                 :          0 :     self = (PySSLContext *) type->tp_alloc(type, 0);
        3048         [ #  # ]:          0 :     if (self == NULL) {
        3049                 :          0 :         SSL_CTX_free(ctx);
        3050                 :          0 :         return NULL;
        3051                 :            :     }
        3052                 :          0 :     self->ctx = ctx;
        3053                 :          0 :     self->hostflags = X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS;
        3054                 :          0 :     self->protocol = proto_version;
        3055                 :          0 :     self->msg_cb = NULL;
        3056                 :          0 :     self->keylog_filename = NULL;
        3057                 :          0 :     self->keylog_bio = NULL;
        3058                 :          0 :     self->alpn_protocols = NULL;
        3059                 :          0 :     self->set_sni_cb = NULL;
        3060                 :          0 :     self->state = get_ssl_state(module);
        3061                 :            :
        3062                 :            :     /* Don't check host name by default */
        3063         [ #  # ]:          0 :     if (proto_version == PY_SSL_VERSION_TLS_CLIENT) {
        3064                 :          0 :         self->check_hostname = 1;
        3065         [ #  # ]:          0 :         if (_set_verify_mode(self, PY_SSL_CERT_REQUIRED) == -1) {
        3066                 :          0 :             Py_DECREF(self);
        3067                 :          0 :             return NULL;
        3068                 :            :         }
        3069                 :            :     } else {
        3070                 :          0 :         self->check_hostname = 0;
        3071         [ #  # ]:          0 :         if (_set_verify_mode(self, PY_SSL_CERT_NONE) == -1) {
        3072                 :          0 :             Py_DECREF(self);
        3073                 :          0 :             return NULL;
        3074                 :            :         }
        3075                 :            :     }
        3076                 :            :     /* Defaults */
        3077                 :          0 :     options = SSL_OP_ALL & ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
        3078         [ #  # ]:          0 :     if (proto_version != PY_SSL_VERSION_SSL2)
        3079                 :          0 :         options |= SSL_OP_NO_SSLv2;
        3080         [ #  # ]:          0 :     if (proto_version != PY_SSL_VERSION_SSL3)
        3081                 :          0 :         options |= SSL_OP_NO_SSLv3;
        3082                 :            :     /* Minimal security flags for server and client side context.
        3083                 :            :      * Client sockets ignore server-side parameters. */
        3084                 :            : #ifdef SSL_OP_NO_COMPRESSION
        3085                 :          0 :     options |= SSL_OP_NO_COMPRESSION;
        3086                 :            : #endif
        3087                 :            : #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
        3088                 :          0 :     options |= SSL_OP_CIPHER_SERVER_PREFERENCE;
        3089                 :            : #endif
        3090                 :            : #ifdef SSL_OP_SINGLE_DH_USE
        3091                 :          0 :     options |= SSL_OP_SINGLE_DH_USE;
        3092                 :            : #endif
        3093                 :            : #ifdef SSL_OP_SINGLE_ECDH_USE
        3094                 :          0 :     options |= SSL_OP_SINGLE_ECDH_USE;
        3095                 :            : #endif
        3096                 :            : #ifdef SSL_OP_IGNORE_UNEXPECTED_EOF
        3097                 :            :     /* Make OpenSSL 3.0.0 behave like 1.1.1 */
        3098                 :            :     options |= SSL_OP_IGNORE_UNEXPECTED_EOF;
        3099                 :            : #endif
        3100                 :          0 :     SSL_CTX_set_options(self->ctx, options);
        3101                 :            :
        3102                 :            :     /* A bare minimum cipher list without completely broken cipher suites.
        3103                 :            :      * It's far from perfect but gives users a better head start. */
        3104         [ #  # ]:          0 :     if (proto_version != PY_SSL_VERSION_SSL2) {
        3105                 :            : #if PY_SSL_DEFAULT_CIPHERS == 2
        3106                 :            :         /* stick to OpenSSL's default settings */
        3107                 :            :         result = 1;
        3108                 :            : #else
        3109                 :          0 :         result = SSL_CTX_set_cipher_list(ctx, PY_SSL_DEFAULT_CIPHER_STRING);
        3110                 :            : #endif
        3111                 :            :     } else {
        3112                 :            :         /* SSLv2 needs MD5 */
        3113                 :          0 :         result = SSL_CTX_set_cipher_list(ctx, "HIGH:!aNULL:!eNULL");
        3114                 :            :     }
        3115         [ #  # ]:          0 :     if (result == 0) {
        3116                 :          0 :         Py_DECREF(self);
        3117                 :          0 :         ERR_clear_error();
        3118                 :          0 :         PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
        3119                 :            :                         "No cipher can be selected.");
        3120                 :          0 :         goto error;
        3121                 :            :     }
        3122                 :            : #ifdef PY_SSL_MIN_PROTOCOL
        3123         [ #  # ]:          0 :     switch(proto_version) {
        3124                 :          0 :     case PY_SSL_VERSION_TLS:
        3125                 :            :     case PY_SSL_VERSION_TLS_CLIENT:
        3126                 :            :     case PY_SSL_VERSION_TLS_SERVER:
        3127                 :          0 :         result = SSL_CTX_set_min_proto_version(ctx, PY_SSL_MIN_PROTOCOL);
        3128         [ #  # ]:          0 :         if (result == 0) {
        3129                 :          0 :             PyErr_Format(PyExc_ValueError,
        3130                 :            :                          "Failed to set minimum protocol 0x%x",
        3131                 :            :                           PY_SSL_MIN_PROTOCOL);
        3132                 :          0 :             goto error;
        3133                 :            :         }
        3134                 :          0 :         break;
        3135                 :          0 :     default:
        3136                 :          0 :         break;
        3137                 :            :     }
        3138                 :            : #endif
        3139                 :            :
        3140                 :            :     /* Set SSL_MODE_RELEASE_BUFFERS. This potentially greatly reduces memory
        3141                 :            :        usage for no cost at all. */
        3142                 :          0 :     SSL_CTX_set_mode(self->ctx, SSL_MODE_RELEASE_BUFFERS);
        3143                 :            :
        3144                 :            : #define SID_CTX "Python"
        3145                 :          0 :     SSL_CTX_set_session_id_context(self->ctx, (const unsigned char *) SID_CTX,
        3146                 :            :                                    sizeof(SID_CTX));
        3147                 :            : #undef SID_CTX
        3148                 :            :
        3149                 :          0 :     params = SSL_CTX_get0_param(self->ctx);
        3150                 :            :     /* Improve trust chain building when cross-signed intermediate
        3151                 :            :        certificates are present. See https://bugs.python.org/issue23476. */
        3152                 :          0 :     X509_VERIFY_PARAM_set_flags(params, X509_V_FLAG_TRUSTED_FIRST);
        3153                 :          0 :     X509_VERIFY_PARAM_set_hostflags(params, self->hostflags);
        3154                 :            :
        3155                 :            : #ifdef TLS1_3_VERSION
        3156                 :          0 :     self->post_handshake_auth = 0;
        3157                 :          0 :     SSL_CTX_set_post_handshake_auth(self->ctx, self->post_handshake_auth);
        3158                 :            : #endif
        3159                 :            :
        3160                 :          0 :     return (PyObject *)self;
        3161                 :          0 :   error:
        3162                 :          0 :     Py_XDECREF(self);
        3163                 :          0 :     ERR_clear_error();
        3164                 :          0 :     return NULL;
        3165                 :            : }
        3166                 :            :
        3167                 :            : static int
        3168                 :          0 : context_traverse(PySSLContext *self, visitproc visit, void *arg)
        3169                 :            : {
        3170   [ #  #  #  # ]:          0 :     Py_VISIT(self->set_sni_cb);
        3171   [ #  #  #  # ]:          0 :     Py_VISIT(self->msg_cb);
        3172   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
        3173                 :          0 :     return 0;
        3174                 :            : }
        3175                 :            :
        3176                 :            : static int
        3177                 :          0 : context_clear(PySSLContext *self)
        3178                 :            : {
        3179         [ #  # ]:          0 :     Py_CLEAR(self->set_sni_cb);
        3180         [ #  # ]:          0 :     Py_CLEAR(self->msg_cb);
        3181         [ #  # ]:          0 :     Py_CLEAR(self->keylog_filename);
        3182         [ #  # ]:          0 :     if (self->keylog_bio != NULL) {
        3183                 :          0 :         PySSL_BEGIN_ALLOW_THREADS
        3184                 :          0 :         BIO_free_all(self->keylog_bio);
        3185                 :          0 :         PySSL_END_ALLOW_THREADS
        3186                 :          0 :         self->keylog_bio = NULL;
        3187                 :            :     }
        3188                 :          0 :     return 0;
        3189                 :            : }
        3190                 :            :
        3191                 :            : static void
        3192                 :          0 : context_dealloc(PySSLContext *self)
        3193                 :            : {
        3194                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
        3195                 :            :     /* bpo-31095: UnTrack is needed before calling any callbacks */
        3196                 :          0 :     PyObject_GC_UnTrack(self);
        3197                 :          0 :     context_clear(self);
        3198                 :          0 :     SSL_CTX_free(self->ctx);
        3199                 :          0 :     PyMem_FREE(self->alpn_protocols);
        3200                 :          0 :     Py_TYPE(self)->tp_free(self);
        3201                 :          0 :     Py_DECREF(tp);
        3202                 :          0 : }
        3203                 :            :
        3204                 :            : /*[clinic input]
        3205                 :            : _ssl._SSLContext.set_ciphers
        3206                 :            :     cipherlist: str
        3207                 :            :     /
        3208                 :            : [clinic start generated code]*/
        3209                 :            :
        3210                 :            : static PyObject *
        3211                 :          0 : _ssl__SSLContext_set_ciphers_impl(PySSLContext *self, const char *cipherlist)
        3212                 :            : /*[clinic end generated code: output=3a3162f3557c0f3f input=a7ac931b9f3ca7fc]*/
        3213                 :            : {
        3214                 :          0 :     int ret = SSL_CTX_set_cipher_list(self->ctx, cipherlist);
        3215         [ #  # ]:          0 :     if (ret == 0) {
        3216                 :            :         /* Clearing the error queue is necessary on some OpenSSL versions,
        3217                 :            :            otherwise the error will be reported again when another SSL call
        3218                 :            :            is done. */
        3219                 :          0 :         ERR_clear_error();
        3220                 :          0 :         PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
        3221                 :            :                         "No cipher can be selected.");
        3222                 :          0 :         return NULL;
        3223                 :            :     }
        3224                 :          0 :     Py_RETURN_NONE;
        3225                 :            : }
        3226                 :            :
        3227                 :            : /*[clinic input]
        3228                 :            : _ssl._SSLContext.get_ciphers
        3229                 :            : [clinic start generated code]*/
        3230                 :            :
        3231                 :            : static PyObject *
        3232                 :          0 : _ssl__SSLContext_get_ciphers_impl(PySSLContext *self)
        3233                 :            : /*[clinic end generated code: output=a56e4d68a406dfc4 input=a2aadc9af89b79c5]*/
        3234                 :            : {
        3235                 :          0 :     SSL *ssl = NULL;
        3236                 :          0 :     STACK_OF(SSL_CIPHER) *sk = NULL;
        3237                 :            :     const SSL_CIPHER *cipher;
        3238                 :          0 :     int i=0;
        3239                 :          0 :     PyObject *result = NULL, *dct;
        3240                 :            :
        3241                 :          0 :     ssl = SSL_new(self->ctx);
        3242         [ #  # ]:          0 :     if (ssl == NULL) {
        3243                 :          0 :         _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3244                 :          0 :         goto exit;
        3245                 :            :     }
        3246                 :          0 :     sk = SSL_get_ciphers(ssl);
        3247                 :            :
        3248                 :          0 :     result = PyList_New(sk_SSL_CIPHER_num(sk));
        3249         [ #  # ]:          0 :     if (result == NULL) {
        3250                 :          0 :         goto exit;
        3251                 :            :     }
        3252                 :            :
        3253         [ #  # ]:          0 :     for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
        3254                 :          0 :         cipher = sk_SSL_CIPHER_value(sk, i);
        3255                 :          0 :         dct = cipher_to_dict(cipher);
        3256         [ #  # ]:          0 :         if (dct == NULL) {
        3257         [ #  # ]:          0 :             Py_CLEAR(result);
        3258                 :          0 :             goto exit;
        3259                 :            :         }
        3260                 :          0 :         PyList_SET_ITEM(result, i, dct);
        3261                 :            :     }
        3262                 :            :
        3263                 :          0 :   exit:
        3264         [ #  # ]:          0 :     if (ssl != NULL)
        3265                 :          0 :         SSL_free(ssl);
        3266                 :          0 :     return result;
        3267                 :            :
        3268                 :            : }
        3269                 :            :
        3270                 :            :
        3271                 :            : static int
        3272                 :          0 : do_protocol_selection(int alpn, unsigned char **out, unsigned char *outlen,
        3273                 :            :                       const unsigned char *server_protocols, unsigned int server_protocols_len,
        3274                 :            :                       const unsigned char *client_protocols, unsigned int client_protocols_len)
        3275                 :            : {
        3276                 :            :     int ret;
        3277         [ #  # ]:          0 :     if (client_protocols == NULL) {
        3278                 :          0 :         client_protocols = (unsigned char *)"";
        3279                 :          0 :         client_protocols_len = 0;
        3280                 :            :     }
        3281         [ #  # ]:          0 :     if (server_protocols == NULL) {
        3282                 :          0 :         server_protocols = (unsigned char *)"";
        3283                 :          0 :         server_protocols_len = 0;
        3284                 :            :     }
        3285                 :            :
        3286                 :          0 :     ret = SSL_select_next_proto(out, outlen,
        3287                 :            :                                 server_protocols, server_protocols_len,
        3288                 :            :                                 client_protocols, client_protocols_len);
        3289   [ #  #  #  # ]:          0 :     if (alpn && ret != OPENSSL_NPN_NEGOTIATED)
        3290                 :          0 :         return SSL_TLSEXT_ERR_NOACK;
        3291                 :            :
        3292                 :          0 :     return SSL_TLSEXT_ERR_OK;
        3293                 :            : }
        3294                 :            :
        3295                 :            : static int
        3296                 :          0 : _selectALPN_cb(SSL *s,
        3297                 :            :               const unsigned char **out, unsigned char *outlen,
        3298                 :            :               const unsigned char *client_protocols, unsigned int client_protocols_len,
        3299                 :            :               void *args)
        3300                 :            : {
        3301                 :          0 :     PySSLContext *ctx = (PySSLContext *)args;
        3302                 :          0 :     return do_protocol_selection(1, (unsigned char **)out, outlen,
        3303                 :          0 :                                  ctx->alpn_protocols, ctx->alpn_protocols_len,
        3304                 :            :                                  client_protocols, client_protocols_len);
        3305                 :            : }
        3306                 :            :
        3307                 :            : /*[clinic input]
        3308                 :            : _ssl._SSLContext._set_alpn_protocols
        3309                 :            :     protos: Py_buffer
        3310                 :            :     /
        3311                 :            : [clinic start generated code]*/
        3312                 :            :
        3313                 :            : static PyObject *
        3314                 :          0 : _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self,
        3315                 :            :                                           Py_buffer *protos)
        3316                 :            : /*[clinic end generated code: output=87599a7f76651a9b input=9bba964595d519be]*/
        3317                 :            : {
        3318         [ #  # ]:          0 :     if ((size_t)protos->len > UINT_MAX) {
        3319                 :          0 :         PyErr_Format(PyExc_OverflowError,
        3320                 :            :             "protocols longer than %u bytes", UINT_MAX);
        3321                 :          0 :         return NULL;
        3322                 :            :     }
        3323                 :            :
        3324                 :          0 :     PyMem_Free(self->alpn_protocols);
        3325                 :          0 :     self->alpn_protocols = PyMem_Malloc(protos->len);
        3326         [ #  # ]:          0 :     if (!self->alpn_protocols)
        3327                 :          0 :         return PyErr_NoMemory();
        3328                 :          0 :     memcpy(self->alpn_protocols, protos->buf, protos->len);
        3329                 :          0 :     self->alpn_protocols_len = (unsigned int)protos->len;
        3330                 :            :
        3331         [ #  # ]:          0 :     if (SSL_CTX_set_alpn_protos(self->ctx, self->alpn_protocols, self->alpn_protocols_len))
        3332                 :          0 :         return PyErr_NoMemory();
        3333                 :          0 :     SSL_CTX_set_alpn_select_cb(self->ctx, _selectALPN_cb, self);
        3334                 :            :
        3335                 :          0 :     Py_RETURN_NONE;
        3336                 :            : }
        3337                 :            :
        3338                 :            : static PyObject *
        3339                 :          0 : get_verify_mode(PySSLContext *self, void *c)
        3340                 :            : {
        3341                 :            :     /* ignore SSL_VERIFY_CLIENT_ONCE and SSL_VERIFY_POST_HANDSHAKE */
        3342                 :          0 :     int mask = (SSL_VERIFY_NONE | SSL_VERIFY_PEER |
        3343                 :            :                 SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
        3344   [ #  #  #  # ]:          0 :     switch (SSL_CTX_get_verify_mode(self->ctx) & mask) {
        3345                 :          0 :     case SSL_VERIFY_NONE:
        3346                 :          0 :         return PyLong_FromLong(PY_SSL_CERT_NONE);
        3347                 :          0 :     case SSL_VERIFY_PEER:
        3348                 :          0 :         return PyLong_FromLong(PY_SSL_CERT_OPTIONAL);
        3349                 :          0 :     case SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT:
        3350                 :          0 :         return PyLong_FromLong(PY_SSL_CERT_REQUIRED);
        3351                 :            :     }
        3352                 :          0 :     PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
        3353                 :            :                     "invalid return value from SSL_CTX_get_verify_mode");
        3354                 :          0 :     return NULL;
        3355                 :            : }
        3356                 :            :
        3357                 :            : static int
        3358                 :          0 : set_verify_mode(PySSLContext *self, PyObject *arg, void *c)
        3359                 :            : {
        3360                 :            :     int n;
        3361         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "i", &n))
        3362                 :          0 :         return -1;
        3363   [ #  #  #  # ]:          0 :     if (n == PY_SSL_CERT_NONE && self->check_hostname) {
        3364                 :          0 :         PyErr_SetString(PyExc_ValueError,
        3365                 :            :                         "Cannot set verify_mode to CERT_NONE when "
        3366                 :            :                         "check_hostname is enabled.");
        3367                 :          0 :         return -1;
        3368                 :            :     }
        3369                 :          0 :     return _set_verify_mode(self, n);
        3370                 :            : }
        3371                 :            :
        3372                 :            : static PyObject *
        3373                 :          0 : get_verify_flags(PySSLContext *self, void *c)
        3374                 :            : {
        3375                 :            :     X509_VERIFY_PARAM *param;
        3376                 :            :     unsigned long flags;
        3377                 :            :
        3378                 :          0 :     param = SSL_CTX_get0_param(self->ctx);
        3379                 :          0 :     flags = X509_VERIFY_PARAM_get_flags(param);
        3380                 :          0 :     return PyLong_FromUnsignedLong(flags);
        3381                 :            : }
        3382                 :            :
        3383                 :            : static int
        3384                 :          0 : set_verify_flags(PySSLContext *self, PyObject *arg, void *c)
        3385                 :            : {
        3386                 :            :     X509_VERIFY_PARAM *param;
        3387                 :            :     unsigned long new_flags, flags, set, clear;
        3388                 :            :
        3389         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "k", &new_flags))
        3390                 :          0 :         return -1;
        3391                 :          0 :     param = SSL_CTX_get0_param(self->ctx);
        3392                 :          0 :     flags = X509_VERIFY_PARAM_get_flags(param);
        3393                 :          0 :     clear = flags & ~new_flags;
        3394                 :          0 :     set = ~flags & new_flags;
        3395         [ #  # ]:          0 :     if (clear) {
        3396         [ #  # ]:          0 :         if (!X509_VERIFY_PARAM_clear_flags(param, clear)) {
        3397                 :          0 :             _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3398                 :          0 :             return -1;
        3399                 :            :         }
        3400                 :            :     }
        3401         [ #  # ]:          0 :     if (set) {
        3402         [ #  # ]:          0 :         if (!X509_VERIFY_PARAM_set_flags(param, set)) {
        3403                 :          0 :             _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3404                 :          0 :             return -1;
        3405                 :            :         }
        3406                 :            :     }
        3407                 :          0 :     return 0;
        3408                 :            : }
        3409                 :            :
        3410                 :            : /* Getter and setter for protocol version */
        3411                 :            : static int
        3412                 :          0 : set_min_max_proto_version(PySSLContext *self, PyObject *arg, int what)
        3413                 :            : {
        3414                 :            :     long v;
        3415                 :            :     int result;
        3416                 :            :
        3417         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "l", &v))
        3418                 :          0 :         return -1;
        3419         [ #  # ]:          0 :     if (v > INT_MAX) {
        3420                 :          0 :         PyErr_SetString(PyExc_OverflowError, "Option is too long");
        3421                 :          0 :         return -1;
        3422                 :            :     }
        3423                 :            :
        3424         [ #  # ]:          0 :     switch(self->protocol) {
        3425                 :          0 :     case PY_SSL_VERSION_TLS_CLIENT:  /* fall through */
        3426                 :            :     case PY_SSL_VERSION_TLS_SERVER:  /* fall through */
        3427                 :            :     case PY_SSL_VERSION_TLS:
        3428                 :          0 :         break;
        3429                 :          0 :     default:
        3430                 :          0 :         PyErr_SetString(
        3431                 :            :             PyExc_ValueError,
        3432                 :            :             "The context's protocol doesn't support modification of "
        3433                 :            :             "highest and lowest version."
        3434                 :            :         );
        3435                 :          0 :         return -1;
        3436                 :            :     }
        3437                 :            :
        3438                 :            :     /* check for deprecations and supported values */
        3439   [ #  #  #  #  :          0 :     switch(v) {
                          # ]
        3440                 :          0 :         case PY_PROTO_SSLv3:
        3441         [ #  # ]:          0 :             PY_SSL_DEPRECATED("ssl.TLSVersion.SSLv3 is deprecated", 2, -1);
        3442                 :          0 :             break;
        3443                 :          0 :         case PY_PROTO_TLSv1:
        3444         [ #  # ]:          0 :             PY_SSL_DEPRECATED("ssl.TLSVersion.TLSv1 is deprecated", 2, -1);
        3445                 :          0 :             break;
        3446                 :          0 :         case PY_PROTO_TLSv1_1:
        3447         [ #  # ]:          0 :             PY_SSL_DEPRECATED("ssl.TLSVersion.TLSv1_1 is deprecated", 2, -1);
        3448                 :          0 :             break;
        3449                 :          0 :         case PY_PROTO_MINIMUM_SUPPORTED:
        3450                 :            :         case PY_PROTO_MAXIMUM_SUPPORTED:
        3451                 :            :         case PY_PROTO_TLSv1_2:
        3452                 :            :         case PY_PROTO_TLSv1_3:
        3453                 :            :             /* ok */
        3454                 :          0 :             break;
        3455                 :          0 :         default:
        3456                 :          0 :             PyErr_Format(PyExc_ValueError,
        3457                 :            :                      "Unsupported TLS/SSL version 0x%x", v);
        3458                 :          0 :             return -1;
        3459                 :            :     }
        3460                 :            :
        3461         [ #  # ]:          0 :     if (what == 0) {
        3462      [ #  #  # ]:          0 :         switch(v) {
        3463                 :          0 :         case PY_PROTO_MINIMUM_SUPPORTED:
        3464                 :          0 :             v = 0;
        3465                 :          0 :             break;
        3466                 :          0 :         case PY_PROTO_MAXIMUM_SUPPORTED:
        3467                 :            :             /* Emulate max for set_min_proto_version */
        3468                 :          0 :             v = PY_PROTO_MAXIMUM_AVAILABLE;
        3469                 :          0 :             break;
        3470                 :          0 :         default:
        3471                 :          0 :             break;
        3472                 :            :         }
        3473                 :          0 :         result = SSL_CTX_set_min_proto_version(self->ctx, v);
        3474                 :            :     }
        3475                 :            :     else {
        3476      [ #  #  # ]:          0 :         switch(v) {
        3477                 :          0 :         case PY_PROTO_MAXIMUM_SUPPORTED:
        3478                 :          0 :             v = 0;
        3479                 :          0 :             break;
        3480                 :          0 :         case PY_PROTO_MINIMUM_SUPPORTED:
        3481                 :            :             /* Emulate max for set_min_proto_version */
        3482                 :          0 :             v = PY_PROTO_MINIMUM_AVAILABLE;
        3483                 :          0 :             break;
        3484                 :          0 :         default:
        3485                 :          0 :             break;
        3486                 :            :         }
        3487                 :          0 :         result = SSL_CTX_set_max_proto_version(self->ctx, v);
        3488                 :            :     }
        3489         [ #  # ]:          0 :     if (result == 0) {
        3490                 :          0 :         PyErr_Format(PyExc_ValueError,
        3491                 :            :                      "Unsupported protocol version 0x%x", v);
        3492                 :          0 :         return -1;
        3493                 :            :     }
        3494                 :          0 :     return 0;
        3495                 :            : }
        3496                 :            :
        3497                 :            : static PyObject *
        3498                 :          0 : get_minimum_version(PySSLContext *self, void *c)
        3499                 :            : {
        3500                 :          0 :     int v = SSL_CTX_get_min_proto_version(self->ctx);
        3501         [ #  # ]:          0 :     if (v == 0) {
        3502                 :          0 :         v = PY_PROTO_MINIMUM_SUPPORTED;
        3503                 :            :     }
        3504                 :          0 :     return PyLong_FromLong(v);
        3505                 :            : }
        3506                 :            :
        3507                 :            : static int
        3508                 :          0 : set_minimum_version(PySSLContext *self, PyObject *arg, void *c)
        3509                 :            : {
        3510                 :          0 :     return set_min_max_proto_version(self, arg, 0);
        3511                 :            : }
        3512                 :            :
        3513                 :            : static PyObject *
        3514                 :          0 : get_maximum_version(PySSLContext *self, void *c)
        3515                 :            : {
        3516                 :          0 :     int v = SSL_CTX_get_max_proto_version(self->ctx);
        3517         [ #  # ]:          0 :     if (v == 0) {
        3518                 :          0 :         v = PY_PROTO_MAXIMUM_SUPPORTED;
        3519                 :            :     }
        3520                 :          0 :     return PyLong_FromLong(v);
        3521                 :            : }
        3522                 :            :
        3523                 :            : static int
        3524                 :          0 : set_maximum_version(PySSLContext *self, PyObject *arg, void *c)
        3525                 :            : {
        3526                 :          0 :     return set_min_max_proto_version(self, arg, 1);
        3527                 :            : }
        3528                 :            :
        3529                 :            : #ifdef TLS1_3_VERSION
        3530                 :            : static PyObject *
        3531                 :          0 : get_num_tickets(PySSLContext *self, void *c)
        3532                 :            : {
        3533                 :          0 :     return PyLong_FromSize_t(SSL_CTX_get_num_tickets(self->ctx));
        3534                 :            : }
        3535                 :            :
        3536                 :            : static int
        3537                 :          0 : set_num_tickets(PySSLContext *self, PyObject *arg, void *c)
        3538                 :            : {
        3539                 :            :     long num;
        3540         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "l", &num))
        3541                 :          0 :         return -1;
        3542         [ #  # ]:          0 :     if (num < 0) {
        3543                 :          0 :         PyErr_SetString(PyExc_ValueError, "value must be non-negative");
        3544                 :          0 :         return -1;
        3545                 :            :     }
        3546         [ #  # ]:          0 :     if (self->protocol != PY_SSL_VERSION_TLS_SERVER) {
        3547                 :          0 :         PyErr_SetString(PyExc_ValueError,
        3548                 :            :                         "SSLContext is not a server context.");
        3549                 :          0 :         return -1;
        3550                 :            :     }
        3551         [ #  # ]:          0 :     if (SSL_CTX_set_num_tickets(self->ctx, num) != 1) {
        3552                 :          0 :         PyErr_SetString(PyExc_ValueError, "failed to set num tickets.");
        3553                 :          0 :         return -1;
        3554                 :            :     }
        3555                 :          0 :     return 0;
        3556                 :            : }
        3557                 :            :
        3558                 :            : PyDoc_STRVAR(PySSLContext_num_tickets_doc,
        3559                 :            : "Control the number of TLSv1.3 session tickets");
        3560                 :            : #endif /* TLS1_3_VERSION */
        3561                 :            :
        3562                 :            : static PyObject *
        3563                 :          0 : get_security_level(PySSLContext *self, void *c)
        3564                 :            : {
        3565                 :          0 :     return PyLong_FromLong(SSL_CTX_get_security_level(self->ctx));
        3566                 :            : }
        3567                 :            : PyDoc_STRVAR(PySSLContext_security_level_doc, "The current security level");
        3568                 :            :
        3569                 :            : static PyObject *
        3570                 :          0 : get_options(PySSLContext *self, void *c)
        3571                 :            : {
        3572                 :          0 :     return PyLong_FromLong(SSL_CTX_get_options(self->ctx));
        3573                 :            : }
        3574                 :            :
        3575                 :            : static int
        3576                 :          0 : set_options(PySSLContext *self, PyObject *arg, void *c)
        3577                 :            : {
        3578                 :            :     long new_opts, opts, set, clear;
        3579                 :          0 :     long opt_no = (
        3580                 :            :         SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 |
        3581                 :            :         SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_TLSv1_3
        3582                 :            :     );
        3583                 :            :
        3584         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "l", &new_opts))
        3585                 :          0 :         return -1;
        3586                 :          0 :     opts = SSL_CTX_get_options(self->ctx);
        3587                 :          0 :     clear = opts & ~new_opts;
        3588                 :          0 :     set = ~opts & new_opts;
        3589                 :            :
        3590         [ #  # ]:          0 :     if ((set & opt_no) != 0) {
        3591         [ #  # ]:          0 :         if (_ssl_deprecated("ssl.OP_NO_SSL*/ssl.OP_NO_TLS* options are "
        3592                 :            :                             "deprecated", 2) < 0) {
        3593                 :          0 :             return -1;
        3594                 :            :         }
        3595                 :            :     }
        3596         [ #  # ]:          0 :     if (clear) {
        3597                 :          0 :         SSL_CTX_clear_options(self->ctx, clear);
        3598                 :            :     }
        3599         [ #  # ]:          0 :     if (set)
        3600                 :          0 :         SSL_CTX_set_options(self->ctx, set);
        3601                 :          0 :     return 0;
        3602                 :            : }
        3603                 :            :
        3604                 :            : static PyObject *
        3605                 :          0 : get_host_flags(PySSLContext *self, void *c)
        3606                 :            : {
        3607                 :          0 :     return PyLong_FromUnsignedLong(self->hostflags);
        3608                 :            : }
        3609                 :            :
        3610                 :            : static int
        3611                 :          0 : set_host_flags(PySSLContext *self, PyObject *arg, void *c)
        3612                 :            : {
        3613                 :            :     X509_VERIFY_PARAM *param;
        3614                 :          0 :     unsigned int new_flags = 0;
        3615                 :            :
        3616         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "I", &new_flags))
        3617                 :          0 :         return -1;
        3618                 :            :
        3619                 :          0 :     param = SSL_CTX_get0_param(self->ctx);
        3620                 :          0 :     self->hostflags = new_flags;
        3621                 :          0 :     X509_VERIFY_PARAM_set_hostflags(param, new_flags);
        3622                 :          0 :     return 0;
        3623                 :            : }
        3624                 :            :
        3625                 :            : static PyObject *
        3626                 :          0 : get_check_hostname(PySSLContext *self, void *c)
        3627                 :            : {
        3628                 :          0 :     return PyBool_FromLong(self->check_hostname);
        3629                 :            : }
        3630                 :            :
        3631                 :            : static int
        3632                 :          0 : set_check_hostname(PySSLContext *self, PyObject *arg, void *c)
        3633                 :            : {
        3634                 :            :     int check_hostname;
        3635         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "p", &check_hostname))
        3636                 :          0 :         return -1;
        3637   [ #  #  #  # ]:          0 :     if (check_hostname &&
        3638                 :          0 :             SSL_CTX_get_verify_mode(self->ctx) == SSL_VERIFY_NONE) {
        3639                 :            :         /* check_hostname = True sets verify_mode = CERT_REQUIRED */
        3640         [ #  # ]:          0 :         if (_set_verify_mode(self, PY_SSL_CERT_REQUIRED) == -1) {
        3641                 :          0 :             return -1;
        3642                 :            :         }
        3643                 :            :     }
        3644                 :          0 :     self->check_hostname = check_hostname;
        3645                 :          0 :     return 0;
        3646                 :            : }
        3647                 :            :
        3648                 :            : static PyObject *
        3649                 :          0 : get_post_handshake_auth(PySSLContext *self, void *c) {
        3650                 :            : #if TLS1_3_VERSION
        3651                 :          0 :     return PyBool_FromLong(self->post_handshake_auth);
        3652                 :            : #else
        3653                 :            :     Py_RETURN_NONE;
        3654                 :            : #endif
        3655                 :            : }
        3656                 :            :
        3657                 :            : #if TLS1_3_VERSION
        3658                 :            : static int
        3659                 :          0 : set_post_handshake_auth(PySSLContext *self, PyObject *arg, void *c) {
        3660         [ #  # ]:          0 :     if (arg == NULL) {
        3661                 :          0 :         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
        3662                 :          0 :         return -1;
        3663                 :            :     }
        3664                 :          0 :     int pha = PyObject_IsTrue(arg);
        3665                 :            :
        3666         [ #  # ]:          0 :     if (pha == -1) {
        3667                 :          0 :         return -1;
        3668                 :            :     }
        3669                 :          0 :     self->post_handshake_auth = pha;
        3670                 :            :
        3671                 :            :     /* bpo-37428: newPySSLSocket() sets SSL_VERIFY_POST_HANDSHAKE flag for
        3672                 :            :      * server sockets and SSL_set_post_handshake_auth() for client. */
        3673                 :            :
        3674                 :          0 :     return 0;
        3675                 :            : }
        3676                 :            : #endif
        3677                 :            :
        3678                 :            : static PyObject *
        3679                 :          0 : get_protocol(PySSLContext *self, void *c) {
        3680                 :          0 :     return PyLong_FromLong(self->protocol);
        3681                 :            : }
        3682                 :            :
        3683                 :            : typedef struct {
        3684                 :            :     PyThreadState *thread_state;
        3685                 :            :     PyObject *callable;
        3686                 :            :     char *password;
        3687                 :            :     int size;
        3688                 :            :     int error;
        3689                 :            : } _PySSLPasswordInfo;
        3690                 :            :
        3691                 :            : static int
        3692                 :          0 : _pwinfo_set(_PySSLPasswordInfo *pw_info, PyObject* password,
        3693                 :            :             const char *bad_type_error)
        3694                 :            : {
        3695                 :            :     /* Set the password and size fields of a _PySSLPasswordInfo struct
        3696                 :            :        from a unicode, bytes, or byte array object.
        3697                 :            :        The password field will be dynamically allocated and must be freed
        3698                 :            :        by the caller */
        3699                 :          0 :     PyObject *password_bytes = NULL;
        3700                 :          0 :     const char *data = NULL;
        3701                 :            :     Py_ssize_t size;
        3702                 :            :
        3703         [ #  # ]:          0 :     if (PyUnicode_Check(password)) {
        3704                 :          0 :         password_bytes = PyUnicode_AsUTF8String(password);
        3705         [ #  # ]:          0 :         if (!password_bytes) {
        3706                 :          0 :             goto error;
        3707                 :            :         }
        3708                 :          0 :         data = PyBytes_AS_STRING(password_bytes);
        3709                 :          0 :         size = PyBytes_GET_SIZE(password_bytes);
        3710         [ #  # ]:          0 :     } else if (PyBytes_Check(password)) {
        3711                 :          0 :         data = PyBytes_AS_STRING(password);
        3712                 :          0 :         size = PyBytes_GET_SIZE(password);
        3713         [ #  # ]:          0 :     } else if (PyByteArray_Check(password)) {
        3714                 :          0 :         data = PyByteArray_AS_STRING(password);
        3715                 :          0 :         size = PyByteArray_GET_SIZE(password);
        3716                 :            :     } else {
        3717                 :          0 :         PyErr_SetString(PyExc_TypeError, bad_type_error);
        3718                 :          0 :         goto error;
        3719                 :            :     }
        3720                 :            :
        3721         [ #  # ]:          0 :     if (size > (Py_ssize_t)INT_MAX) {
        3722                 :          0 :         PyErr_Format(PyExc_ValueError,
        3723                 :            :                      "password cannot be longer than %d bytes", INT_MAX);
        3724                 :          0 :         goto error;
        3725                 :            :     }
        3726                 :            :
        3727                 :          0 :     PyMem_Free(pw_info->password);
        3728                 :          0 :     pw_info->password = PyMem_Malloc(size);
        3729         [ #  # ]:          0 :     if (!pw_info->password) {
        3730                 :          0 :         PyErr_SetString(PyExc_MemoryError,
        3731                 :            :                         "unable to allocate password buffer");
        3732                 :          0 :         goto error;
        3733                 :            :     }
        3734                 :          0 :     memcpy(pw_info->password, data, size);
        3735                 :          0 :     pw_info->size = (int)size;
        3736                 :            :
        3737                 :          0 :     Py_XDECREF(password_bytes);
        3738                 :          0 :     return 1;
        3739                 :            :
        3740                 :          0 : error:
        3741                 :          0 :     Py_XDECREF(password_bytes);
        3742                 :          0 :     return 0;
        3743                 :            : }
        3744                 :            :
        3745                 :            : static int
        3746                 :          0 : _password_callback(char *buf, int size, int rwflag, void *userdata)
        3747                 :            : {
        3748                 :          0 :     _PySSLPasswordInfo *pw_info = (_PySSLPasswordInfo*) userdata;
        3749                 :          0 :     PyObject *fn_ret = NULL;
        3750                 :            :
        3751                 :          0 :     PySSL_END_ALLOW_THREADS_S(pw_info->thread_state);
        3752                 :            :
        3753         [ #  # ]:          0 :     if (pw_info->error) {
        3754                 :            :         /* already failed previously. OpenSSL 3.0.0-alpha14 invokes the
        3755                 :            :          * callback multiple times which can lead to fatal Python error in
        3756                 :            :          * exception check. */
        3757                 :          0 :         goto error;
        3758                 :            :     }
        3759                 :            :
        3760         [ #  # ]:          0 :     if (pw_info->callable) {
        3761                 :          0 :         fn_ret = PyObject_CallNoArgs(pw_info->callable);
        3762         [ #  # ]:          0 :         if (!fn_ret) {
        3763                 :            :             /* TODO: It would be nice to move _ctypes_add_traceback() into the
        3764                 :            :                core python API, so we could use it to add a frame here */
        3765                 :          0 :             goto error;
        3766                 :            :         }
        3767                 :            :
        3768         [ #  # ]:          0 :         if (!_pwinfo_set(pw_info, fn_ret,
        3769                 :            :                          "password callback must return a string")) {
        3770                 :          0 :             goto error;
        3771                 :            :         }
        3772         [ #  # ]:          0 :         Py_CLEAR(fn_ret);
        3773                 :            :     }
        3774                 :            :
        3775         [ #  # ]:          0 :     if (pw_info->size > size) {
        3776                 :          0 :         PyErr_Format(PyExc_ValueError,
        3777                 :            :                      "password cannot be longer than %d bytes", size);
        3778                 :          0 :         goto error;
        3779                 :            :     }
        3780                 :            :
        3781                 :          0 :     PySSL_BEGIN_ALLOW_THREADS_S(pw_info->thread_state);
        3782                 :          0 :     memcpy(buf, pw_info->password, pw_info->size);
        3783                 :          0 :     return pw_info->size;
        3784                 :            :
        3785                 :          0 : error:
        3786                 :          0 :     Py_XDECREF(fn_ret);
        3787                 :          0 :     PySSL_BEGIN_ALLOW_THREADS_S(pw_info->thread_state);
        3788                 :          0 :     pw_info->error = 1;
        3789                 :          0 :     return -1;
        3790                 :            : }
        3791                 :            :
        3792                 :            : /*[clinic input]
        3793                 :            : _ssl._SSLContext.load_cert_chain
        3794                 :            :     certfile: object
        3795                 :            :     keyfile: object = None
        3796                 :            :     password: object = None
        3797                 :            :
        3798                 :            : [clinic start generated code]*/
        3799                 :            :
        3800                 :            : static PyObject *
        3801                 :          0 : _ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
        3802                 :            :                                       PyObject *keyfile, PyObject *password)
        3803                 :            : /*[clinic end generated code: output=9480bc1c380e2095 input=30bc7e967ea01a58]*/
        3804                 :            : {
        3805                 :          0 :     PyObject *certfile_bytes = NULL, *keyfile_bytes = NULL;
        3806                 :          0 :     pem_password_cb *orig_passwd_cb = SSL_CTX_get_default_passwd_cb(self->ctx);
        3807                 :          0 :     void *orig_passwd_userdata = SSL_CTX_get_default_passwd_cb_userdata(self->ctx);
        3808                 :          0 :     _PySSLPasswordInfo pw_info = { NULL, NULL, NULL, 0, 0 };
        3809                 :            :     int r;
        3810                 :            :
        3811                 :          0 :     errno = 0;
        3812                 :          0 :     ERR_clear_error();
        3813         [ #  # ]:          0 :     if (keyfile == Py_None)
        3814                 :          0 :         keyfile = NULL;
        3815         [ #  # ]:          0 :     if (!PyUnicode_FSConverter(certfile, &certfile_bytes)) {
        3816         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_TypeError)) {
        3817                 :          0 :             PyErr_SetString(PyExc_TypeError,
        3818                 :            :                             "certfile should be a valid filesystem path");
        3819                 :            :         }
        3820                 :          0 :         return NULL;
        3821                 :            :     }
        3822   [ #  #  #  # ]:          0 :     if (keyfile && !PyUnicode_FSConverter(keyfile, &keyfile_bytes)) {
        3823         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_TypeError)) {
        3824                 :          0 :             PyErr_SetString(PyExc_TypeError,
        3825                 :            :                             "keyfile should be a valid filesystem path");
        3826                 :            :         }
        3827                 :          0 :         goto error;
        3828                 :            :     }
        3829         [ #  # ]:          0 :     if (password != Py_None) {
        3830         [ #  # ]:          0 :         if (PyCallable_Check(password)) {
        3831                 :          0 :             pw_info.callable = password;
        3832         [ #  # ]:          0 :         } else if (!_pwinfo_set(&pw_info, password,
        3833                 :            :                                 "password should be a string or callable")) {
        3834                 :          0 :             goto error;
        3835                 :            :         }
        3836                 :          0 :         SSL_CTX_set_default_passwd_cb(self->ctx, _password_callback);
        3837                 :          0 :         SSL_CTX_set_default_passwd_cb_userdata(self->ctx, &pw_info);
        3838                 :            :     }
        3839                 :          0 :     PySSL_BEGIN_ALLOW_THREADS_S(pw_info.thread_state);
        3840                 :          0 :     r = SSL_CTX_use_certificate_chain_file(self->ctx,
        3841                 :          0 :         PyBytes_AS_STRING(certfile_bytes));
        3842                 :          0 :     PySSL_END_ALLOW_THREADS_S(pw_info.thread_state);
        3843         [ #  # ]:          0 :     if (r != 1) {
        3844         [ #  # ]:          0 :         if (pw_info.error) {
        3845                 :          0 :             ERR_clear_error();
        3846                 :            :             /* the password callback has already set the error information */
        3847                 :            :         }
        3848         [ #  # ]:          0 :         else if (errno != 0) {
        3849                 :          0 :             ERR_clear_error();
        3850                 :          0 :             PyErr_SetFromErrno(PyExc_OSError);
        3851                 :            :         }
        3852                 :            :         else {
        3853                 :          0 :             _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3854                 :            :         }
        3855                 :          0 :         goto error;
        3856                 :            :     }
        3857                 :          0 :     PySSL_BEGIN_ALLOW_THREADS_S(pw_info.thread_state);
        3858                 :          0 :     r = SSL_CTX_use_PrivateKey_file(self->ctx,
        3859         [ #  # ]:          0 :         PyBytes_AS_STRING(keyfile ? keyfile_bytes : certfile_bytes),
        3860                 :            :         SSL_FILETYPE_PEM);
        3861                 :          0 :     PySSL_END_ALLOW_THREADS_S(pw_info.thread_state);
        3862         [ #  # ]:          0 :     Py_CLEAR(keyfile_bytes);
        3863         [ #  # ]:          0 :     Py_CLEAR(certfile_bytes);
        3864         [ #  # ]:          0 :     if (r != 1) {
        3865         [ #  # ]:          0 :         if (pw_info.error) {
        3866                 :          0 :             ERR_clear_error();
        3867                 :            :             /* the password callback has already set the error information */
        3868                 :            :         }
        3869         [ #  # ]:          0 :         else if (errno != 0) {
        3870                 :          0 :             ERR_clear_error();
        3871                 :          0 :             PyErr_SetFromErrno(PyExc_OSError);
        3872                 :            :         }
        3873                 :            :         else {
        3874                 :          0 :             _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3875                 :            :         }
        3876                 :          0 :         goto error;
        3877                 :            :     }
        3878                 :          0 :     PySSL_BEGIN_ALLOW_THREADS_S(pw_info.thread_state);
        3879                 :          0 :     r = SSL_CTX_check_private_key(self->ctx);
        3880                 :          0 :     PySSL_END_ALLOW_THREADS_S(pw_info.thread_state);
        3881         [ #  # ]:          0 :     if (r != 1) {
        3882                 :          0 :         _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3883                 :          0 :         goto error;
        3884                 :            :     }
        3885                 :          0 :     SSL_CTX_set_default_passwd_cb(self->ctx, orig_passwd_cb);
        3886                 :          0 :     SSL_CTX_set_default_passwd_cb_userdata(self->ctx, orig_passwd_userdata);
        3887                 :          0 :     PyMem_Free(pw_info.password);
        3888                 :          0 :     Py_RETURN_NONE;
        3889                 :            :
        3890                 :          0 : error:
        3891                 :          0 :     SSL_CTX_set_default_passwd_cb(self->ctx, orig_passwd_cb);
        3892                 :          0 :     SSL_CTX_set_default_passwd_cb_userdata(self->ctx, orig_passwd_userdata);
        3893                 :          0 :     PyMem_Free(pw_info.password);
        3894                 :          0 :     Py_XDECREF(keyfile_bytes);
        3895                 :          0 :     Py_XDECREF(certfile_bytes);
        3896                 :          0 :     return NULL;
        3897                 :            : }
        3898                 :            :
        3899                 :            : /* internal helper function, returns -1 on error
        3900                 :            :  */
        3901                 :            : static int
        3902                 :          0 : _add_ca_certs(PySSLContext *self, const void *data, Py_ssize_t len,
        3903                 :            :               int filetype)
        3904                 :            : {
        3905                 :          0 :     BIO *biobuf = NULL;
        3906                 :            :     X509_STORE *store;
        3907                 :          0 :     int retval = -1, err, loaded = 0;
        3908                 :            :
        3909                 :            :     assert(filetype == SSL_FILETYPE_ASN1 || filetype == SSL_FILETYPE_PEM);
        3910                 :            :
        3911         [ #  # ]:          0 :     if (len <= 0) {
        3912                 :          0 :         PyErr_SetString(PyExc_ValueError,
        3913                 :            :                         "Empty certificate data");
        3914                 :          0 :         return -1;
        3915         [ #  # ]:          0 :     } else if (len > INT_MAX) {
        3916                 :          0 :         PyErr_SetString(PyExc_OverflowError,
        3917                 :            :                         "Certificate data is too long.");
        3918                 :          0 :         return -1;
        3919                 :            :     }
        3920                 :            :
        3921                 :          0 :     biobuf = BIO_new_mem_buf(data, (int)len);
        3922         [ #  # ]:          0 :     if (biobuf == NULL) {
        3923                 :          0 :         _setSSLError(get_state_ctx(self), "Can't allocate buffer", 0, __FILE__, __LINE__);
        3924                 :          0 :         return -1;
        3925                 :            :     }
        3926                 :            :
        3927                 :          0 :     store = SSL_CTX_get_cert_store(self->ctx);
        3928                 :            :     assert(store != NULL);
        3929                 :            :
        3930                 :          0 :     while (1) {
        3931                 :          0 :         X509 *cert = NULL;
        3932                 :            :         int r;
        3933                 :            :
        3934         [ #  # ]:          0 :         if (filetype == SSL_FILETYPE_ASN1) {
        3935                 :          0 :             cert = d2i_X509_bio(biobuf, NULL);
        3936                 :            :         } else {
        3937                 :          0 :             cert = PEM_read_bio_X509(biobuf, NULL,
        3938                 :            :                                      SSL_CTX_get_default_passwd_cb(self->ctx),
        3939                 :            :                                      SSL_CTX_get_default_passwd_cb_userdata(self->ctx)
        3940                 :            :                                     );
        3941                 :            :         }
        3942         [ #  # ]:          0 :         if (cert == NULL) {
        3943                 :          0 :             break;
        3944                 :            :         }
        3945                 :          0 :         r = X509_STORE_add_cert(store, cert);
        3946                 :          0 :         X509_free(cert);
        3947         [ #  # ]:          0 :         if (!r) {
        3948                 :          0 :             err = ERR_peek_last_error();
        3949         [ #  # ]:          0 :             if ((ERR_GET_LIB(err) == ERR_LIB_X509) &&
        3950         [ #  # ]:          0 :                 (ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE)) {
        3951                 :            :                 /* cert already in hash table, not an error */
        3952                 :          0 :                 ERR_clear_error();
        3953                 :            :             } else {
        3954                 :            :                 break;
        3955                 :            :             }
        3956                 :            :         }
        3957                 :          0 :         loaded++;
        3958                 :            :     }
        3959                 :            :
        3960                 :          0 :     err = ERR_peek_last_error();
        3961         [ #  # ]:          0 :     if (loaded == 0) {
        3962                 :          0 :         const char *msg = NULL;
        3963         [ #  # ]:          0 :         if (filetype == SSL_FILETYPE_PEM) {
        3964                 :          0 :             msg = "no start line: cadata does not contain a certificate";
        3965                 :            :         } else {
        3966                 :          0 :             msg = "not enough data: cadata does not contain a certificate";
        3967                 :            :         }
        3968                 :          0 :         _setSSLError(get_state_ctx(self), msg, 0, __FILE__, __LINE__);
        3969                 :          0 :         retval = -1;
        3970         [ #  # ]:          0 :     } else if ((filetype == SSL_FILETYPE_ASN1) &&
        3971         [ #  # ]:          0 :                     (ERR_GET_LIB(err) == ERR_LIB_ASN1) &&
        3972         [ #  # ]:          0 :                     (ERR_GET_REASON(err) == ASN1_R_HEADER_TOO_LONG)) {
        3973                 :            :         /* EOF ASN1 file, not an error */
        3974                 :          0 :         ERR_clear_error();
        3975                 :          0 :         retval = 0;
        3976         [ #  # ]:          0 :     } else if ((filetype == SSL_FILETYPE_PEM) &&
        3977         [ #  # ]:          0 :                    (ERR_GET_LIB(err) == ERR_LIB_PEM) &&
        3978         [ #  # ]:          0 :                    (ERR_GET_REASON(err) == PEM_R_NO_START_LINE)) {
        3979                 :            :         /* EOF PEM file, not an error */
        3980                 :          0 :         ERR_clear_error();
        3981                 :          0 :         retval = 0;
        3982         [ #  # ]:          0 :     } else if (err != 0) {
        3983                 :          0 :         _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        3984                 :          0 :         retval = -1;
        3985                 :            :     } else {
        3986                 :          0 :         retval = 0;
        3987                 :            :     }
        3988                 :            :
        3989                 :          0 :     BIO_free(biobuf);
        3990                 :          0 :     return retval;
        3991                 :            : }
        3992                 :            :
        3993                 :            :
        3994                 :            : /*[clinic input]
        3995                 :            : _ssl._SSLContext.load_verify_locations
        3996                 :            :     cafile: object = None
        3997                 :            :     capath: object = None
        3998                 :            :     cadata: object = None
        3999                 :            :
        4000                 :            : [clinic start generated code]*/
        4001                 :            :
        4002                 :            : static PyObject *
        4003                 :          0 : _ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
        4004                 :            :                                             PyObject *cafile,
        4005                 :            :                                             PyObject *capath,
        4006                 :            :                                             PyObject *cadata)
        4007                 :            : /*[clinic end generated code: output=454c7e41230ca551 input=42ecfe258233e194]*/
        4008                 :            : {
        4009                 :          0 :     PyObject *cafile_bytes = NULL, *capath_bytes = NULL;
        4010                 :          0 :     const char *cafile_buf = NULL, *capath_buf = NULL;
        4011                 :          0 :     int r = 0, ok = 1;
        4012                 :            :
        4013                 :          0 :     errno = 0;
        4014         [ #  # ]:          0 :     if (cafile == Py_None)
        4015                 :          0 :         cafile = NULL;
        4016         [ #  # ]:          0 :     if (capath == Py_None)
        4017                 :          0 :         capath = NULL;
        4018         [ #  # ]:          0 :     if (cadata == Py_None)
        4019                 :          0 :         cadata = NULL;
        4020                 :            :
        4021   [ #  #  #  #  :          0 :     if (cafile == NULL && capath == NULL && cadata == NULL) {
                       #  # ]
        4022                 :          0 :         PyErr_SetString(PyExc_TypeError,
        4023                 :            :                         "cafile, capath and cadata cannot be all omitted");
        4024                 :          0 :         goto error;
        4025                 :            :     }
        4026   [ #  #  #  # ]:          0 :     if (cafile && !PyUnicode_FSConverter(cafile, &cafile_bytes)) {
        4027         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_TypeError)) {
        4028                 :          0 :             PyErr_SetString(PyExc_TypeError,
        4029                 :            :                             "cafile should be a valid filesystem path");
        4030                 :            :         }
        4031                 :          0 :         goto error;
        4032                 :            :     }
        4033   [ #  #  #  # ]:          0 :     if (capath && !PyUnicode_FSConverter(capath, &capath_bytes)) {
        4034         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_TypeError)) {
        4035                 :          0 :             PyErr_SetString(PyExc_TypeError,
        4036                 :            :                             "capath should be a valid filesystem path");
        4037                 :            :         }
        4038                 :          0 :         goto error;
        4039                 :            :     }
        4040                 :            :
        4041                 :            :     /* validate cadata type and load cadata */
        4042         [ #  # ]:          0 :     if (cadata) {
        4043         [ #  # ]:          0 :         if (PyUnicode_Check(cadata)) {
        4044                 :          0 :             PyObject *cadata_ascii = PyUnicode_AsASCIIString(cadata);
        4045         [ #  # ]:          0 :             if (cadata_ascii == NULL) {
        4046         [ #  # ]:          0 :                 if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) {
        4047                 :          0 :                     goto invalid_cadata;
        4048                 :            :                 }
        4049                 :          0 :                 goto error;
        4050                 :            :             }
        4051                 :          0 :             r = _add_ca_certs(self,
        4052                 :          0 :                               PyBytes_AS_STRING(cadata_ascii),
        4053                 :            :                               PyBytes_GET_SIZE(cadata_ascii),
        4054                 :            :                               SSL_FILETYPE_PEM);
        4055                 :          0 :             Py_DECREF(cadata_ascii);
        4056         [ #  # ]:          0 :             if (r == -1) {
        4057                 :          0 :                 goto error;
        4058                 :            :             }
        4059                 :            :         }
        4060         [ #  # ]:          0 :         else if (PyObject_CheckBuffer(cadata)) {
        4061                 :            :             Py_buffer buf;
        4062         [ #  # ]:          0 :             if (PyObject_GetBuffer(cadata, &buf, PyBUF_SIMPLE)) {
        4063                 :          0 :                 goto error;
        4064                 :            :             }
        4065   [ #  #  #  # ]:          0 :             if (!PyBuffer_IsContiguous(&buf, 'C') || buf.ndim > 1) {
        4066                 :          0 :                 PyBuffer_Release(&buf);
        4067                 :          0 :                 PyErr_SetString(PyExc_TypeError,
        4068                 :            :                                 "cadata should be a contiguous buffer with "
        4069                 :            :                                 "a single dimension");
        4070                 :          0 :                 goto error;
        4071                 :            :             }
        4072                 :          0 :             r = _add_ca_certs(self, buf.buf, buf.len, SSL_FILETYPE_ASN1);
        4073                 :          0 :             PyBuffer_Release(&buf);
        4074         [ #  # ]:          0 :             if (r == -1) {
        4075                 :          0 :                 goto error;
        4076                 :            :             }
        4077                 :            :         }
        4078                 :            :         else {
        4079                 :          0 :   invalid_cadata:
        4080                 :          0 :             PyErr_SetString(PyExc_TypeError,
        4081                 :            :                             "cadata should be an ASCII string or a "
        4082                 :            :                             "bytes-like object");
        4083                 :          0 :             goto error;
        4084                 :            :         }
        4085                 :            :     }
        4086                 :            :
        4087                 :            :     /* load cafile or capath */
        4088   [ #  #  #  # ]:          0 :     if (cafile || capath) {
        4089         [ #  # ]:          0 :         if (cafile)
        4090                 :          0 :             cafile_buf = PyBytes_AS_STRING(cafile_bytes);
        4091         [ #  # ]:          0 :         if (capath)
        4092                 :          0 :             capath_buf = PyBytes_AS_STRING(capath_bytes);
        4093                 :          0 :         PySSL_BEGIN_ALLOW_THREADS
        4094                 :          0 :         r = SSL_CTX_load_verify_locations(self->ctx, cafile_buf, capath_buf);
        4095                 :          0 :         PySSL_END_ALLOW_THREADS
        4096         [ #  # ]:          0 :         if (r != 1) {
        4097         [ #  # ]:          0 :             if (errno != 0) {
        4098                 :          0 :                 ERR_clear_error();
        4099                 :          0 :                 PyErr_SetFromErrno(PyExc_OSError);
        4100                 :            :             }
        4101                 :            :             else {
        4102                 :          0 :                 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        4103                 :            :             }
        4104                 :          0 :             goto error;
        4105                 :            :         }
        4106                 :            :     }
        4107                 :          0 :     goto end;
        4108                 :            :
        4109                 :          0 :   error:
        4110                 :          0 :     ok = 0;
        4111                 :          0 :   end:
        4112                 :          0 :     Py_XDECREF(cafile_bytes);
        4113                 :          0 :     Py_XDECREF(capath_bytes);
        4114         [ #  # ]:          0 :     if (ok) {
        4115                 :          0 :         Py_RETURN_NONE;
        4116                 :            :     } else {
        4117                 :          0 :         return NULL;
        4118                 :            :     }
        4119                 :            : }
        4120                 :            :
        4121                 :            : /*[clinic input]
        4122                 :            : _ssl._SSLContext.load_dh_params
        4123                 :            :     path as filepath: object
        4124                 :            :     /
        4125                 :            :
        4126                 :            : [clinic start generated code]*/
        4127                 :            :
        4128                 :            : static PyObject *
        4129                 :          0 : _ssl__SSLContext_load_dh_params(PySSLContext *self, PyObject *filepath)
        4130                 :            : /*[clinic end generated code: output=1c8e57a38e055af0 input=c8871f3c796ae1d6]*/
        4131                 :            : {
        4132                 :            :     FILE *f;
        4133                 :            :     DH *dh;
        4134                 :            :
        4135                 :          0 :     f = _Py_fopen_obj(filepath, "rb");
        4136         [ #  # ]:          0 :     if (f == NULL)
        4137                 :          0 :         return NULL;
        4138                 :            :
        4139                 :          0 :     errno = 0;
        4140                 :          0 :     PySSL_BEGIN_ALLOW_THREADS
        4141                 :          0 :     dh = PEM_read_DHparams(f, NULL, NULL, NULL);
        4142                 :          0 :     fclose(f);
        4143                 :          0 :     PySSL_END_ALLOW_THREADS
        4144         [ #  # ]:          0 :     if (dh == NULL) {
        4145         [ #  # ]:          0 :         if (errno != 0) {
        4146                 :          0 :             ERR_clear_error();
        4147                 :          0 :             PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, filepath);
        4148                 :            :         }
        4149                 :            :         else {
        4150                 :          0 :             _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        4151                 :            :         }
        4152                 :          0 :         return NULL;
        4153                 :            :     }
        4154         [ #  # ]:          0 :     if (!SSL_CTX_set_tmp_dh(self->ctx, dh)) {
        4155                 :          0 :         DH_free(dh);
        4156                 :          0 :         return _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        4157                 :            :     }
        4158                 :          0 :     DH_free(dh);
        4159                 :          0 :     Py_RETURN_NONE;
        4160                 :            : }
        4161                 :            :
        4162                 :            : /*[clinic input]
        4163                 :            : _ssl._SSLContext._wrap_socket
        4164                 :            :     sock: object(subclass_of="get_state_ctx(self)->Sock_Type")
        4165                 :            :     server_side: bool
        4166                 :            :     server_hostname as hostname_obj: object = None
        4167                 :            :     *
        4168                 :            :     owner: object = None
        4169                 :            :     session: object = None
        4170                 :            :
        4171                 :            : [clinic start generated code]*/
        4172                 :            :
        4173                 :            : static PyObject *
        4174                 :          0 : _ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
        4175                 :            :                                    int server_side, PyObject *hostname_obj,
        4176                 :            :                                    PyObject *owner, PyObject *session)
        4177                 :            : /*[clinic end generated code: output=f103f238633940b4 input=700ca8fedff53994]*/
        4178                 :            : {
        4179                 :          0 :     char *hostname = NULL;
        4180                 :            :     PyObject *res;
        4181                 :            :
        4182                 :            :     /* server_hostname is either None (or absent), or to be encoded
        4183                 :            :        as IDN A-label (ASCII str) without NULL bytes. */
        4184         [ #  # ]:          0 :     if (hostname_obj != Py_None) {
        4185         [ #  # ]:          0 :         if (!PyArg_Parse(hostname_obj, "es", "ascii", &hostname))
        4186                 :          0 :             return NULL;
        4187                 :            :     }
        4188                 :            :
        4189                 :          0 :     res = (PyObject *) newPySSLSocket(self, (PySocketSockObject *)sock,
        4190                 :            :                                       server_side, hostname,
        4191                 :            :                                       owner, session,
        4192                 :            :                                       NULL, NULL);
        4193         [ #  # ]:          0 :     if (hostname != NULL)
        4194                 :          0 :         PyMem_Free(hostname);
        4195                 :          0 :     return res;
        4196                 :            : }
        4197                 :            :
        4198                 :            : /*[clinic input]
        4199                 :            : _ssl._SSLContext._wrap_bio
        4200                 :            :     incoming: object(subclass_of="get_state_ctx(self)->PySSLMemoryBIO_Type", type="PySSLMemoryBIO *")
        4201                 :            :     outgoing: object(subclass_of="get_state_ctx(self)->PySSLMemoryBIO_Type", type="PySSLMemoryBIO *")
        4202                 :            :     server_side: bool
        4203                 :            :     server_hostname as hostname_obj: object = None
        4204                 :            :     *
        4205                 :            :     owner: object = None
        4206                 :            :     session: object = None
        4207                 :            :
        4208                 :            : [clinic start generated code]*/
        4209                 :            :
        4210                 :            : static PyObject *
        4211                 :          0 : _ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
        4212                 :            :                                 PySSLMemoryBIO *outgoing, int server_side,
        4213                 :            :                                 PyObject *hostname_obj, PyObject *owner,
        4214                 :            :                                 PyObject *session)
        4215                 :            : /*[clinic end generated code: output=5c5d6d9b41f99332 input=a9205d097fd45a82]*/
        4216                 :            : {
        4217                 :          0 :     char *hostname = NULL;
        4218                 :            :     PyObject *res;
        4219                 :            :
        4220                 :            :     /* server_hostname is either None (or absent), or to be encoded
        4221                 :            :        as IDN A-label (ASCII str) without NULL bytes. */
        4222         [ #  # ]:          0 :     if (hostname_obj != Py_None) {
        4223         [ #  # ]:          0 :         if (!PyArg_Parse(hostname_obj, "es", "ascii", &hostname))
        4224                 :          0 :             return NULL;
        4225                 :            :     }
        4226                 :            :
        4227                 :          0 :     res = (PyObject *) newPySSLSocket(self, NULL, server_side, hostname,
        4228                 :            :                                       owner, session,
        4229                 :            :                                       incoming, outgoing);
        4230                 :            :
        4231                 :          0 :     PyMem_Free(hostname);
        4232                 :          0 :     return res;
        4233                 :            : }
        4234                 :            :
        4235                 :            : /*[clinic input]
        4236                 :            : _ssl._SSLContext.session_stats
        4237                 :            : [clinic start generated code]*/
        4238                 :            :
        4239                 :            : static PyObject *
        4240                 :          0 : _ssl__SSLContext_session_stats_impl(PySSLContext *self)
        4241                 :            : /*[clinic end generated code: output=0d96411c42893bfb input=7e0a81fb11102c8b]*/
        4242                 :            : {
        4243                 :            :     int r;
        4244                 :          0 :     PyObject *value, *stats = PyDict_New();
        4245         [ #  # ]:          0 :     if (!stats)
        4246                 :          0 :         return NULL;
        4247                 :            :
        4248                 :            : #define ADD_STATS(SSL_NAME, KEY_NAME) \
        4249                 :            :     value = PyLong_FromLong(SSL_CTX_sess_ ## SSL_NAME (self->ctx)); \
        4250                 :            :     if (value == NULL) \
        4251                 :            :         goto error; \
        4252                 :            :     r = PyDict_SetItemString(stats, KEY_NAME, value); \
        4253                 :            :     Py_DECREF(value); \
        4254                 :            :     if (r < 0) \
        4255                 :            :         goto error;
        4256                 :            :
        4257   [ #  #  #  # ]:          0 :     ADD_STATS(number, "number");
        4258   [ #  #  #  # ]:          0 :     ADD_STATS(connect, "connect");
        4259   [ #  #  #  # ]:          0 :     ADD_STATS(connect_good, "connect_good");
        4260   [ #  #  #  # ]:          0 :     ADD_STATS(connect_renegotiate, "connect_renegotiate");
        4261   [ #  #  #  # ]:          0 :     ADD_STATS(accept, "accept");
        4262   [ #  #  #  # ]:          0 :     ADD_STATS(accept_good, "accept_good");
        4263   [ #  #  #  # ]:          0 :     ADD_STATS(accept_renegotiate, "accept_renegotiate");
        4264   [ #  #  #  # ]:          0 :     ADD_STATS(accept, "accept");
        4265   [ #  #  #  # ]:          0 :     ADD_STATS(hits, "hits");
        4266   [ #  #  #  # ]:          0 :     ADD_STATS(misses, "misses");
        4267   [ #  #  #  # ]:          0 :     ADD_STATS(timeouts, "timeouts");
        4268   [ #  #  #  # ]:          0 :     ADD_STATS(cache_full, "cache_full");
        4269                 :            :
        4270                 :            : #undef ADD_STATS
        4271                 :            :
        4272                 :          0 :     return stats;
        4273                 :            :
        4274                 :          0 : error:
        4275                 :          0 :     Py_DECREF(stats);
        4276                 :          0 :     return NULL;
        4277                 :            : }
        4278                 :            :
        4279                 :            : /*[clinic input]
        4280                 :            : _ssl._SSLContext.set_default_verify_paths
        4281                 :            : [clinic start generated code]*/
        4282                 :            :
        4283                 :            : static PyObject *
        4284                 :          0 : _ssl__SSLContext_set_default_verify_paths_impl(PySSLContext *self)
        4285                 :            : /*[clinic end generated code: output=0bee74e6e09deaaa input=35f3408021463d74]*/
        4286                 :            : {
        4287                 :            :     int rc;
        4288                 :          0 :     Py_BEGIN_ALLOW_THREADS
        4289                 :          0 :     rc = SSL_CTX_set_default_verify_paths(self->ctx);
        4290                 :          0 :     Py_END_ALLOW_THREADS
        4291         [ #  # ]:          0 :     if (!rc) {
        4292                 :          0 :         _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        4293                 :          0 :         return NULL;
        4294                 :            :     }
        4295                 :          0 :     Py_RETURN_NONE;
        4296                 :            : }
        4297                 :            :
        4298                 :            : /*[clinic input]
        4299                 :            : _ssl._SSLContext.set_ecdh_curve
        4300                 :            :     name: object
        4301                 :            :     /
        4302                 :            :
        4303                 :            : [clinic start generated code]*/
        4304                 :            :
        4305                 :            : static PyObject *
        4306                 :          0 : _ssl__SSLContext_set_ecdh_curve(PySSLContext *self, PyObject *name)
        4307                 :            : /*[clinic end generated code: output=23022c196e40d7d2 input=c2bafb6f6e34726b]*/
        4308                 :            : {
        4309                 :            :     PyObject *name_bytes;
        4310                 :            :     int nid;
        4311                 :            :     EC_KEY *key;
        4312                 :            :
        4313         [ #  # ]:          0 :     if (!PyUnicode_FSConverter(name, &name_bytes))
        4314                 :          0 :         return NULL;
        4315                 :            :     assert(PyBytes_Check(name_bytes));
        4316                 :          0 :     nid = OBJ_sn2nid(PyBytes_AS_STRING(name_bytes));
        4317                 :          0 :     Py_DECREF(name_bytes);
        4318         [ #  # ]:          0 :     if (nid == 0) {
        4319                 :          0 :         PyErr_Format(PyExc_ValueError,
        4320                 :            :                      "unknown elliptic curve name %R", name);
        4321                 :          0 :         return NULL;
        4322                 :            :     }
        4323                 :          0 :     key = EC_KEY_new_by_curve_name(nid);
        4324         [ #  # ]:          0 :     if (key == NULL) {
        4325                 :          0 :         _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
        4326                 :          0 :         return NULL;
        4327                 :            :     }
        4328                 :          0 :     SSL_CTX_set_tmp_ecdh(self->ctx, key);
        4329                 :          0 :     EC_KEY_free(key);
        4330                 :          0 :     Py_RETURN_NONE;
        4331                 :            : }
        4332                 :            :
        4333                 :            : static int
        4334                 :          0 : _servername_callback(SSL *s, int *al, void *args)
        4335                 :            : {
        4336                 :            :     int ret;
        4337                 :          0 :     PySSLContext *sslctx = (PySSLContext *) args;
        4338                 :            :     PySSLSocket *ssl;
        4339                 :            :     PyObject *result;
        4340                 :            :     /* The high-level ssl.SSLSocket object */
        4341                 :            :     PyObject *ssl_socket;
        4342                 :          0 :     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
        4343                 :          0 :     PyGILState_STATE gstate = PyGILState_Ensure();
        4344                 :            :
        4345         [ #  # ]:          0 :     if (sslctx->set_sni_cb == NULL) {
        4346                 :            :         /* remove race condition in this the call back while if removing the
        4347                 :            :          * callback is in progress */
        4348                 :          0 :         PyGILState_Release(gstate);
        4349                 :          0 :         return SSL_TLSEXT_ERR_OK;
        4350                 :            :     }
        4351                 :            :
        4352                 :          0 :     ssl = SSL_get_app_data(s);
        4353                 :            :     assert(Py_IS_TYPE(ssl, get_state_ctx(sslctx)->PySSLSocket_Type));
        4354                 :            :
        4355                 :            :     /* The servername callback expects an argument that represents the current
        4356                 :            :      * SSL connection and that has a .context attribute that can be changed to
        4357                 :            :      * identify the requested hostname. Since the official API is the Python
        4358                 :            :      * level API we want to pass the callback a Python level object rather than
        4359                 :            :      * a _ssl.SSLSocket instance. If there's an "owner" (typically an
        4360                 :            :      * SSLObject) that will be passed. Otherwise if there's a socket then that
        4361                 :            :      * will be passed. If both do not exist only then the C-level object is
        4362                 :            :      * passed. */
        4363         [ #  # ]:          0 :     if (ssl->owner)
        4364                 :          0 :         ssl_socket = PyWeakref_GetObject(ssl->owner);
        4365         [ #  # ]:          0 :     else if (ssl->Socket)
        4366                 :          0 :         ssl_socket = PyWeakref_GetObject(ssl->Socket);
        4367                 :            :     else
        4368                 :          0 :         ssl_socket = (PyObject *) ssl;
        4369                 :            :
        4370                 :          0 :     Py_INCREF(ssl_socket);
        4371         [ #  # ]:          0 :     if (ssl_socket == Py_None)
        4372                 :          0 :         goto error;
        4373                 :            :
        4374         [ #  # ]:          0 :     if (servername == NULL) {
        4375                 :          0 :         result = PyObject_CallFunctionObjArgs(sslctx->set_sni_cb, ssl_socket,
        4376                 :            :                                               Py_None, sslctx, NULL);
        4377                 :            :     }
        4378                 :            :     else {
        4379                 :            :         PyObject *servername_bytes;
        4380                 :            :         PyObject *servername_str;
        4381                 :            :
        4382                 :          0 :         servername_bytes = PyBytes_FromString(servername);
        4383         [ #  # ]:          0 :         if (servername_bytes == NULL) {
        4384                 :          0 :             PyErr_WriteUnraisable((PyObject *) sslctx);
        4385                 :          0 :             goto error;
        4386                 :            :         }
        4387                 :            :         /* server_hostname was encoded to an A-label by our caller; put it
        4388                 :            :          * back into a str object, but still as an A-label (bpo-28414)
        4389                 :            :          */
        4390                 :          0 :         servername_str = PyUnicode_FromEncodedObject(servername_bytes, "ascii", NULL);
        4391         [ #  # ]:          0 :         if (servername_str == NULL) {
        4392                 :          0 :             PyErr_WriteUnraisable(servername_bytes);
        4393                 :          0 :             Py_DECREF(servername_bytes);
        4394                 :          0 :             goto error;
        4395                 :            :         }
        4396                 :          0 :         Py_DECREF(servername_bytes);
        4397                 :          0 :         result = PyObject_CallFunctionObjArgs(
        4398                 :            :             sslctx->set_sni_cb, ssl_socket, servername_str,
        4399                 :            :             sslctx, NULL);
        4400                 :          0 :         Py_DECREF(servername_str);
        4401                 :            :     }
        4402                 :          0 :     Py_DECREF(ssl_socket);
        4403                 :            :
        4404         [ #  # ]:          0 :     if (result == NULL) {
        4405                 :          0 :         PyErr_WriteUnraisable(sslctx->set_sni_cb);
        4406                 :          0 :         *al = SSL_AD_HANDSHAKE_FAILURE;
        4407                 :          0 :         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
        4408                 :            :     }
        4409                 :            :     else {
        4410                 :            :         /* Result may be None, a SSLContext or an integer
        4411                 :            :          * None and SSLContext are OK, integer or other values are an error.
        4412                 :            :          */
        4413         [ #  # ]:          0 :         if (result == Py_None) {
        4414                 :          0 :             ret = SSL_TLSEXT_ERR_OK;
        4415                 :            :         } else {
        4416                 :          0 :             *al = (int) PyLong_AsLong(result);
        4417         [ #  # ]:          0 :             if (PyErr_Occurred()) {
        4418                 :          0 :                 PyErr_WriteUnraisable(result);
        4419                 :          0 :                 *al = SSL_AD_INTERNAL_ERROR;
        4420                 :            :             }
        4421                 :          0 :             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
        4422                 :            :         }
        4423                 :          0 :         Py_DECREF(result);
        4424                 :            :     }
        4425                 :            :
        4426                 :          0 :     PyGILState_Release(gstate);
        4427                 :          0 :     return ret;
        4428                 :            :
        4429                 :          0 : error:
        4430                 :          0 :     Py_DECREF(ssl_socket);
        4431                 :          0 :     *al = SSL_AD_INTERNAL_ERROR;
        4432                 :          0 :     ret = SSL_TLSEXT_ERR_ALERT_FATAL;
        4433                 :          0 :     PyGILState_Release(gstate);
        4434                 :          0 :     return ret;
        4435                 :            : }
        4436                 :            :
        4437                 :            : static PyObject *
        4438                 :          0 : get_sni_callback(PySSLContext *self, void *c)
        4439                 :            : {
        4440                 :          0 :     PyObject *cb = self->set_sni_cb;
        4441         [ #  # ]:          0 :     if (cb == NULL) {
        4442                 :          0 :         Py_RETURN_NONE;
        4443                 :            :     }
        4444                 :          0 :     return Py_NewRef(cb);
        4445                 :            : }
        4446                 :            :
        4447                 :            : static int
        4448                 :          0 : set_sni_callback(PySSLContext *self, PyObject *arg, void *c)
        4449                 :            : {
        4450         [ #  # ]:          0 :     if (self->protocol == PY_SSL_VERSION_TLS_CLIENT) {
        4451                 :          0 :         PyErr_SetString(PyExc_ValueError,
        4452                 :            :                         "sni_callback cannot be set on TLS_CLIENT context");
        4453                 :          0 :         return -1;
        4454                 :            :     }
        4455         [ #  # ]:          0 :     Py_CLEAR(self->set_sni_cb);
        4456         [ #  # ]:          0 :     if (arg == Py_None) {
        4457                 :          0 :         SSL_CTX_set_tlsext_servername_callback(self->ctx, NULL);
        4458                 :            :     }
        4459                 :            :     else {
        4460         [ #  # ]:          0 :         if (!PyCallable_Check(arg)) {
        4461                 :          0 :             SSL_CTX_set_tlsext_servername_callback(self->ctx, NULL);
        4462                 :          0 :             PyErr_SetString(PyExc_TypeError,
        4463                 :            :                             "not a callable object");
        4464                 :          0 :             return -1;
        4465                 :            :         }
        4466                 :          0 :         self->set_sni_cb = Py_NewRef(arg);
        4467                 :          0 :         SSL_CTX_set_tlsext_servername_callback(self->ctx, _servername_callback);
        4468                 :          0 :         SSL_CTX_set_tlsext_servername_arg(self->ctx, self);
        4469                 :            :     }
        4470                 :          0 :     return 0;
        4471                 :            : }
        4472                 :            :
        4473                 :            : PyDoc_STRVAR(PySSLContext_sni_callback_doc,
        4474                 :            : "Set a callback that will be called when a server name is provided by the SSL/TLS client in the SNI extension.\n\
        4475                 :            : \n\
        4476                 :            : If the argument is None then the callback is disabled. The method is called\n\
        4477                 :            : with the SSLSocket, the server name as a string, and the SSLContext object.\n\
        4478                 :            : See RFC 6066 for details of the SNI extension.");
        4479                 :            :
        4480                 :            : /*[clinic input]
        4481                 :            : _ssl._SSLContext.cert_store_stats
        4482                 :            :
        4483                 :            : Returns quantities of loaded X.509 certificates.
        4484                 :            :
        4485                 :            : X.509 certificates with a CA extension and certificate revocation lists
        4486                 :            : inside the context's cert store.
        4487                 :            :
        4488                 :            : NOTE: Certificates in a capath directory aren't loaded unless they have
        4489                 :            : been used at least once.
        4490                 :            : [clinic start generated code]*/
        4491                 :            :
        4492                 :            : static PyObject *
        4493                 :          0 : _ssl__SSLContext_cert_store_stats_impl(PySSLContext *self)
        4494                 :            : /*[clinic end generated code: output=5f356f4d9cca874d input=eb40dd0f6d0e40cf]*/
        4495                 :            : {
        4496                 :            :     X509_STORE *store;
        4497                 :            :     STACK_OF(X509_OBJECT) *objs;
        4498                 :            :     X509_OBJECT *obj;
        4499                 :          0 :     int x509 = 0, crl = 0, ca = 0, i;
        4500                 :            :
        4501                 :          0 :     store = SSL_CTX_get_cert_store(self->ctx);
        4502                 :          0 :     objs = X509_STORE_get0_objects(store);
        4503         [ #  # ]:          0 :     for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
        4504                 :          0 :         obj = sk_X509_OBJECT_value(objs, i);
        4505      [ #  #  # ]:          0 :         switch (X509_OBJECT_get_type(obj)) {
        4506                 :          0 :             case X509_LU_X509:
        4507                 :          0 :                 x509++;
        4508         [ #  # ]:          0 :                 if (X509_check_ca(X509_OBJECT_get0_X509(obj))) {
        4509                 :          0 :                     ca++;
        4510                 :            :                 }
        4511                 :          0 :                 break;
        4512                 :          0 :             case X509_LU_CRL:
        4513                 :          0 :                 crl++;
        4514                 :          0 :                 break;
        4515                 :          0 :             default:
        4516                 :            :                 /* Ignore X509_LU_FAIL, X509_LU_RETRY, X509_LU_PKEY.
        4517                 :            :                  * As far as I can tell they are internal states and never
        4518                 :            :                  * stored in a cert store */
        4519                 :          0 :                 break;
        4520                 :            :         }
        4521                 :            :     }
        4522                 :          0 :     return Py_BuildValue("{sisisi}", "x509", x509, "crl", crl,
        4523                 :            :         "x509_ca", ca);
        4524                 :            : }
        4525                 :            :
        4526                 :            : /*[clinic input]
        4527                 :            : _ssl._SSLContext.get_ca_certs
        4528                 :            :     binary_form: bool = False
        4529                 :            :
        4530                 :            : Returns a list of dicts with information of loaded CA certs.
        4531                 :            :
        4532                 :            : If the optional argument is True, returns a DER-encoded copy of the CA
        4533                 :            : certificate.
        4534                 :            :
        4535                 :            : NOTE: Certificates in a capath directory aren't loaded unless they have
        4536                 :            : been used at least once.
        4537                 :            : [clinic start generated code]*/
        4538                 :            :
        4539                 :            : static PyObject *
        4540                 :          0 : _ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form)
        4541                 :            : /*[clinic end generated code: output=0d58f148f37e2938 input=6887b5a09b7f9076]*/
        4542                 :            : {
        4543                 :            :     X509_STORE *store;
        4544                 :            :     STACK_OF(X509_OBJECT) *objs;
        4545                 :          0 :     PyObject *ci = NULL, *rlist = NULL;
        4546                 :            :     int i;
        4547                 :            :
        4548         [ #  # ]:          0 :     if ((rlist = PyList_New(0)) == NULL) {
        4549                 :          0 :         return NULL;
        4550                 :            :     }
        4551                 :            :
        4552                 :          0 :     store = SSL_CTX_get_cert_store(self->ctx);
        4553                 :          0 :     objs = X509_STORE_get0_objects(store);
        4554         [ #  # ]:          0 :     for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
        4555                 :            :         X509_OBJECT *obj;
        4556                 :            :         X509 *cert;
        4557                 :            :
        4558                 :          0 :         obj = sk_X509_OBJECT_value(objs, i);
        4559         [ #  # ]:          0 :         if (X509_OBJECT_get_type(obj) != X509_LU_X509) {
        4560                 :            :             /* not a x509 cert */
        4561                 :          0 :             continue;
        4562                 :            :         }
        4563                 :            :         /* CA for any purpose */
        4564                 :          0 :         cert = X509_OBJECT_get0_X509(obj);
        4565         [ #  # ]:          0 :         if (!X509_check_ca(cert)) {
        4566                 :          0 :             continue;
        4567                 :            :         }
        4568         [ #  # ]:          0 :         if (binary_form) {
        4569                 :          0 :             ci = _certificate_to_der(get_state_ctx(self), cert);
        4570                 :            :         } else {
        4571                 :          0 :             ci = _decode_certificate(get_state_ctx(self), cert);
        4572                 :            :         }
        4573         [ #  # ]:          0 :         if (ci == NULL) {
        4574                 :          0 :             goto error;
        4575                 :            :         }
        4576         [ #  # ]:          0 :         if (PyList_Append(rlist, ci) == -1) {
        4577                 :          0 :             goto error;
        4578                 :            :         }
        4579         [ #  # ]:          0 :         Py_CLEAR(ci);
        4580                 :            :     }
        4581                 :          0 :     return rlist;
        4582                 :            :
        4583                 :          0 :   error:
        4584                 :          0 :     Py_XDECREF(ci);
        4585                 :          0 :     Py_XDECREF(rlist);
        4586                 :          0 :     return NULL;
        4587                 :            : }
        4588                 :            :
        4589                 :            :
        4590                 :            : static PyGetSetDef context_getsetlist[] = {
        4591                 :            :     {"check_hostname", (getter) get_check_hostname,
        4592                 :            :                        (setter) set_check_hostname, NULL},
        4593                 :            :     {"_host_flags", (getter) get_host_flags,
        4594                 :            :                     (setter) set_host_flags, NULL},
        4595                 :            :     {"minimum_version", (getter) get_minimum_version,
        4596                 :            :                         (setter) set_minimum_version, NULL},
        4597                 :            :     {"maximum_version", (getter) get_maximum_version,
        4598                 :            :                         (setter) set_maximum_version, NULL},
        4599                 :            :     {"keylog_filename", (getter) _PySSLContext_get_keylog_filename,
        4600                 :            :                         (setter) _PySSLContext_set_keylog_filename, NULL},
        4601                 :            :     {"_msg_callback", (getter) _PySSLContext_get_msg_callback,
        4602                 :            :                       (setter) _PySSLContext_set_msg_callback, NULL},
        4603                 :            :     {"sni_callback", (getter) get_sni_callback,
        4604                 :            :                      (setter) set_sni_callback, PySSLContext_sni_callback_doc},
        4605                 :            : #ifdef TLS1_3_VERSION
        4606                 :            :     {"num_tickets", (getter) get_num_tickets,
        4607                 :            :                     (setter) set_num_tickets, PySSLContext_num_tickets_doc},
        4608                 :            : #endif
        4609                 :            :     {"options", (getter) get_options,
        4610                 :            :                 (setter) set_options, NULL},
        4611                 :            :     {"post_handshake_auth", (getter) get_post_handshake_auth,
        4612                 :            : #ifdef TLS1_3_VERSION
        4613                 :            :                             (setter) set_post_handshake_auth,
        4614                 :            : #else
        4615                 :            :                             NULL,
        4616                 :            : #endif
        4617                 :            :                             NULL},
        4618                 :            :     {"protocol", (getter) get_protocol,
        4619                 :            :                  NULL, NULL},
        4620                 :            :     {"verify_flags", (getter) get_verify_flags,
        4621                 :            :                      (setter) set_verify_flags, NULL},
        4622                 :            :     {"verify_mode", (getter) get_verify_mode,
        4623                 :            :                     (setter) set_verify_mode, NULL},
        4624                 :            :     {"security_level", (getter) get_security_level,
        4625                 :            :                        NULL, PySSLContext_security_level_doc},
        4626                 :            :     {NULL},            /* sentinel */
        4627                 :            : };
        4628                 :            :
        4629                 :            : static struct PyMethodDef context_methods[] = {
        4630                 :            :     _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF
        4631                 :            :     _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF
        4632                 :            :     _SSL__SSLCONTEXT_SET_CIPHERS_METHODDEF
        4633                 :            :     _SSL__SSLCONTEXT__SET_ALPN_PROTOCOLS_METHODDEF
        4634                 :            :     _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF
        4635                 :            :     _SSL__SSLCONTEXT_LOAD_DH_PARAMS_METHODDEF
        4636                 :            :     _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF
        4637                 :            :     _SSL__SSLCONTEXT_SESSION_STATS_METHODDEF
        4638                 :            :     _SSL__SSLCONTEXT_SET_DEFAULT_VERIFY_PATHS_METHODDEF
        4639                 :            :     _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF
        4640                 :            :     _SSL__SSLCONTEXT_CERT_STORE_STATS_METHODDEF
        4641                 :            :     _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF
        4642                 :            :     _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF
        4643                 :            :     {NULL, NULL}        /* sentinel */
        4644                 :            : };
        4645                 :            :
        4646                 :            : static PyType_Slot PySSLContext_slots[] = {
        4647                 :            :     {Py_tp_methods, context_methods},
        4648                 :            :     {Py_tp_getset, context_getsetlist},
        4649                 :            :     {Py_tp_new, _ssl__SSLContext},
        4650                 :            :     {Py_tp_dealloc, context_dealloc},
        4651                 :            :     {Py_tp_traverse, context_traverse},
        4652                 :            :     {Py_tp_clear, context_clear},
        4653                 :            :     {0, 0},
        4654                 :            : };
        4655                 :            :
        4656                 :            : static PyType_Spec PySSLContext_spec = {
        4657                 :            :     .name = "_ssl._SSLContext",
        4658                 :            :     .basicsize = sizeof(PySSLContext),
        4659                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
        4660                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        4661                 :            :     .slots = PySSLContext_slots,
        4662                 :            : };
        4663                 :            :
        4664                 :            :
        4665                 :            : /*
        4666                 :            :  * MemoryBIO objects
        4667                 :            :  */
        4668                 :            :
        4669                 :            : /*[clinic input]
        4670                 :            : @classmethod
        4671                 :            : _ssl.MemoryBIO.__new__
        4672                 :            :
        4673                 :            : [clinic start generated code]*/
        4674                 :            :
        4675                 :            : static PyObject *
        4676                 :          0 : _ssl_MemoryBIO_impl(PyTypeObject *type)
        4677                 :            : /*[clinic end generated code: output=8820a58db78330ac input=26d22e4909ecb1b5]*/
        4678                 :            : {
        4679                 :            :     BIO *bio;
        4680                 :            :     PySSLMemoryBIO *self;
        4681                 :            :
        4682                 :          0 :     bio = BIO_new(BIO_s_mem());
        4683         [ #  # ]:          0 :     if (bio == NULL) {
        4684                 :          0 :         PyErr_SetString(PyExc_MemoryError, "failed to allocate BIO");
        4685                 :          0 :         return NULL;
        4686                 :            :     }
        4687                 :            :     /* Since our BIO is non-blocking an empty read() does not indicate EOF,
        4688                 :            :      * just that no data is currently available. The SSL routines should retry
        4689                 :            :      * the read, which we can achieve by calling BIO_set_retry_read(). */
        4690                 :          0 :     BIO_set_retry_read(bio);
        4691                 :          0 :     BIO_set_mem_eof_return(bio, -1);
        4692                 :            :
        4693                 :            :     assert(type != NULL && type->tp_alloc != NULL);
        4694                 :          0 :     self = (PySSLMemoryBIO *) type->tp_alloc(type, 0);
        4695         [ #  # ]:          0 :     if (self == NULL) {
        4696                 :          0 :         BIO_free(bio);
        4697                 :          0 :         return NULL;
        4698                 :            :     }
        4699                 :          0 :     self->bio = bio;
        4700                 :          0 :     self->eof_written = 0;
        4701                 :            :
        4702                 :          0 :     return (PyObject *) self;
        4703                 :            : }
        4704                 :            :
        4705                 :            : static int
        4706                 :          0 : memory_bio_traverse(PySSLMemoryBIO *self, visitproc visit, void *arg)
        4707                 :            : {
        4708   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
        4709                 :          0 :     return 0;
        4710                 :            : }
        4711                 :            :
        4712                 :            : static void
        4713                 :          0 : memory_bio_dealloc(PySSLMemoryBIO *self)
        4714                 :            : {
        4715                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
        4716                 :          0 :     PyObject_GC_UnTrack(self);
        4717                 :          0 :     BIO_free(self->bio);
        4718                 :          0 :     Py_TYPE(self)->tp_free(self);
        4719                 :          0 :     Py_DECREF(tp);
        4720                 :          0 : }
        4721                 :            :
        4722                 :            : static PyObject *
        4723                 :          0 : memory_bio_get_pending(PySSLMemoryBIO *self, void *c)
        4724                 :            : {
        4725                 :          0 :     return PyLong_FromSize_t(BIO_ctrl_pending(self->bio));
        4726                 :            : }
        4727                 :            :
        4728                 :            : PyDoc_STRVAR(PySSL_memory_bio_pending_doc,
        4729                 :            : "The number of bytes pending in the memory BIO.");
        4730                 :            :
        4731                 :            : static PyObject *
        4732                 :          0 : memory_bio_get_eof(PySSLMemoryBIO *self, void *c)
        4733                 :            : {
        4734                 :          0 :     return PyBool_FromLong((BIO_ctrl_pending(self->bio) == 0)
        4735   [ #  #  #  # ]:          0 :                            && self->eof_written);
        4736                 :            : }
        4737                 :            :
        4738                 :            : PyDoc_STRVAR(PySSL_memory_bio_eof_doc,
        4739                 :            : "Whether the memory BIO is at EOF.");
        4740                 :            :
        4741                 :            : /*[clinic input]
        4742                 :            : _ssl.MemoryBIO.read
        4743                 :            :     size as len: int = -1
        4744                 :            :     /
        4745                 :            :
        4746                 :            : Read up to size bytes from the memory BIO.
        4747                 :            :
        4748                 :            : If size is not specified, read the entire buffer.
        4749                 :            : If the return value is an empty bytes instance, this means either
        4750                 :            : EOF or that no data is available. Use the "eof" property to
        4751                 :            : distinguish between the two.
        4752                 :            : [clinic start generated code]*/
        4753                 :            :
        4754                 :            : static PyObject *
        4755                 :          0 : _ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len)
        4756                 :            : /*[clinic end generated code: output=a657aa1e79cd01b3 input=574d7be06a902366]*/
        4757                 :            : {
        4758                 :            :     int avail, nbytes;
        4759                 :            :     PyObject *result;
        4760                 :            :
        4761         [ #  # ]:          0 :     avail = (int)Py_MIN(BIO_ctrl_pending(self->bio), INT_MAX);
        4762   [ #  #  #  # ]:          0 :     if ((len < 0) || (len > avail))
        4763                 :          0 :         len = avail;
        4764                 :            :
        4765                 :          0 :     result = PyBytes_FromStringAndSize(NULL, len);
        4766   [ #  #  #  # ]:          0 :     if ((result == NULL) || (len == 0))
        4767                 :          0 :         return result;
        4768                 :            :
        4769                 :          0 :     nbytes = BIO_read(self->bio, PyBytes_AS_STRING(result), len);
        4770         [ #  # ]:          0 :     if (nbytes < 0) {
        4771                 :          0 :         _sslmodulestate *state = get_state_mbio(self);
        4772                 :          0 :         Py_DECREF(result);
        4773                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        4774                 :          0 :         return NULL;
        4775                 :            :     }
        4776                 :            :
        4777                 :            :     /* There should never be any short reads but check anyway. */
        4778         [ #  # ]:          0 :     if (nbytes < len) {
        4779                 :          0 :         _PyBytes_Resize(&result, nbytes);
        4780                 :            :     }
        4781                 :            :
        4782                 :          0 :     return result;
        4783                 :            : }
        4784                 :            :
        4785                 :            : /*[clinic input]
        4786                 :            : _ssl.MemoryBIO.write
        4787                 :            :     b: Py_buffer
        4788                 :            :     /
        4789                 :            :
        4790                 :            : Writes the bytes b into the memory BIO.
        4791                 :            :
        4792                 :            : Returns the number of bytes written.
        4793                 :            : [clinic start generated code]*/
        4794                 :            :
        4795                 :            : static PyObject *
        4796                 :          0 : _ssl_MemoryBIO_write_impl(PySSLMemoryBIO *self, Py_buffer *b)
        4797                 :            : /*[clinic end generated code: output=156ec59110d75935 input=e45757b3e17c4808]*/
        4798                 :            : {
        4799                 :            :     int nbytes;
        4800                 :            :
        4801         [ #  # ]:          0 :     if (b->len > INT_MAX) {
        4802                 :          0 :         PyErr_Format(PyExc_OverflowError,
        4803                 :            :                      "string longer than %d bytes", INT_MAX);
        4804                 :          0 :         return NULL;
        4805                 :            :     }
        4806                 :            :
        4807         [ #  # ]:          0 :     if (self->eof_written) {
        4808                 :          0 :         PyObject *module = PyType_GetModule(Py_TYPE(self));
        4809         [ #  # ]:          0 :         if (module == NULL)
        4810                 :          0 :             return NULL;
        4811                 :          0 :         PyErr_SetString(get_ssl_state(module)->PySSLErrorObject,
        4812                 :            :                         "cannot write() after write_eof()");
        4813                 :          0 :         return NULL;
        4814                 :            :     }
        4815                 :            :
        4816                 :          0 :     nbytes = BIO_write(self->bio, b->buf, (int)b->len);
        4817         [ #  # ]:          0 :     if (nbytes < 0) {
        4818                 :          0 :         _sslmodulestate *state = get_state_mbio(self);
        4819                 :          0 :         _setSSLError(state, NULL, 0, __FILE__, __LINE__);
        4820                 :          0 :         return NULL;
        4821                 :            :     }
        4822                 :            :
        4823                 :          0 :     return PyLong_FromLong(nbytes);
        4824                 :            : }
        4825                 :            :
        4826                 :            : /*[clinic input]
        4827                 :            : _ssl.MemoryBIO.write_eof
        4828                 :            :
        4829                 :            : Write an EOF marker to the memory BIO.
        4830                 :            :
        4831                 :            : When all data has been read, the "eof" property will be True.
        4832                 :            : [clinic start generated code]*/
        4833                 :            :
        4834                 :            : static PyObject *
        4835                 :          0 : _ssl_MemoryBIO_write_eof_impl(PySSLMemoryBIO *self)
        4836                 :            : /*[clinic end generated code: output=d4106276ccd1ed34 input=56a945f1d29e8bd6]*/
        4837                 :            : {
        4838                 :          0 :     self->eof_written = 1;
        4839                 :            :     /* After an EOF is written, a zero return from read() should be a real EOF
        4840                 :            :      * i.e. it should not be retried. Clear the SHOULD_RETRY flag. */
        4841                 :          0 :     BIO_clear_retry_flags(self->bio);
        4842                 :          0 :     BIO_set_mem_eof_return(self->bio, 0);
        4843                 :            :
        4844                 :          0 :     Py_RETURN_NONE;
        4845                 :            : }
        4846                 :            :
        4847                 :            : static PyGetSetDef memory_bio_getsetlist[] = {
        4848                 :            :     {"pending", (getter) memory_bio_get_pending, NULL,
        4849                 :            :                 PySSL_memory_bio_pending_doc},
        4850                 :            :     {"eof", (getter) memory_bio_get_eof, NULL,
        4851                 :            :             PySSL_memory_bio_eof_doc},
        4852                 :            :     {NULL},            /* sentinel */
        4853                 :            : };
        4854                 :            :
        4855                 :            : static struct PyMethodDef memory_bio_methods[] = {
        4856                 :            :     _SSL_MEMORYBIO_READ_METHODDEF
        4857                 :            :     _SSL_MEMORYBIO_WRITE_METHODDEF
        4858                 :            :     _SSL_MEMORYBIO_WRITE_EOF_METHODDEF
        4859                 :            :     {NULL, NULL}        /* sentinel */
        4860                 :            : };
        4861                 :            :
        4862                 :            : static PyType_Slot PySSLMemoryBIO_slots[] = {
        4863                 :            :     {Py_tp_methods, memory_bio_methods},
        4864                 :            :     {Py_tp_getset, memory_bio_getsetlist},
        4865                 :            :     {Py_tp_new, _ssl_MemoryBIO},
        4866                 :            :     {Py_tp_dealloc, memory_bio_dealloc},
        4867                 :            :     {Py_tp_traverse, memory_bio_traverse},
        4868                 :            :     {0, 0},
        4869                 :            : };
        4870                 :            :
        4871                 :            : static PyType_Spec PySSLMemoryBIO_spec = {
        4872                 :            :     .name = "_ssl.MemoryBIO",
        4873                 :            :     .basicsize = sizeof(PySSLMemoryBIO),
        4874                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |
        4875                 :            :               Py_TPFLAGS_HAVE_GC),
        4876                 :            :     .slots = PySSLMemoryBIO_slots,
        4877                 :            : };
        4878                 :            :
        4879                 :            : /*
        4880                 :            :  * SSL Session object
        4881                 :            :  */
        4882                 :            :
        4883                 :            : static void
        4884                 :          0 : PySSLSession_dealloc(PySSLSession *self)
        4885                 :            : {
        4886                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
        4887                 :            :     /* bpo-31095: UnTrack is needed before calling any callbacks */
        4888                 :          0 :     PyObject_GC_UnTrack(self);
        4889                 :          0 :     Py_XDECREF(self->ctx);
        4890         [ #  # ]:          0 :     if (self->session != NULL) {
        4891                 :          0 :         SSL_SESSION_free(self->session);
        4892                 :            :     }
        4893                 :          0 :     PyObject_GC_Del(self);
        4894                 :          0 :     Py_DECREF(tp);
        4895                 :          0 : }
        4896                 :            :
        4897                 :            : static PyObject *
        4898                 :          0 : PySSLSession_richcompare(PyObject *left, PyObject *right, int op)
        4899                 :            : {
        4900                 :            :     int result;
        4901                 :          0 :     PyTypeObject *sesstype = ((PySSLSession*)left)->ctx->state->PySSLSession_Type;
        4902                 :            :
        4903   [ #  #  #  # ]:          0 :     if (left == NULL || right == NULL) {
        4904                 :          0 :         PyErr_BadInternalCall();
        4905                 :          0 :         return NULL;
        4906                 :            :     }
        4907                 :            :
        4908   [ #  #  #  # ]:          0 :     if (!Py_IS_TYPE(left, sesstype) || !Py_IS_TYPE(right, sesstype)) {
        4909                 :          0 :         Py_RETURN_NOTIMPLEMENTED;
        4910                 :            :     }
        4911                 :            :
        4912         [ #  # ]:          0 :     if (left == right) {
        4913                 :          0 :         result = 0;
        4914                 :            :     } else {
        4915                 :            :         const unsigned char *left_id, *right_id;
        4916                 :            :         unsigned int left_len, right_len;
        4917                 :          0 :         left_id = SSL_SESSION_get_id(((PySSLSession *)left)->session,
        4918                 :            :                                      &left_len);
        4919                 :          0 :         right_id = SSL_SESSION_get_id(((PySSLSession *)right)->session,
        4920                 :            :                                       &right_len);
        4921         [ #  # ]:          0 :         if (left_len == right_len) {
        4922                 :          0 :             result = memcmp(left_id, right_id, left_len);
        4923                 :            :         } else {
        4924                 :          0 :             result = 1;
        4925                 :            :         }
        4926                 :            :     }
        4927                 :            :
        4928   [ #  #  #  # ]:          0 :     switch (op) {
        4929                 :          0 :       case Py_EQ:
        4930         [ #  # ]:          0 :         if (result == 0) {
        4931                 :          0 :             Py_RETURN_TRUE;
        4932                 :            :         } else {
        4933                 :          0 :             Py_RETURN_FALSE;
        4934                 :            :         }
        4935                 :            :         break;
        4936                 :          0 :       case Py_NE:
        4937         [ #  # ]:          0 :         if (result != 0) {
        4938                 :          0 :             Py_RETURN_TRUE;
        4939                 :            :         } else {
        4940                 :          0 :             Py_RETURN_FALSE;
        4941                 :            :         }
        4942                 :            :         break;
        4943                 :          0 :       case Py_LT:
        4944                 :            :       case Py_LE:
        4945                 :            :       case Py_GT:
        4946                 :            :       case Py_GE:
        4947                 :          0 :         Py_RETURN_NOTIMPLEMENTED;
        4948                 :            :         break;
        4949                 :          0 :       default:
        4950                 :          0 :         PyErr_BadArgument();
        4951                 :          0 :         return NULL;
        4952                 :            :     }
        4953                 :            : }
        4954                 :            :
        4955                 :            : static int
        4956                 :          0 : PySSLSession_traverse(PySSLSession *self, visitproc visit, void *arg)
        4957                 :            : {
        4958   [ #  #  #  # ]:          0 :     Py_VISIT(self->ctx);
        4959   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
        4960                 :          0 :     return 0;
        4961                 :            : }
        4962                 :            :
        4963                 :            : static int
        4964                 :          0 : PySSLSession_clear(PySSLSession *self)
        4965                 :            : {
        4966         [ #  # ]:          0 :     Py_CLEAR(self->ctx);
        4967                 :          0 :     return 0;
        4968                 :            : }
        4969                 :            :
        4970                 :            :
        4971                 :            : static PyObject *
        4972                 :          0 : PySSLSession_get_time(PySSLSession *self, void *closure) {
        4973                 :          0 :     return PyLong_FromLong(SSL_SESSION_get_time(self->session));
        4974                 :            : }
        4975                 :            :
        4976                 :            : PyDoc_STRVAR(PySSLSession_get_time_doc,
        4977                 :            : "Session creation time (seconds since epoch).");
        4978                 :            :
        4979                 :            :
        4980                 :            : static PyObject *
        4981                 :          0 : PySSLSession_get_timeout(PySSLSession *self, void *closure) {
        4982                 :          0 :     return PyLong_FromLong(SSL_SESSION_get_timeout(self->session));
        4983                 :            : }
        4984                 :            :
        4985                 :            : PyDoc_STRVAR(PySSLSession_get_timeout_doc,
        4986                 :            : "Session timeout (delta in seconds).");
        4987                 :            :
        4988                 :            :
        4989                 :            : static PyObject *
        4990                 :          0 : PySSLSession_get_ticket_lifetime_hint(PySSLSession *self, void *closure) {
        4991                 :          0 :     unsigned long hint = SSL_SESSION_get_ticket_lifetime_hint(self->session);
        4992                 :          0 :     return PyLong_FromUnsignedLong(hint);
        4993                 :            : }
        4994                 :            :
        4995                 :            : PyDoc_STRVAR(PySSLSession_get_ticket_lifetime_hint_doc,
        4996                 :            : "Ticket life time hint.");
        4997                 :            :
        4998                 :            :
        4999                 :            : static PyObject *
        5000                 :          0 : PySSLSession_get_session_id(PySSLSession *self, void *closure) {
        5001                 :            :     const unsigned char *id;
        5002                 :            :     unsigned int len;
        5003                 :          0 :     id = SSL_SESSION_get_id(self->session, &len);
        5004                 :          0 :     return PyBytes_FromStringAndSize((const char *)id, len);
        5005                 :            : }
        5006                 :            :
        5007                 :            : PyDoc_STRVAR(PySSLSession_get_session_id_doc,
        5008                 :            : "Session id");
        5009                 :            :
        5010                 :            :
        5011                 :            : static PyObject *
        5012                 :          0 : PySSLSession_get_has_ticket(PySSLSession *self, void *closure) {
        5013         [ #  # ]:          0 :     if (SSL_SESSION_has_ticket(self->session)) {
        5014                 :          0 :         Py_RETURN_TRUE;
        5015                 :            :     } else {
        5016                 :          0 :         Py_RETURN_FALSE;
        5017                 :            :     }
        5018                 :            : }
        5019                 :            :
        5020                 :            : PyDoc_STRVAR(PySSLSession_get_has_ticket_doc,
        5021                 :            : "Does the session contain a ticket?");
        5022                 :            :
        5023                 :            :
        5024                 :            : static PyGetSetDef PySSLSession_getsetlist[] = {
        5025                 :            :     {"has_ticket", (getter) PySSLSession_get_has_ticket, NULL,
        5026                 :            :               PySSLSession_get_has_ticket_doc},
        5027                 :            :     {"id",   (getter) PySSLSession_get_session_id, NULL,
        5028                 :            :               PySSLSession_get_session_id_doc},
        5029                 :            :     {"ticket_lifetime_hint", (getter) PySSLSession_get_ticket_lifetime_hint,
        5030                 :            :               NULL, PySSLSession_get_ticket_lifetime_hint_doc},
        5031                 :            :     {"time", (getter) PySSLSession_get_time, NULL,
        5032                 :            :               PySSLSession_get_time_doc},
        5033                 :            :     {"timeout", (getter) PySSLSession_get_timeout, NULL,
        5034                 :            :               PySSLSession_get_timeout_doc},
        5035                 :            :     {NULL},            /* sentinel */
        5036                 :            : };
        5037                 :            :
        5038                 :            : static PyType_Slot PySSLSession_slots[] = {
        5039                 :            :     {Py_tp_getset,PySSLSession_getsetlist},
        5040                 :            :     {Py_tp_richcompare, PySSLSession_richcompare},
        5041                 :            :     {Py_tp_dealloc, PySSLSession_dealloc},
        5042                 :            :     {Py_tp_traverse, PySSLSession_traverse},
        5043                 :            :     {Py_tp_clear, PySSLSession_clear},
        5044                 :            :     {0, 0},
        5045                 :            : };
        5046                 :            :
        5047                 :            : static PyType_Spec PySSLSession_spec = {
        5048                 :            :     .name = "_ssl.SSLSession",
        5049                 :            :     .basicsize = sizeof(PySSLSession),
        5050                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
        5051                 :            :               Py_TPFLAGS_IMMUTABLETYPE |
        5052                 :            :               Py_TPFLAGS_DISALLOW_INSTANTIATION),
        5053                 :            :     .slots = PySSLSession_slots,
        5054                 :            : };
        5055                 :            :
        5056                 :            :
        5057                 :            : /* helper routines for seeding the SSL PRNG */
        5058                 :            : /*[clinic input]
        5059                 :            : _ssl.RAND_add
        5060                 :            :     string as view: Py_buffer(accept={str, buffer})
        5061                 :            :     entropy: double
        5062                 :            :     /
        5063                 :            :
        5064                 :            : Mix string into the OpenSSL PRNG state.
        5065                 :            :
        5066                 :            : entropy (a float) is a lower bound on the entropy contained in
        5067                 :            : string.  See RFC 4086.
        5068                 :            : [clinic start generated code]*/
        5069                 :            :
        5070                 :            : static PyObject *
        5071                 :          0 : _ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy)
        5072                 :            : /*[clinic end generated code: output=e6dd48df9c9024e9 input=5c33017422828f5c]*/
        5073                 :            : {
        5074                 :            :     const char *buf;
        5075                 :            :     Py_ssize_t len, written;
        5076                 :            :
        5077                 :          0 :     buf = (const char *)view->buf;
        5078                 :          0 :     len = view->len;
        5079                 :            :     do {
        5080                 :          0 :         written = Py_MIN(len, INT_MAX);
        5081                 :          0 :         RAND_add(buf, (int)written, entropy);
        5082                 :          0 :         buf += written;
        5083                 :          0 :         len -= written;
        5084         [ #  # ]:          0 :     } while (len);
        5085                 :          0 :     Py_RETURN_NONE;
        5086                 :            : }
        5087                 :            :
        5088                 :            : static PyObject *
        5089                 :          0 : PySSL_RAND(PyObject *module, int len, int pseudo)
        5090                 :            : {
        5091                 :            :     int ok;
        5092                 :            :     PyObject *bytes;
        5093                 :            :     unsigned long err;
        5094                 :            :     const char *errstr;
        5095                 :            :     PyObject *v;
        5096                 :            :
        5097         [ #  # ]:          0 :     if (len < 0) {
        5098                 :          0 :         PyErr_SetString(PyExc_ValueError, "num must be positive");
        5099                 :          0 :         return NULL;
        5100                 :            :     }
        5101                 :            :
        5102                 :          0 :     bytes = PyBytes_FromStringAndSize(NULL, len);
        5103         [ #  # ]:          0 :     if (bytes == NULL)
        5104                 :          0 :         return NULL;
        5105         [ #  # ]:          0 :     if (pseudo) {
        5106                 :          0 :         ok = RAND_bytes((unsigned char*)PyBytes_AS_STRING(bytes), len);
        5107   [ #  #  #  # ]:          0 :         if (ok == 0 || ok == 1)
        5108         [ #  # ]:          0 :             return Py_BuildValue("NO", bytes, ok == 1 ? Py_True : Py_False);
        5109                 :            :     }
        5110                 :            :     else {
        5111                 :          0 :         ok = RAND_bytes((unsigned char*)PyBytes_AS_STRING(bytes), len);
        5112         [ #  # ]:          0 :         if (ok == 1)
        5113                 :          0 :             return bytes;
        5114                 :            :     }
        5115                 :          0 :     Py_DECREF(bytes);
        5116                 :            :
        5117                 :          0 :     err = ERR_get_error();
        5118                 :          0 :     errstr = ERR_reason_error_string(err);
        5119                 :          0 :     v = Py_BuildValue("(ks)", err, errstr);
        5120         [ #  # ]:          0 :     if (v != NULL) {
        5121                 :          0 :         PyErr_SetObject(get_ssl_state(module)->PySSLErrorObject, v);
        5122                 :          0 :         Py_DECREF(v);
        5123                 :            :     }
        5124                 :          0 :     return NULL;
        5125                 :            : }
        5126                 :            :
        5127                 :            : /*[clinic input]
        5128                 :            : _ssl.RAND_bytes
        5129                 :            :     n: int
        5130                 :            :     /
        5131                 :            :
        5132                 :            : Generate n cryptographically strong pseudo-random bytes.
        5133                 :            : [clinic start generated code]*/
        5134                 :            :
        5135                 :            : static PyObject *
        5136                 :          0 : _ssl_RAND_bytes_impl(PyObject *module, int n)
        5137                 :            : /*[clinic end generated code: output=977da635e4838bc7 input=678ddf2872dfebfc]*/
        5138                 :            : {
        5139                 :          0 :     return PySSL_RAND(module, n, 0);
        5140                 :            : }
        5141                 :            :
        5142                 :            :
        5143                 :            : /*[clinic input]
        5144                 :            : _ssl.RAND_status
        5145                 :            :
        5146                 :            : Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.
        5147                 :            :
        5148                 :            : It is necessary to seed the PRNG with RAND_add() on some platforms before
        5149                 :            : using the ssl() function.
        5150                 :            : [clinic start generated code]*/
        5151                 :            :
        5152                 :            : static PyObject *
        5153                 :          0 : _ssl_RAND_status_impl(PyObject *module)
        5154                 :            : /*[clinic end generated code: output=7e0aaa2d39fdc1ad input=d5ae5aea52f36e01]*/
        5155                 :            : {
        5156                 :          0 :     return PyBool_FromLong(RAND_status());
        5157                 :            : }
        5158                 :            :
        5159                 :            : /*[clinic input]
        5160                 :            : _ssl.get_default_verify_paths
        5161                 :            :
        5162                 :            : Return search paths and environment vars that are used by SSLContext's set_default_verify_paths() to load default CAs.
        5163                 :            :
        5164                 :            : The values are 'cert_file_env', 'cert_file', 'cert_dir_env', 'cert_dir'.
        5165                 :            : [clinic start generated code]*/
        5166                 :            :
        5167                 :            : static PyObject *
        5168                 :          0 : _ssl_get_default_verify_paths_impl(PyObject *module)
        5169                 :            : /*[clinic end generated code: output=e5b62a466271928b input=5210c953d98c3eb5]*/
        5170                 :            : {
        5171                 :          0 :     PyObject *ofile_env = NULL;
        5172                 :          0 :     PyObject *ofile = NULL;
        5173                 :          0 :     PyObject *odir_env = NULL;
        5174                 :          0 :     PyObject *odir = NULL;
        5175                 :            :
        5176                 :            : #define CONVERT(info, target) { \
        5177                 :            :         const char *tmp = (info); \
        5178                 :            :         target = NULL; \
        5179                 :            :         if (!tmp) { target = Py_NewRef(Py_None); } \
        5180                 :            :         else if ((target = PyUnicode_DecodeFSDefault(tmp)) == NULL) { \
        5181                 :            :             target = PyBytes_FromString(tmp); } \
        5182                 :            :         if (!target) goto error; \
        5183                 :            :     }
        5184                 :            :
        5185   [ #  #  #  #  :          0 :     CONVERT(X509_get_default_cert_file_env(), ofile_env);
                       #  # ]
        5186   [ #  #  #  #  :          0 :     CONVERT(X509_get_default_cert_file(), ofile);
                       #  # ]
        5187   [ #  #  #  #  :          0 :     CONVERT(X509_get_default_cert_dir_env(), odir_env);
                       #  # ]
        5188   [ #  #  #  #  :          0 :     CONVERT(X509_get_default_cert_dir(), odir);
                       #  # ]
        5189                 :            : #undef CONVERT
        5190                 :            :
        5191                 :          0 :     return Py_BuildValue("NNNN", ofile_env, ofile, odir_env, odir);
        5192                 :            :
        5193                 :          0 :   error:
        5194                 :          0 :     Py_XDECREF(ofile_env);
        5195                 :          0 :     Py_XDECREF(ofile);
        5196                 :          0 :     Py_XDECREF(odir_env);
        5197                 :          0 :     Py_XDECREF(odir);
        5198                 :          0 :     return NULL;
        5199                 :            : }
        5200                 :            :
        5201                 :            : static PyObject*
        5202                 :          4 : asn1obj2py(_sslmodulestate *state, ASN1_OBJECT *obj)
        5203                 :            : {
        5204                 :            :     int nid;
        5205                 :            :     const char *ln, *sn;
        5206                 :            :
        5207                 :          4 :     nid = OBJ_obj2nid(obj);
        5208         [ -  + ]:          4 :     if (nid == NID_undef) {
        5209                 :          0 :         PyErr_Format(PyExc_ValueError, "Unknown object");
        5210                 :          0 :         return NULL;
        5211                 :            :     }
        5212                 :          4 :     sn = OBJ_nid2sn(nid);
        5213                 :          4 :     ln = OBJ_nid2ln(nid);
        5214                 :          4 :     return Py_BuildValue("issN", nid, sn, ln, _asn1obj2py(state, obj, 1));
        5215                 :            : }
        5216                 :            :
        5217                 :            : /*[clinic input]
        5218                 :            : _ssl.txt2obj
        5219                 :            :     txt: str
        5220                 :            :     name: bool = False
        5221                 :            :
        5222                 :            : Lookup NID, short name, long name and OID of an ASN1_OBJECT.
        5223                 :            :
        5224                 :            : By default objects are looked up by OID. With name=True short and
        5225                 :            : long name are also matched.
        5226                 :            : [clinic start generated code]*/
        5227                 :            :
        5228                 :            : static PyObject *
        5229                 :          4 : _ssl_txt2obj_impl(PyObject *module, const char *txt, int name)
        5230                 :            : /*[clinic end generated code: output=c38e3991347079c1 input=1c1e7d0aa7c48602]*/
        5231                 :            : {
        5232                 :          4 :     PyObject *result = NULL;
        5233                 :            :     ASN1_OBJECT *obj;
        5234                 :            :
        5235                 :          4 :     obj = OBJ_txt2obj(txt, name ? 0 : 1);
        5236         [ -  + ]:          4 :     if (obj == NULL) {
        5237                 :          0 :         PyErr_Format(PyExc_ValueError, "unknown object '%.100s'", txt);
        5238                 :          0 :         return NULL;
        5239                 :            :     }
        5240                 :          4 :     result = asn1obj2py(get_ssl_state(module), obj);
        5241                 :          4 :     ASN1_OBJECT_free(obj);
        5242                 :          4 :     return result;
        5243                 :            : }
        5244                 :            :
        5245                 :            : /*[clinic input]
        5246                 :            : _ssl.nid2obj
        5247                 :            :     nid: int
        5248                 :            :     /
        5249                 :            :
        5250                 :            : Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.
        5251                 :            : [clinic start generated code]*/
        5252                 :            :
        5253                 :            : static PyObject *
        5254                 :          0 : _ssl_nid2obj_impl(PyObject *module, int nid)
        5255                 :            : /*[clinic end generated code: output=4a98ab691cd4f84a input=51787a3bee7d8f98]*/
        5256                 :            : {
        5257                 :          0 :     PyObject *result = NULL;
        5258                 :            :     ASN1_OBJECT *obj;
        5259                 :            :
        5260         [ #  # ]:          0 :     if (nid < NID_undef) {
        5261                 :          0 :         PyErr_SetString(PyExc_ValueError, "NID must be positive.");
        5262                 :          0 :         return NULL;
        5263                 :            :     }
        5264                 :          0 :     obj = OBJ_nid2obj(nid);
        5265         [ #  # ]:          0 :     if (obj == NULL) {
        5266                 :          0 :         PyErr_Format(PyExc_ValueError, "unknown NID %i", nid);
        5267                 :          0 :         return NULL;
        5268                 :            :     }
        5269                 :          0 :     result = asn1obj2py(get_ssl_state(module), obj);
        5270                 :          0 :     ASN1_OBJECT_free(obj);
        5271                 :          0 :     return result;
        5272                 :            : }
        5273                 :            :
        5274                 :            : #ifdef _MSC_VER
        5275                 :            :
        5276                 :            : static PyObject*
        5277                 :            : certEncodingType(DWORD encodingType)
        5278                 :            : {
        5279                 :            :     static PyObject *x509_asn = NULL;
        5280                 :            :     static PyObject *pkcs_7_asn = NULL;
        5281                 :            :
        5282                 :            :     if (x509_asn == NULL) {
        5283                 :            :         x509_asn = PyUnicode_InternFromString("x509_asn");
        5284                 :            :         if (x509_asn == NULL)
        5285                 :            :             return NULL;
        5286                 :            :     }
        5287                 :            :     if (pkcs_7_asn == NULL) {
        5288                 :            :         pkcs_7_asn = PyUnicode_InternFromString("pkcs_7_asn");
        5289                 :            :         if (pkcs_7_asn == NULL)
        5290                 :            :             return NULL;
        5291                 :            :     }
        5292                 :            :     switch(encodingType) {
        5293                 :            :     case X509_ASN_ENCODING:
        5294                 :            :         return Py_NewRef(x509_asn);
        5295                 :            :     case PKCS_7_ASN_ENCODING:
        5296                 :            :         return Py_NewRef(pkcs_7_asn);
        5297                 :            :     default:
        5298                 :            :         return PyLong_FromLong(encodingType);
        5299                 :            :     }
        5300                 :            : }
        5301                 :            :
        5302                 :            : static PyObject*
        5303                 :            : parseKeyUsage(PCCERT_CONTEXT pCertCtx, DWORD flags)
        5304                 :            : {
        5305                 :            :     CERT_ENHKEY_USAGE *usage;
        5306                 :            :     DWORD size, error, i;
        5307                 :            :     PyObject *retval;
        5308                 :            :
        5309                 :            :     if (!CertGetEnhancedKeyUsage(pCertCtx, flags, NULL, &size)) {
        5310                 :            :         error = GetLastError();
        5311                 :            :         if (error == CRYPT_E_NOT_FOUND) {
        5312                 :            :             Py_RETURN_TRUE;
        5313                 :            :         }
        5314                 :            :         return PyErr_SetFromWindowsErr(error);
        5315                 :            :     }
        5316                 :            :
        5317                 :            :     usage = (CERT_ENHKEY_USAGE*)PyMem_Malloc(size);
        5318                 :            :     if (usage == NULL) {
        5319                 :            :         return PyErr_NoMemory();
        5320                 :            :     }
        5321                 :            :
        5322                 :            :     /* Now get the actual enhanced usage property */
        5323                 :            :     if (!CertGetEnhancedKeyUsage(pCertCtx, flags, usage, &size)) {
        5324                 :            :         PyMem_Free(usage);
        5325                 :            :         error = GetLastError();
        5326                 :            :         if (error == CRYPT_E_NOT_FOUND) {
        5327                 :            :             Py_RETURN_TRUE;
        5328                 :            :         }
        5329                 :            :         return PyErr_SetFromWindowsErr(error);
        5330                 :            :     }
        5331                 :            :     retval = PyFrozenSet_New(NULL);
        5332                 :            :     if (retval == NULL) {
        5333                 :            :         goto error;
        5334                 :            :     }
        5335                 :            :     for (i = 0; i < usage->cUsageIdentifier; ++i) {
        5336                 :            :         if (usage->rgpszUsageIdentifier[i]) {
        5337                 :            :             PyObject *oid;
        5338                 :            :             int err;
        5339                 :            :             oid = PyUnicode_FromString(usage->rgpszUsageIdentifier[i]);
        5340                 :            :             if (oid == NULL) {
        5341                 :            :                 Py_CLEAR(retval);
        5342                 :            :                 goto error;
        5343                 :            :             }
        5344                 :            :             err = PySet_Add(retval, oid);
        5345                 :            :             Py_DECREF(oid);
        5346                 :            :             if (err == -1) {
        5347                 :            :                 Py_CLEAR(retval);
        5348                 :            :                 goto error;
        5349                 :            :             }
        5350                 :            :         }
        5351                 :            :     }
        5352                 :            :   error:
        5353                 :            :     PyMem_Free(usage);
        5354                 :            :     return retval;
        5355                 :            : }
        5356                 :            :
        5357                 :            : static HCERTSTORE
        5358                 :            : ssl_collect_certificates(const char *store_name)
        5359                 :            : {
        5360                 :            : /* this function collects the system certificate stores listed in
        5361                 :            :  * system_stores into a collection certificate store for being
        5362                 :            :  * enumerated. The store must be readable to be added to the
        5363                 :            :  * store collection.
        5364                 :            :  */
        5365                 :            :
        5366                 :            :     HCERTSTORE hCollectionStore = NULL, hSystemStore = NULL;
        5367                 :            :     static DWORD system_stores[] = {
        5368                 :            :         CERT_SYSTEM_STORE_LOCAL_MACHINE,
        5369                 :            :         CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE,
        5370                 :            :         CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY,
        5371                 :            :         CERT_SYSTEM_STORE_CURRENT_USER,
        5372                 :            :         CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY,
        5373                 :            :         CERT_SYSTEM_STORE_SERVICES,
        5374                 :            :         CERT_SYSTEM_STORE_USERS};
        5375                 :            :     size_t i, storesAdded;
        5376                 :            :     BOOL result;
        5377                 :            :
        5378                 :            :     hCollectionStore = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0,
        5379                 :            :                                      (HCRYPTPROV)NULL, 0, NULL);
        5380                 :            :     if (!hCollectionStore) {
        5381                 :            :         return NULL;
        5382                 :            :     }
        5383                 :            :     storesAdded = 0;
        5384                 :            :     for (i = 0; i < sizeof(system_stores) / sizeof(DWORD); i++) {
        5385                 :            :         hSystemStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_A, 0,
        5386                 :            :                                      (HCRYPTPROV)NULL,
        5387                 :            :                                      CERT_STORE_READONLY_FLAG |
        5388                 :            :                                      system_stores[i], store_name);
        5389                 :            :         if (hSystemStore) {
        5390                 :            :             result = CertAddStoreToCollection(hCollectionStore, hSystemStore,
        5391                 :            :                                      CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
        5392                 :            :             if (result) {
        5393                 :            :                 ++storesAdded;
        5394                 :            :             }
        5395                 :            :             CertCloseStore(hSystemStore, 0);  /* flag must be 0 */
        5396                 :            :         }
        5397                 :            :     }
        5398                 :            :     if (storesAdded == 0) {
        5399                 :            :         CertCloseStore(hCollectionStore, CERT_CLOSE_STORE_FORCE_FLAG);
        5400                 :            :         return NULL;
        5401                 :            :     }
        5402                 :            :
        5403                 :            :     return hCollectionStore;
        5404                 :            : }
        5405                 :            :
        5406                 :            : /*[clinic input]
        5407                 :            : _ssl.enum_certificates
        5408                 :            :     store_name: str
        5409                 :            :
        5410                 :            : Retrieve certificates from Windows' cert store.
        5411                 :            :
        5412                 :            : store_name may be one of 'CA', 'ROOT' or 'MY'.  The system may provide
        5413                 :            : more cert storages, too.  The function returns a list of (bytes,
        5414                 :            : encoding_type, trust) tuples.  The encoding_type flag can be interpreted
        5415                 :            : with X509_ASN_ENCODING or PKCS_7_ASN_ENCODING. The trust setting is either
        5416                 :            : a set of OIDs or the boolean True.
        5417                 :            : [clinic start generated code]*/
        5418                 :            :
        5419                 :            : static PyObject *
        5420                 :            : _ssl_enum_certificates_impl(PyObject *module, const char *store_name)
        5421                 :            : /*[clinic end generated code: output=5134dc8bb3a3c893 input=915f60d70461ea4e]*/
        5422                 :            : {
        5423                 :            :     HCERTSTORE hCollectionStore = NULL;
        5424                 :            :     PCCERT_CONTEXT pCertCtx = NULL;
        5425                 :            :     PyObject *keyusage = NULL, *cert = NULL, *enc = NULL, *tup = NULL;
        5426                 :            :     PyObject *result = NULL;
        5427                 :            :
        5428                 :            :     result = PySet_New(NULL);
        5429                 :            :     if (result == NULL) {
        5430                 :            :         return NULL;
        5431                 :            :     }
        5432                 :            :     hCollectionStore = ssl_collect_certificates(store_name);
        5433                 :            :     if (hCollectionStore == NULL) {
        5434                 :            :         Py_DECREF(result);
        5435                 :            :         return PyErr_SetFromWindowsErr(GetLastError());
        5436                 :            :     }
        5437                 :            :
        5438                 :            :     while (pCertCtx = CertEnumCertificatesInStore(hCollectionStore, pCertCtx)) {
        5439                 :            :         cert = PyBytes_FromStringAndSize((const char*)pCertCtx->pbCertEncoded,
        5440                 :            :                                             pCertCtx->cbCertEncoded);
        5441                 :            :         if (!cert) {
        5442                 :            :             Py_CLEAR(result);
        5443                 :            :             break;
        5444                 :            :         }
        5445                 :            :         if ((enc = certEncodingType(pCertCtx->dwCertEncodingType)) == NULL) {
        5446                 :            :             Py_CLEAR(result);
        5447                 :            :             break;
        5448                 :            :         }
        5449                 :            :         keyusage = parseKeyUsage(pCertCtx, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG);
        5450                 :            :         if (keyusage == Py_True) {
        5451                 :            :             Py_DECREF(keyusage);
        5452                 :            :             keyusage = parseKeyUsage(pCertCtx, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG);
        5453                 :            :         }
        5454                 :            :         if (keyusage == NULL) {
        5455                 :            :             Py_CLEAR(result);
        5456                 :            :             break;
        5457                 :            :         }
        5458                 :            :         if ((tup = PyTuple_New(3)) == NULL) {
        5459                 :            :             Py_CLEAR(result);
        5460                 :            :             break;
        5461                 :            :         }
        5462                 :            :         PyTuple_SET_ITEM(tup, 0, cert);
        5463                 :            :         cert = NULL;
        5464                 :            :         PyTuple_SET_ITEM(tup, 1, enc);
        5465                 :            :         enc = NULL;
        5466                 :            :         PyTuple_SET_ITEM(tup, 2, keyusage);
        5467                 :            :         keyusage = NULL;
        5468                 :            :         if (PySet_Add(result, tup) == -1) {
        5469                 :            :             Py_CLEAR(result);
        5470                 :            :             Py_CLEAR(tup);
        5471                 :            :             break;
        5472                 :            :         }
        5473                 :            :         Py_CLEAR(tup);
        5474                 :            :     }
        5475                 :            :     if (pCertCtx) {
        5476                 :            :         /* loop ended with an error, need to clean up context manually */
        5477                 :            :         CertFreeCertificateContext(pCertCtx);
        5478                 :            :     }
        5479                 :            :
        5480                 :            :     /* In error cases cert, enc and tup may not be NULL */
        5481                 :            :     Py_XDECREF(cert);
        5482                 :            :     Py_XDECREF(enc);
        5483                 :            :     Py_XDECREF(keyusage);
        5484                 :            :     Py_XDECREF(tup);
        5485                 :            :
        5486                 :            :     /* CERT_CLOSE_STORE_FORCE_FLAG forces freeing of memory for all contexts
        5487                 :            :        associated with the store, in this case our collection store and the
        5488                 :            :        associated system stores. */
        5489                 :            :     if (!CertCloseStore(hCollectionStore, CERT_CLOSE_STORE_FORCE_FLAG)) {
        5490                 :            :         /* This error case might shadow another exception.*/
        5491                 :            :         Py_XDECREF(result);
        5492                 :            :         return PyErr_SetFromWindowsErr(GetLastError());
        5493                 :            :     }
        5494                 :            :
        5495                 :            :     /* convert set to list */
        5496                 :            :     if (result == NULL) {
        5497                 :            :         return NULL;
        5498                 :            :     } else {
        5499                 :            :         PyObject *lst = PySequence_List(result);
        5500                 :            :         Py_DECREF(result);
        5501                 :            :         return lst;
        5502                 :            :     }
        5503                 :            : }
        5504                 :            :
        5505                 :            : /*[clinic input]
        5506                 :            : _ssl.enum_crls
        5507                 :            :     store_name: str
        5508                 :            :
        5509                 :            : Retrieve CRLs from Windows' cert store.
        5510                 :            :
        5511                 :            : store_name may be one of 'CA', 'ROOT' or 'MY'.  The system may provide
        5512                 :            : more cert storages, too.  The function returns a list of (bytes,
        5513                 :            : encoding_type) tuples.  The encoding_type flag can be interpreted with
        5514                 :            : X509_ASN_ENCODING or PKCS_7_ASN_ENCODING.
        5515                 :            : [clinic start generated code]*/
        5516                 :            :
        5517                 :            : static PyObject *
        5518                 :            : _ssl_enum_crls_impl(PyObject *module, const char *store_name)
        5519                 :            : /*[clinic end generated code: output=bce467f60ccd03b6 input=a1f1d7629f1c5d3d]*/
        5520                 :            : {
        5521                 :            :     HCERTSTORE hCollectionStore = NULL;
        5522                 :            :     PCCRL_CONTEXT pCrlCtx = NULL;
        5523                 :            :     PyObject *crl = NULL, *enc = NULL, *tup = NULL;
        5524                 :            :     PyObject *result = NULL;
        5525                 :            :
        5526                 :            :     result = PySet_New(NULL);
        5527                 :            :     if (result == NULL) {
        5528                 :            :         return NULL;
        5529                 :            :     }
        5530                 :            :     hCollectionStore = ssl_collect_certificates(store_name);
        5531                 :            :     if (hCollectionStore == NULL) {
        5532                 :            :         Py_DECREF(result);
        5533                 :            :         return PyErr_SetFromWindowsErr(GetLastError());
        5534                 :            :     }
        5535                 :            :
        5536                 :            :     while (pCrlCtx = CertEnumCRLsInStore(hCollectionStore, pCrlCtx)) {
        5537                 :            :         crl = PyBytes_FromStringAndSize((const char*)pCrlCtx->pbCrlEncoded,
        5538                 :            :                                             pCrlCtx->cbCrlEncoded);
        5539                 :            :         if (!crl) {
        5540                 :            :             Py_CLEAR(result);
        5541                 :            :             break;
        5542                 :            :         }
        5543                 :            :         if ((enc = certEncodingType(pCrlCtx->dwCertEncodingType)) == NULL) {
        5544                 :            :             Py_CLEAR(result);
        5545                 :            :             break;
        5546                 :            :         }
        5547                 :            :         if ((tup = PyTuple_New(2)) == NULL) {
        5548                 :            :             Py_CLEAR(result);
        5549                 :            :             break;
        5550                 :            :         }
        5551                 :            :         PyTuple_SET_ITEM(tup, 0, crl);
        5552                 :            :         crl = NULL;
        5553                 :            :         PyTuple_SET_ITEM(tup, 1, enc);
        5554                 :            :         enc = NULL;
        5555                 :            :
        5556                 :            :         if (PySet_Add(result, tup) == -1) {
        5557                 :            :             Py_CLEAR(result);
        5558                 :            :             Py_CLEAR(tup);
        5559                 :            :             break;
        5560                 :            :         }
        5561                 :            :         Py_CLEAR(tup);
        5562                 :            :     }
        5563                 :            :     if (pCrlCtx) {
        5564                 :            :         /* loop ended with an error, need to clean up context manually */
        5565                 :            :         CertFreeCRLContext(pCrlCtx);
        5566                 :            :     }
        5567                 :            :
        5568                 :            :     /* In error cases cert, enc and tup may not be NULL */
        5569                 :            :     Py_XDECREF(crl);
        5570                 :            :     Py_XDECREF(enc);
        5571                 :            :     Py_XDECREF(tup);
        5572                 :            :
        5573                 :            :     /* CERT_CLOSE_STORE_FORCE_FLAG forces freeing of memory for all contexts
        5574                 :            :        associated with the store, in this case our collection store and the
        5575                 :            :        associated system stores. */
        5576                 :            :     if (!CertCloseStore(hCollectionStore, CERT_CLOSE_STORE_FORCE_FLAG)) {
        5577                 :            :         /* This error case might shadow another exception.*/
        5578                 :            :         Py_XDECREF(result);
        5579                 :            :         return PyErr_SetFromWindowsErr(GetLastError());
        5580                 :            :     }
        5581                 :            :     /* convert set to list */
        5582                 :            :     if (result == NULL) {
        5583                 :            :         return NULL;
        5584                 :            :     } else {
        5585                 :            :         PyObject *lst = PySequence_List(result);
        5586                 :            :         Py_DECREF(result);
        5587                 :            :         return lst;
        5588                 :            :     }
        5589                 :            : }
        5590                 :            :
        5591                 :            : #endif /* _MSC_VER */
        5592                 :            :
        5593                 :            : /* List of functions exported by this module. */
        5594                 :            : static PyMethodDef PySSL_methods[] = {
        5595                 :            :     _SSL__TEST_DECODE_CERT_METHODDEF
        5596                 :            :     _SSL_RAND_ADD_METHODDEF
        5597                 :            :     _SSL_RAND_BYTES_METHODDEF
        5598                 :            :     _SSL_RAND_STATUS_METHODDEF
        5599                 :            :     _SSL_GET_DEFAULT_VERIFY_PATHS_METHODDEF
        5600                 :            :     _SSL_ENUM_CERTIFICATES_METHODDEF
        5601                 :            :     _SSL_ENUM_CRLS_METHODDEF
        5602                 :            :     _SSL_TXT2OBJ_METHODDEF
        5603                 :            :     _SSL_NID2OBJ_METHODDEF
        5604                 :            :     {NULL,                  NULL}            /* Sentinel */
        5605                 :            : };
        5606                 :            :
        5607                 :            :
        5608                 :            : PyDoc_STRVAR(module_doc,
        5609                 :            : "Implementation module for SSL socket operations.  See the socket module\n\
        5610                 :            : for documentation.");
        5611                 :            :
        5612                 :            : static int
        5613                 :          2 : sslmodule_init_exceptions(PyObject *module)
        5614                 :            : {
        5615                 :          2 :     _sslmodulestate *state = get_ssl_state(module);
        5616                 :          2 :     PyObject *bases = NULL;
        5617                 :            :
        5618                 :            : #define add_exception(exc, name, doc, base)                                 \
        5619                 :            : do {                                                                        \
        5620                 :            :     (exc) = PyErr_NewExceptionWithDoc("ssl." name, (doc), (base), NULL);    \
        5621                 :            :     if ((state) == NULL) goto error;                                        \
        5622                 :            :     if (PyModule_AddObjectRef(module, name, exc) < 0) goto error;           \
        5623                 :            : } while(0)
        5624                 :            :
        5625                 :          2 :     state->PySSLErrorObject = PyType_FromSpecWithBases(
        5626                 :            :         &sslerror_type_spec, PyExc_OSError);
        5627         [ -  + ]:          2 :     if (state->PySSLErrorObject == NULL) {
        5628                 :          0 :         goto error;
        5629                 :            :     }
        5630         [ -  + ]:          2 :     if (PyModule_AddObjectRef(module, "SSLError", state->PySSLErrorObject) < 0) {
        5631                 :          0 :         goto error;
        5632                 :            :     }
        5633                 :            :
        5634                 :            :     /* ssl.CertificateError used to be a subclass of ValueError */
        5635                 :          2 :     bases = PyTuple_Pack(2, state->PySSLErrorObject, PyExc_ValueError);
        5636         [ -  + ]:          2 :     if (bases == NULL) {
        5637                 :          0 :         goto error;
        5638                 :            :     }
        5639   [ -  +  -  + ]:          2 :     add_exception(
        5640                 :            :         state->PySSLCertVerificationErrorObject,
        5641                 :            :         "SSLCertVerificationError",
        5642                 :            :         SSLCertVerificationError_doc,
        5643                 :            :         bases
        5644                 :            :     );
        5645         [ +  - ]:          2 :     Py_CLEAR(bases);
        5646                 :            :
        5647   [ -  +  -  + ]:          2 :     add_exception(
        5648                 :            :         state->PySSLZeroReturnErrorObject,
        5649                 :            :         "SSLZeroReturnError",
        5650                 :            :         SSLZeroReturnError_doc,
        5651                 :            :         state->PySSLErrorObject
        5652                 :            :     );
        5653                 :            :
        5654   [ -  +  -  + ]:          2 :     add_exception(
        5655                 :            :         state->PySSLWantWriteErrorObject,
        5656                 :            :         "SSLWantWriteError",
        5657                 :            :         SSLWantWriteError_doc,
        5658                 :            :         state->PySSLErrorObject
        5659                 :            :     );
        5660                 :            :
        5661   [ -  +  -  + ]:          2 :     add_exception(
        5662                 :            :         state->PySSLWantReadErrorObject,
        5663                 :            :         "SSLWantReadError",
        5664                 :            :         SSLWantReadError_doc,
        5665                 :            :         state->PySSLErrorObject
        5666                 :            :     );
        5667                 :            :
        5668   [ -  +  -  + ]:          2 :     add_exception(
        5669                 :            :         state->PySSLSyscallErrorObject,
        5670                 :            :         "SSLSyscallError",
        5671                 :            :         SSLSyscallError_doc,
        5672                 :            :         state->PySSLErrorObject
        5673                 :            :     );
        5674                 :            :
        5675   [ -  +  -  + ]:          2 :     add_exception(
        5676                 :            :         state->PySSLEOFErrorObject,
        5677                 :            :         "SSLEOFError",
        5678                 :            :         SSLEOFError_doc,
        5679                 :            :         state->PySSLErrorObject
        5680                 :            :     );
        5681                 :            : #undef add_exception
        5682                 :            :
        5683                 :          2 :     return 0;
        5684                 :          0 :   error:
        5685                 :          0 :     Py_XDECREF(bases);
        5686                 :          0 :     return -1;
        5687                 :            : }
        5688                 :            :
        5689                 :            : static int
        5690                 :          2 : sslmodule_init_socketapi(PyObject *module)
        5691                 :            : {
        5692                 :          2 :     _sslmodulestate *state = get_ssl_state(module);
        5693                 :          2 :     PySocketModule_APIObject *sockmod = PySocketModule_ImportModuleAndAPI();
        5694                 :            :
        5695   [ +  -  -  + ]:          2 :     if ((sockmod == NULL) || (sockmod->Sock_Type == NULL)) {
        5696                 :          0 :         return -1;
        5697                 :            :     }
        5698                 :          2 :     state->Sock_Type = (PyTypeObject*)Py_NewRef(sockmod->Sock_Type);
        5699                 :          2 :     return 0;
        5700                 :            : }
        5701                 :            :
        5702                 :            : static int
        5703                 :          2 : sslmodule_init_constants(PyObject *m)
        5704                 :            : {
        5705                 :            :
        5706                 :          2 :     PyModule_AddStringConstant(m, "_DEFAULT_CIPHERS",
        5707                 :            :                                PY_SSL_DEFAULT_CIPHER_STRING);
        5708                 :            :
        5709                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_ZERO_RETURN",
        5710                 :            :                             PY_SSL_ERROR_ZERO_RETURN);
        5711                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_WANT_READ",
        5712                 :            :                             PY_SSL_ERROR_WANT_READ);
        5713                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_WANT_WRITE",
        5714                 :            :                             PY_SSL_ERROR_WANT_WRITE);
        5715                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_WANT_X509_LOOKUP",
        5716                 :            :                             PY_SSL_ERROR_WANT_X509_LOOKUP);
        5717                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_SYSCALL",
        5718                 :            :                             PY_SSL_ERROR_SYSCALL);
        5719                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_SSL",
        5720                 :            :                             PY_SSL_ERROR_SSL);
        5721                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_WANT_CONNECT",
        5722                 :            :                             PY_SSL_ERROR_WANT_CONNECT);
        5723                 :            :     /* non ssl.h errorcodes */
        5724                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_EOF",
        5725                 :            :                             PY_SSL_ERROR_EOF);
        5726                 :          2 :     PyModule_AddIntConstant(m, "SSL_ERROR_INVALID_ERROR_CODE",
        5727                 :            :                             PY_SSL_ERROR_INVALID_ERROR_CODE);
        5728                 :            :     /* cert requirements */
        5729                 :          2 :     PyModule_AddIntConstant(m, "CERT_NONE",
        5730                 :            :                             PY_SSL_CERT_NONE);
        5731                 :          2 :     PyModule_AddIntConstant(m, "CERT_OPTIONAL",
        5732                 :            :                             PY_SSL_CERT_OPTIONAL);
        5733                 :          2 :     PyModule_AddIntConstant(m, "CERT_REQUIRED",
        5734                 :            :                             PY_SSL_CERT_REQUIRED);
        5735                 :            :     /* CRL verification for verification_flags */
        5736                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_DEFAULT",
        5737                 :            :                             0);
        5738                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_CRL_CHECK_LEAF",
        5739                 :            :                             X509_V_FLAG_CRL_CHECK);
        5740                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_CRL_CHECK_CHAIN",
        5741                 :            :                             X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
        5742                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_X509_STRICT",
        5743                 :            :                             X509_V_FLAG_X509_STRICT);
        5744                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_ALLOW_PROXY_CERTS",
        5745                 :            :                             X509_V_FLAG_ALLOW_PROXY_CERTS);
        5746                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_X509_TRUSTED_FIRST",
        5747                 :            :                             X509_V_FLAG_TRUSTED_FIRST);
        5748                 :            :
        5749                 :            : #ifdef X509_V_FLAG_PARTIAL_CHAIN
        5750                 :          2 :     PyModule_AddIntConstant(m, "VERIFY_X509_PARTIAL_CHAIN",
        5751                 :            :                             X509_V_FLAG_PARTIAL_CHAIN);
        5752                 :            : #endif
        5753                 :            :
        5754                 :            :     /* Alert Descriptions from ssl.h */
        5755                 :            :     /* note RESERVED constants no longer intended for use have been removed */
        5756                 :            :     /* http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-6 */
        5757                 :            :
        5758                 :            : #define ADD_AD_CONSTANT(s) \
        5759                 :            :     PyModule_AddIntConstant(m, "ALERT_DESCRIPTION_"#s, \
        5760                 :            :                             SSL_AD_##s)
        5761                 :            :
        5762                 :          2 :     ADD_AD_CONSTANT(CLOSE_NOTIFY);
        5763                 :          2 :     ADD_AD_CONSTANT(UNEXPECTED_MESSAGE);
        5764                 :          2 :     ADD_AD_CONSTANT(BAD_RECORD_MAC);
        5765                 :          2 :     ADD_AD_CONSTANT(RECORD_OVERFLOW);
        5766                 :          2 :     ADD_AD_CONSTANT(DECOMPRESSION_FAILURE);
        5767                 :          2 :     ADD_AD_CONSTANT(HANDSHAKE_FAILURE);
        5768                 :          2 :     ADD_AD_CONSTANT(BAD_CERTIFICATE);
        5769                 :          2 :     ADD_AD_CONSTANT(UNSUPPORTED_CERTIFICATE);
        5770                 :          2 :     ADD_AD_CONSTANT(CERTIFICATE_REVOKED);
        5771                 :          2 :     ADD_AD_CONSTANT(CERTIFICATE_EXPIRED);
        5772                 :          2 :     ADD_AD_CONSTANT(CERTIFICATE_UNKNOWN);
        5773                 :          2 :     ADD_AD_CONSTANT(ILLEGAL_PARAMETER);
        5774                 :          2 :     ADD_AD_CONSTANT(UNKNOWN_CA);
        5775                 :          2 :     ADD_AD_CONSTANT(ACCESS_DENIED);
        5776                 :          2 :     ADD_AD_CONSTANT(DECODE_ERROR);
        5777                 :          2 :     ADD_AD_CONSTANT(DECRYPT_ERROR);
        5778                 :          2 :     ADD_AD_CONSTANT(PROTOCOL_VERSION);
        5779                 :          2 :     ADD_AD_CONSTANT(INSUFFICIENT_SECURITY);
        5780                 :          2 :     ADD_AD_CONSTANT(INTERNAL_ERROR);
        5781                 :          2 :     ADD_AD_CONSTANT(USER_CANCELLED);
        5782                 :          2 :     ADD_AD_CONSTANT(NO_RENEGOTIATION);
        5783                 :            :     /* Not all constants are in old OpenSSL versions */
        5784                 :            : #ifdef SSL_AD_UNSUPPORTED_EXTENSION
        5785                 :          2 :     ADD_AD_CONSTANT(UNSUPPORTED_EXTENSION);
        5786                 :            : #endif
        5787                 :            : #ifdef SSL_AD_CERTIFICATE_UNOBTAINABLE
        5788                 :          2 :     ADD_AD_CONSTANT(CERTIFICATE_UNOBTAINABLE);
        5789                 :            : #endif
        5790                 :            : #ifdef SSL_AD_UNRECOGNIZED_NAME
        5791                 :          2 :     ADD_AD_CONSTANT(UNRECOGNIZED_NAME);
        5792                 :            : #endif
        5793                 :            : #ifdef SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE
        5794                 :          2 :     ADD_AD_CONSTANT(BAD_CERTIFICATE_STATUS_RESPONSE);
        5795                 :            : #endif
        5796                 :            : #ifdef SSL_AD_BAD_CERTIFICATE_HASH_VALUE
        5797                 :          2 :     ADD_AD_CONSTANT(BAD_CERTIFICATE_HASH_VALUE);
        5798                 :            : #endif
        5799                 :            : #ifdef SSL_AD_UNKNOWN_PSK_IDENTITY
        5800                 :          2 :     ADD_AD_CONSTANT(UNKNOWN_PSK_IDENTITY);
        5801                 :            : #endif
        5802                 :            :
        5803                 :            : #undef ADD_AD_CONSTANT
        5804                 :            :
        5805                 :            :     /* protocol versions */
        5806                 :            : #ifndef OPENSSL_NO_SSL3
        5807                 :            :     PyModule_AddIntConstant(m, "PROTOCOL_SSLv3",
        5808                 :            :                             PY_SSL_VERSION_SSL3);
        5809                 :            : #endif
        5810                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_SSLv23",
        5811                 :            :                             PY_SSL_VERSION_TLS);
        5812                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_TLS",
        5813                 :            :                             PY_SSL_VERSION_TLS);
        5814                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_TLS_CLIENT",
        5815                 :            :                             PY_SSL_VERSION_TLS_CLIENT);
        5816                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_TLS_SERVER",
        5817                 :            :                             PY_SSL_VERSION_TLS_SERVER);
        5818                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_TLSv1",
        5819                 :            :                             PY_SSL_VERSION_TLS1);
        5820                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_TLSv1_1",
        5821                 :            :                             PY_SSL_VERSION_TLS1_1);
        5822                 :          2 :     PyModule_AddIntConstant(m, "PROTOCOL_TLSv1_2",
        5823                 :            :                             PY_SSL_VERSION_TLS1_2);
        5824                 :            :
        5825                 :            :     /* protocol options */
        5826                 :          2 :     PyModule_AddIntConstant(m, "OP_ALL",
        5827                 :            :                             SSL_OP_ALL & ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
        5828                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_SSLv2", SSL_OP_NO_SSLv2);
        5829                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_SSLv3", SSL_OP_NO_SSLv3);
        5830                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_TLSv1", SSL_OP_NO_TLSv1);
        5831                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_TLSv1_1", SSL_OP_NO_TLSv1_1);
        5832                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_TLSv1_2", SSL_OP_NO_TLSv1_2);
        5833                 :            : #ifdef SSL_OP_NO_TLSv1_3
        5834                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_TLSv1_3", SSL_OP_NO_TLSv1_3);
        5835                 :            : #else
        5836                 :            :     PyModule_AddIntConstant(m, "OP_NO_TLSv1_3", 0);
        5837                 :            : #endif
        5838                 :          2 :     PyModule_AddIntConstant(m, "OP_CIPHER_SERVER_PREFERENCE",
        5839                 :            :                             SSL_OP_CIPHER_SERVER_PREFERENCE);
        5840                 :          2 :     PyModule_AddIntConstant(m, "OP_SINGLE_DH_USE", SSL_OP_SINGLE_DH_USE);
        5841                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_TICKET", SSL_OP_NO_TICKET);
        5842                 :          2 :     PyModule_AddIntConstant(m, "OP_LEGACY_SERVER_CONNECT",
        5843                 :            :                             SSL_OP_LEGACY_SERVER_CONNECT);
        5844                 :            : #ifdef SSL_OP_SINGLE_ECDH_USE
        5845                 :          2 :     PyModule_AddIntConstant(m, "OP_SINGLE_ECDH_USE", SSL_OP_SINGLE_ECDH_USE);
        5846                 :            : #endif
        5847                 :            : #ifdef SSL_OP_NO_COMPRESSION
        5848                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_COMPRESSION",
        5849                 :            :                             SSL_OP_NO_COMPRESSION);
        5850                 :            : #endif
        5851                 :            : #ifdef SSL_OP_ENABLE_MIDDLEBOX_COMPAT
        5852                 :          2 :     PyModule_AddIntConstant(m, "OP_ENABLE_MIDDLEBOX_COMPAT",
        5853                 :            :                             SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
        5854                 :            : #endif
        5855                 :            : #ifdef SSL_OP_NO_RENEGOTIATION
        5856                 :          2 :     PyModule_AddIntConstant(m, "OP_NO_RENEGOTIATION",
        5857                 :            :                             SSL_OP_NO_RENEGOTIATION);
        5858                 :            : #endif
        5859                 :            : #ifdef SSL_OP_IGNORE_UNEXPECTED_EOF
        5860                 :            :     PyModule_AddIntConstant(m, "OP_IGNORE_UNEXPECTED_EOF",
        5861                 :            :                             SSL_OP_IGNORE_UNEXPECTED_EOF);
        5862                 :            : #endif
        5863                 :            : #ifdef SSL_OP_ENABLE_KTLS
        5864                 :            :     PyModule_AddIntConstant(m, "OP_ENABLE_KTLS", SSL_OP_ENABLE_KTLS);
        5865                 :            : #endif
        5866                 :            :
        5867                 :            : #ifdef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT
        5868                 :          2 :     PyModule_AddIntConstant(m, "HOSTFLAG_ALWAYS_CHECK_SUBJECT",
        5869                 :            :                             X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT);
        5870                 :            : #endif
        5871                 :            : #ifdef X509_CHECK_FLAG_NEVER_CHECK_SUBJECT
        5872                 :          2 :     PyModule_AddIntConstant(m, "HOSTFLAG_NEVER_CHECK_SUBJECT",
        5873                 :            :                             X509_CHECK_FLAG_NEVER_CHECK_SUBJECT);
        5874                 :            : #endif
        5875                 :            : #ifdef X509_CHECK_FLAG_NO_WILDCARDS
        5876                 :          2 :     PyModule_AddIntConstant(m, "HOSTFLAG_NO_WILDCARDS",
        5877                 :            :                             X509_CHECK_FLAG_NO_WILDCARDS);
        5878                 :            : #endif
        5879                 :            : #ifdef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
        5880                 :          2 :     PyModule_AddIntConstant(m, "HOSTFLAG_NO_PARTIAL_WILDCARDS",
        5881                 :            :                             X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
        5882                 :            : #endif
        5883                 :            : #ifdef X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS
        5884                 :          2 :     PyModule_AddIntConstant(m, "HOSTFLAG_MULTI_LABEL_WILDCARDS",
        5885                 :            :                             X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS);
        5886                 :            : #endif
        5887                 :            : #ifdef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
        5888                 :          2 :     PyModule_AddIntConstant(m, "HOSTFLAG_SINGLE_LABEL_SUBDOMAINS",
        5889                 :            :                             X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS);
        5890                 :            : #endif
        5891                 :            :
        5892                 :            :     /* file types */
        5893                 :          2 :     PyModule_AddIntConstant(m, "ENCODING_PEM", PY_SSL_ENCODING_PEM);
        5894                 :          2 :     PyModule_AddIntConstant(m, "ENCODING_DER", PY_SSL_ENCODING_DER);
        5895                 :            :
        5896                 :            :     /* protocol versions */
        5897                 :          2 :     PyModule_AddIntConstant(m, "PROTO_MINIMUM_SUPPORTED",
        5898                 :            :                             PY_PROTO_MINIMUM_SUPPORTED);
        5899                 :          2 :     PyModule_AddIntConstant(m, "PROTO_MAXIMUM_SUPPORTED",
        5900                 :            :                             PY_PROTO_MAXIMUM_SUPPORTED);
        5901                 :          2 :     PyModule_AddIntConstant(m, "PROTO_SSLv3", PY_PROTO_SSLv3);
        5902                 :          2 :     PyModule_AddIntConstant(m, "PROTO_TLSv1", PY_PROTO_TLSv1);
        5903                 :          2 :     PyModule_AddIntConstant(m, "PROTO_TLSv1_1", PY_PROTO_TLSv1_1);
        5904                 :          2 :     PyModule_AddIntConstant(m, "PROTO_TLSv1_2", PY_PROTO_TLSv1_2);
        5905                 :          2 :     PyModule_AddIntConstant(m, "PROTO_TLSv1_3", PY_PROTO_TLSv1_3);
        5906                 :            :
        5907                 :            : #define addbool(m, key, value) \
        5908                 :            :     do { \
        5909                 :            :         PyObject *bool_obj = (value) ? Py_True : Py_False; \
        5910                 :            :         PyModule_AddObject((m), (key), Py_NewRef(bool_obj)); \
        5911                 :            :     } while (0)
        5912                 :            :
        5913                 :          2 :     addbool(m, "HAS_SNI", 1);
        5914                 :          2 :     addbool(m, "HAS_TLS_UNIQUE", 1);
        5915                 :          2 :     addbool(m, "HAS_ECDH", 1);
        5916                 :          2 :     addbool(m, "HAS_NPN", 0);
        5917                 :          2 :     addbool(m, "HAS_ALPN", 1);
        5918                 :            :
        5919                 :          2 :     addbool(m, "HAS_SSLv2", 0);
        5920                 :            :
        5921                 :            : #if defined(SSL3_VERSION) && !defined(OPENSSL_NO_SSL3)
        5922                 :            :     addbool(m, "HAS_SSLv3", 1);
        5923                 :            : #else
        5924                 :          2 :     addbool(m, "HAS_SSLv3", 0);
        5925                 :            : #endif
        5926                 :            :
        5927                 :            : #if defined(TLS1_VERSION) && !defined(OPENSSL_NO_TLS1)
        5928                 :          2 :     addbool(m, "HAS_TLSv1", 1);
        5929                 :            : #else
        5930                 :            :     addbool(m, "HAS_TLSv1", 0);
        5931                 :            : #endif
        5932                 :            :
        5933                 :            : #if defined(TLS1_1_VERSION) && !defined(OPENSSL_NO_TLS1_1)
        5934                 :          2 :     addbool(m, "HAS_TLSv1_1", 1);
        5935                 :            : #else
        5936                 :            :     addbool(m, "HAS_TLSv1_1", 0);
        5937                 :            : #endif
        5938                 :            :
        5939                 :            : #if defined(TLS1_2_VERSION) && !defined(OPENSSL_NO_TLS1_2)
        5940                 :          2 :     addbool(m, "HAS_TLSv1_2", 1);
        5941                 :            : #else
        5942                 :            :     addbool(m, "HAS_TLSv1_2", 0);
        5943                 :            : #endif
        5944                 :            :
        5945                 :            : #if defined(TLS1_3_VERSION) && !defined(OPENSSL_NO_TLS1_3)
        5946                 :          2 :     addbool(m, "HAS_TLSv1_3", 1);
        5947                 :            : #else
        5948                 :            :     addbool(m, "HAS_TLSv1_3", 0);
        5949                 :            : #endif
        5950                 :            :
        5951                 :          2 :     return 0;
        5952                 :            : }
        5953                 :            :
        5954                 :            : static int
        5955                 :          2 : sslmodule_init_errorcodes(PyObject *module)
        5956                 :            : {
        5957                 :          2 :     _sslmodulestate *state = get_ssl_state(module);
        5958                 :            :
        5959                 :            :     struct py_ssl_error_code *errcode;
        5960                 :            :     struct py_ssl_library_code *libcode;
        5961                 :            :
        5962                 :            :     /* Mappings for error codes */
        5963                 :          2 :     state->err_codes_to_names = PyDict_New();
        5964         [ -  + ]:          2 :     if (state->err_codes_to_names == NULL)
        5965                 :          0 :         return -1;
        5966                 :          2 :     state->err_names_to_codes = PyDict_New();
        5967         [ -  + ]:          2 :     if (state->err_names_to_codes == NULL)
        5968                 :          0 :         return -1;
        5969                 :          2 :     state->lib_codes_to_names = PyDict_New();
        5970         [ -  + ]:          2 :     if (state->lib_codes_to_names == NULL)
        5971                 :          0 :         return -1;
        5972                 :            :
        5973                 :          2 :     errcode = error_codes;
        5974         [ +  + ]:       2554 :     while (errcode->mnemonic != NULL) {
        5975                 :            :         PyObject *mnemo, *key;
        5976                 :       2552 :         mnemo = PyUnicode_FromString(errcode->mnemonic);
        5977                 :       2552 :         key = Py_BuildValue("ii", errcode->library, errcode->reason);
        5978   [ +  -  -  + ]:       2552 :         if (mnemo == NULL || key == NULL)
        5979                 :          0 :             return -1;
        5980         [ -  + ]:       2552 :         if (PyDict_SetItem(state->err_codes_to_names, key, mnemo))
        5981                 :          0 :             return -1;
        5982         [ -  + ]:       2552 :         if (PyDict_SetItem(state->err_names_to_codes, mnemo, key))
        5983                 :          0 :             return -1;
        5984                 :       2552 :         Py_DECREF(key);
        5985                 :       2552 :         Py_DECREF(mnemo);
        5986                 :       2552 :         errcode++;
        5987                 :            :     }
        5988                 :            :
        5989                 :          2 :     libcode = library_codes;
        5990         [ +  + ]:         78 :     while (libcode->library != NULL) {
        5991                 :            :         PyObject *mnemo, *key;
        5992                 :         76 :         key = PyLong_FromLong(libcode->code);
        5993                 :         76 :         mnemo = PyUnicode_FromString(libcode->library);
        5994   [ +  -  -  + ]:         76 :         if (key == NULL || mnemo == NULL)
        5995                 :          0 :             return -1;
        5996         [ -  + ]:         76 :         if (PyDict_SetItem(state->lib_codes_to_names, key, mnemo))
        5997                 :          0 :             return -1;
        5998                 :         76 :         Py_DECREF(key);
        5999                 :         76 :         Py_DECREF(mnemo);
        6000                 :         76 :         libcode++;
        6001                 :            :     }
        6002                 :            :
        6003         [ -  + ]:          2 :     if (PyModule_AddObjectRef(module, "err_codes_to_names", state->err_codes_to_names))
        6004                 :          0 :         return -1;
        6005         [ -  + ]:          2 :     if (PyModule_AddObjectRef(module, "err_names_to_codes", state->err_names_to_codes))
        6006                 :          0 :         return -1;
        6007         [ -  + ]:          2 :     if (PyModule_AddObjectRef(module, "lib_codes_to_names", state->lib_codes_to_names))
        6008                 :          0 :         return -1;
        6009                 :            :
        6010                 :          2 :     return 0;
        6011                 :            : }
        6012                 :            :
        6013                 :            : static void
        6014                 :          4 : parse_openssl_version(unsigned long libver,
        6015                 :            :                       unsigned int *major, unsigned int *minor,
        6016                 :            :                       unsigned int *fix, unsigned int *patch,
        6017                 :            :                       unsigned int *status)
        6018                 :            : {
        6019                 :          4 :     *status = libver & 0xF;
        6020                 :          4 :     libver >>= 4;
        6021                 :          4 :     *patch = libver & 0xFF;
        6022                 :          4 :     libver >>= 8;
        6023                 :          4 :     *fix = libver & 0xFF;
        6024                 :          4 :     libver >>= 8;
        6025                 :          4 :     *minor = libver & 0xFF;
        6026                 :          4 :     libver >>= 8;
        6027                 :          4 :     *major = libver & 0xFF;
        6028                 :          4 : }
        6029                 :            :
        6030                 :            : static int
        6031                 :          2 : sslmodule_init_versioninfo(PyObject *m)
        6032                 :            : {
        6033                 :            :     PyObject *r;
        6034                 :            :     unsigned long libver;
        6035                 :            :     unsigned int major, minor, fix, patch, status;
        6036                 :            :
        6037                 :            :     /* OpenSSL version */
        6038                 :            :     /* SSLeay() gives us the version of the library linked against,
        6039                 :            :        which could be different from the headers version.
        6040                 :            :     */
        6041                 :          2 :     libver = OpenSSL_version_num();
        6042                 :          2 :     r = PyLong_FromUnsignedLong(libver);
        6043   [ +  -  -  + ]:          2 :     if (r == NULL || PyModule_AddObject(m, "OPENSSL_VERSION_NUMBER", r))
        6044                 :          0 :         return -1;
        6045                 :            :
        6046                 :          2 :     parse_openssl_version(libver, &major, &minor, &fix, &patch, &status);
        6047                 :          2 :     r = Py_BuildValue("IIIII", major, minor, fix, patch, status);
        6048   [ +  -  -  + ]:          2 :     if (r == NULL || PyModule_AddObject(m, "OPENSSL_VERSION_INFO", r))
        6049                 :          0 :         return -1;
        6050                 :            :
        6051                 :          2 :     r = PyUnicode_FromString(OpenSSL_version(OPENSSL_VERSION));
        6052   [ +  -  -  + ]:          2 :     if (r == NULL || PyModule_AddObject(m, "OPENSSL_VERSION", r))
        6053                 :          0 :         return -1;
        6054                 :            :
        6055                 :          2 :     libver = OPENSSL_VERSION_NUMBER;
        6056                 :          2 :     parse_openssl_version(libver, &major, &minor, &fix, &patch, &status);
        6057                 :          2 :     r = Py_BuildValue("IIIII", major, minor, fix, patch, status);
        6058   [ +  -  -  + ]:          2 :     if (r == NULL || PyModule_AddObject(m, "_OPENSSL_API_VERSION", r))
        6059                 :          0 :         return -1;
        6060                 :            :
        6061                 :          2 :     return 0;
        6062                 :            : }
        6063                 :            :
        6064                 :            : static int
        6065                 :          2 : sslmodule_init_types(PyObject *module)
        6066                 :            : {
        6067                 :          2 :     _sslmodulestate *state = get_ssl_state(module);
        6068                 :            :
        6069                 :          2 :     state->PySSLContext_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
        6070                 :            :         module, &PySSLContext_spec, NULL
        6071                 :            :     );
        6072         [ -  + ]:          2 :     if (state->PySSLContext_Type == NULL)
        6073                 :          0 :         return -1;
        6074                 :            :
        6075                 :          2 :     state->PySSLSocket_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
        6076                 :            :         module, &PySSLSocket_spec, NULL
        6077                 :            :     );
        6078         [ -  + ]:          2 :     if (state->PySSLSocket_Type == NULL)
        6079                 :          0 :         return -1;
        6080                 :            :
        6081                 :          2 :     state->PySSLMemoryBIO_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
        6082                 :            :         module, &PySSLMemoryBIO_spec, NULL
        6083                 :            :     );
        6084         [ -  + ]:          2 :     if (state->PySSLMemoryBIO_Type == NULL)
        6085                 :          0 :         return -1;
        6086                 :            :
        6087                 :          2 :     state->PySSLSession_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
        6088                 :            :         module, &PySSLSession_spec, NULL
        6089                 :            :     );
        6090         [ -  + ]:          2 :     if (state->PySSLSession_Type == NULL)
        6091                 :          0 :         return -1;
        6092                 :            :
        6093                 :          2 :     state->PySSLCertificate_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
        6094                 :            :         module, &PySSLCertificate_spec, NULL
        6095                 :            :     );
        6096         [ -  + ]:          2 :     if (state->PySSLCertificate_Type == NULL)
        6097                 :          0 :         return -1;
        6098                 :            :
        6099         [ -  + ]:          2 :     if (PyModule_AddType(module, state->PySSLContext_Type))
        6100                 :          0 :         return -1;
        6101         [ -  + ]:          2 :     if (PyModule_AddType(module, state->PySSLSocket_Type))
        6102                 :          0 :         return -1;
        6103         [ -  + ]:          2 :     if (PyModule_AddType(module, state->PySSLMemoryBIO_Type))
        6104                 :          0 :         return -1;
        6105         [ -  + ]:          2 :     if (PyModule_AddType(module, state->PySSLSession_Type))
        6106                 :          0 :         return -1;
        6107         [ -  + ]:          2 :     if (PyModule_AddType(module, state->PySSLCertificate_Type))
        6108                 :          0 :         return -1;
        6109                 :          2 :     return 0;
        6110                 :            : }
        6111                 :            :
        6112                 :            : static int
        6113                 :          2 : sslmodule_init_strings(PyObject *module)
        6114                 :            : {
        6115                 :          2 :     _sslmodulestate *state = get_ssl_state(module);
        6116                 :          2 :     state->str_library = PyUnicode_InternFromString("library");
        6117         [ -  + ]:          2 :     if (state->str_library == NULL) {
        6118                 :          0 :         return -1;
        6119                 :            :     }
        6120                 :          2 :     state->str_reason = PyUnicode_InternFromString("reason");
        6121         [ -  + ]:          2 :     if (state->str_reason == NULL) {
        6122                 :          0 :         return -1;
        6123                 :            :     }
        6124                 :          2 :     state->str_verify_message = PyUnicode_InternFromString("verify_message");
        6125         [ -  + ]:          2 :     if (state->str_verify_message == NULL) {
        6126                 :          0 :         return -1;
        6127                 :            :     }
        6128                 :          2 :     state->str_verify_code = PyUnicode_InternFromString("verify_code");
        6129         [ -  + ]:          2 :     if (state->str_verify_code == NULL) {
        6130                 :          0 :         return -1;
        6131                 :            :     }
        6132                 :          2 :     return 0;
        6133                 :            : }
        6134                 :            :
        6135                 :            : static PyModuleDef_Slot sslmodule_slots[] = {
        6136                 :            :     {Py_mod_exec, sslmodule_init_types},
        6137                 :            :     {Py_mod_exec, sslmodule_init_exceptions},
        6138                 :            :     {Py_mod_exec, sslmodule_init_socketapi},
        6139                 :            :     {Py_mod_exec, sslmodule_init_errorcodes},
        6140                 :            :     {Py_mod_exec, sslmodule_init_constants},
        6141                 :            :     {Py_mod_exec, sslmodule_init_versioninfo},
        6142                 :            :     {Py_mod_exec, sslmodule_init_strings},
        6143                 :            :     {0, NULL}
        6144                 :            : };
        6145                 :            :
        6146                 :            : static int
        6147                 :         18 : sslmodule_traverse(PyObject *m, visitproc visit, void *arg)
        6148                 :            : {
        6149                 :         18 :     _sslmodulestate *state = get_ssl_state(m);
        6150                 :            :
        6151   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLContext_Type);
        6152   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLSocket_Type);
        6153   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLMemoryBIO_Type);
        6154   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLSession_Type);
        6155   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLCertificate_Type);
        6156   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLErrorObject);
        6157   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLCertVerificationErrorObject);
        6158   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLZeroReturnErrorObject);
        6159   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLWantReadErrorObject);
        6160   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLWantWriteErrorObject);
        6161   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLSyscallErrorObject);
        6162   [ +  -  -  + ]:         18 :     Py_VISIT(state->PySSLEOFErrorObject);
        6163   [ +  -  -  + ]:         18 :     Py_VISIT(state->err_codes_to_names);
        6164   [ +  -  -  + ]:         18 :     Py_VISIT(state->err_names_to_codes);
        6165   [ +  -  -  + ]:         18 :     Py_VISIT(state->lib_codes_to_names);
        6166   [ +  -  -  + ]:         18 :     Py_VISIT(state->Sock_Type);
        6167                 :            :
        6168                 :         18 :     return 0;
        6169                 :            : }
        6170                 :            :
        6171                 :            : static int
        6172                 :          4 : sslmodule_clear(PyObject *m)
        6173                 :            : {
        6174                 :          4 :     _sslmodulestate *state = get_ssl_state(m);
        6175                 :            :
        6176         [ +  + ]:          4 :     Py_CLEAR(state->PySSLContext_Type);
        6177         [ +  + ]:          4 :     Py_CLEAR(state->PySSLSocket_Type);
        6178         [ +  + ]:          4 :     Py_CLEAR(state->PySSLMemoryBIO_Type);
        6179         [ +  + ]:          4 :     Py_CLEAR(state->PySSLSession_Type);
        6180         [ +  + ]:          4 :     Py_CLEAR(state->PySSLCertificate_Type);
        6181         [ +  + ]:          4 :     Py_CLEAR(state->PySSLErrorObject);
        6182         [ +  + ]:          4 :     Py_CLEAR(state->PySSLCertVerificationErrorObject);
        6183         [ +  + ]:          4 :     Py_CLEAR(state->PySSLZeroReturnErrorObject);
        6184         [ +  + ]:          4 :     Py_CLEAR(state->PySSLWantReadErrorObject);
        6185         [ +  + ]:          4 :     Py_CLEAR(state->PySSLWantWriteErrorObject);
        6186         [ +  + ]:          4 :     Py_CLEAR(state->PySSLSyscallErrorObject);
        6187         [ +  + ]:          4 :     Py_CLEAR(state->PySSLEOFErrorObject);
        6188         [ +  + ]:          4 :     Py_CLEAR(state->err_codes_to_names);
        6189         [ +  + ]:          4 :     Py_CLEAR(state->err_names_to_codes);
        6190         [ +  + ]:          4 :     Py_CLEAR(state->lib_codes_to_names);
        6191         [ +  + ]:          4 :     Py_CLEAR(state->Sock_Type);
        6192         [ +  + ]:          4 :     Py_CLEAR(state->str_library);
        6193         [ +  + ]:          4 :     Py_CLEAR(state->str_reason);
        6194         [ +  + ]:          4 :     Py_CLEAR(state->str_verify_code);
        6195         [ +  + ]:          4 :     Py_CLEAR(state->str_verify_message);
        6196                 :          4 :     return 0;
        6197                 :            : }
        6198                 :            :
        6199                 :            : static void
        6200                 :          2 : sslmodule_free(void *m)
        6201                 :            : {
        6202                 :          2 :     sslmodule_clear((PyObject *)m);
        6203                 :          2 : }
        6204                 :            :
        6205                 :            : static struct PyModuleDef _sslmodule_def = {
        6206                 :            :     PyModuleDef_HEAD_INIT,
        6207                 :            :     .m_name = "_ssl",
        6208                 :            :     .m_doc = module_doc,
        6209                 :            :     .m_size = sizeof(_sslmodulestate),
        6210                 :            :     .m_methods = PySSL_methods,
        6211                 :            :     .m_slots = sslmodule_slots,
        6212                 :            :     .m_traverse = sslmodule_traverse,
        6213                 :            :     .m_clear = sslmodule_clear,
        6214                 :            :     .m_free = sslmodule_free
        6215                 :            : };
        6216                 :            :
        6217                 :            : PyMODINIT_FUNC
        6218                 :          2 : PyInit__ssl(void)
        6219                 :            : {
        6220                 :          2 :     return PyModuleDef_Init(&_sslmodule_def);
        6221                 :            : }

Generated by: LCOV version 1.14