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