Debian Codegraph @

Lib/test/test_ssl.py

raw
1 # Test the support for SSL and sockets
2
3 import contextlib
4 import sys
5 import unittest
6 import unittest.mock
7 from ast import literal_eval
8 from threading import Thread
9 from test import support
10 from test.support import import_helper
11 from test.support import os_helper
12 from test.support import socket_helper
13 from test.support import threading_helper
14 from test.support import warnings_helper
15 from test.support import asyncore
16 import array
17 import re
18 import socket
19 import select
20 import struct
21 import time
22 import enum
23 import gc
24 import http.client
25 import os
26 import errno
27 import pprint
28 import urllib.request
29 import threading
30 import traceback
31 import weakref
32 import platform
33 import sysconfig
34 import functools
35 from contextlib import nullcontext
36 try:
37 import ctypes
38 except ImportError:
39 ctypes = None
40
41
42 ssl = import_helper.import_module("ssl")
43 import _ssl
44
45 from ssl import Purpose, TLSVersion, _TLSContentType, _TLSMessageType, _TLSAlertType
46
47 Py_DEBUG_WIN32 = support.Py_DEBUG and sys.platform == 'win32'
48
49 PROTOCOLS = sorted(ssl._PROTOCOL_NAMES)
50 HOST = socket_helper.HOST
51 IS_AWS_LC = "AWS-LC" in ssl.OPENSSL_VERSION
52 IS_OPENSSL_3_0_0 = ssl.OPENSSL_VERSION_INFO >= (3, 0, 0)
53 PY_SSL_DEFAULT_CIPHERS = sysconfig.get_config_var('PY_SSL_DEFAULT_CIPHERS')
54
55 HAS_KEYLOG = hasattr(ssl.SSLContext, 'keylog_filename')
56 requires_keylog = unittest.skipUnless(
57 HAS_KEYLOG, 'test requires OpenSSL 1.1.1 with keylog callback')
58 CAN_SET_KEYLOG = HAS_KEYLOG and os.name != "nt"
59 requires_keylog_setter = unittest.skipUnless(
60 CAN_SET_KEYLOG,
61 "cannot set 'keylog_filename' on Windows"
62 )
63
64
65 PROTOCOL_TO_TLS_VERSION = {}
66 for proto, ver in (
67 ("PROTOCOL_SSLv3", "SSLv3"),
68 ("PROTOCOL_TLSv1", "TLSv1"),
69 ("PROTOCOL_TLSv1_1", "TLSv1_1"),
70 ):
71 try:
72 proto = getattr(ssl, proto)
73 ver = getattr(ssl.TLSVersion, ver)
74 except AttributeError:
75 continue
76 PROTOCOL_TO_TLS_VERSION[proto] = ver
77
78 def data_file(*name):
79 return os.path.join(os.path.dirname(__file__), "certdata", *name)
80
81 # The custom key and certificate files used in test_ssl are generated
82 # using Lib/test/certdata/make_ssl_certs.py.
83 # Other certificates are simply fetched from the internet servers they
84 # are meant to authenticate.
85
86 CERTFILE = data_file("keycert.pem")
87 BYTES_CERTFILE = os.fsencode(CERTFILE)
88 ONLYCERT = data_file("ssl_cert.pem")
89 ONLYKEY = data_file("ssl_key.pem")
90 BYTES_ONLYCERT = os.fsencode(ONLYCERT)
91 BYTES_ONLYKEY = os.fsencode(ONLYKEY)
92 CERTFILE_PROTECTED = data_file("keycert.passwd.pem")
93 ONLYKEY_PROTECTED = data_file("ssl_key.passwd.pem")
94 KEY_PASSWORD = "somepass"
95 CAPATH = data_file("capath")
96 BYTES_CAPATH = os.fsencode(CAPATH)
97 CAFILE_NEURONIO = data_file("capath", "4e1295a3.0")
98 CAFILE_CACERT = data_file("capath", "5ed36f99.0")
99
100 with open(data_file('keycert.pem.reference')) as file:
101 CERTFILE_INFO = literal_eval(file.read())
102
103 # empty CRL
104 CRLFILE = data_file("revocation.crl")
105
106 # Two keys and certs signed by the same CA (for SNI tests)
107 SIGNED_CERTFILE = data_file("keycert3.pem")
108 SINGED_CERTFILE_ONLY = data_file("cert3.pem")
109 SIGNED_CERTFILE_HOSTNAME = 'localhost'
110
111 with open(data_file('keycert3.pem.reference')) as file:
112 SIGNED_CERTFILE_INFO = literal_eval(file.read())
113
114 SIGNED_CERTFILE2 = data_file("keycert4.pem")
115 SIGNED_CERTFILE2_HOSTNAME = 'fakehostname'
116 SIGNED_CERTFILE_ECC = data_file("keycertecc.pem")
117 SIGNED_CERTFILE_ECC_HOSTNAME = 'localhost-ecc'
118
119 # A custom testcase, extracted from `rfc5280::aki::leaf-missing-aki` in x509-limbo:
120 # The leaf (server) certificate has no AKI, which is forbidden under RFC 5280.
121 # See: https://x509-limbo.com/testcases/rfc5280/#rfc5280akileaf-missing-aki
122 LEAF_MISSING_AKI_CERTFILE = data_file("leaf-missing-aki.keycert.pem")
123 LEAF_MISSING_AKI_CERTFILE_HOSTNAME = "example.com"
124 LEAF_MISSING_AKI_CA = data_file("leaf-missing-aki.ca.pem")
125
126 # Same certificate as pycacert.pem, but without extra text in file
127 SIGNING_CA = data_file("capath", "ceff1710.0")
128 # cert with all kinds of subject alt names
129 ALLSANFILE = data_file("allsans.pem")
130 IDNSANSFILE = data_file("idnsans.pem")
131 NOSANFILE = data_file("nosan.pem")
132 NOSAN_HOSTNAME = 'localhost'
133
134 REMOTE_HOST = "self-signed.pythontest.net"
135
136 EMPTYCERT = data_file("nullcert.pem")
137 BADCERT = data_file("badcert.pem")
138 NONEXISTINGCERT = data_file("XXXnonexisting.pem")
139 BADKEY = data_file("badkey.pem")
140 NOKIACERT = data_file("nokia.pem")
141 NULLBYTECERT = data_file("nullbytecert.pem")
142 TALOS_INVALID_CRLDP = data_file("talos-2019-0758.pem")
143
144 DHFILE = data_file("ffdh3072.pem")
145 BYTES_DHFILE = os.fsencode(DHFILE)
146
147 # Not defined in all versions of OpenSSL
148 OP_NO_COMPRESSION = getattr(ssl, "OP_NO_COMPRESSION", 0)
149 OP_SINGLE_DH_USE = getattr(ssl, "OP_SINGLE_DH_USE", 0)
150 OP_SINGLE_ECDH_USE = getattr(ssl, "OP_SINGLE_ECDH_USE", 0)
151 OP_CIPHER_SERVER_PREFERENCE = getattr(ssl, "OP_CIPHER_SERVER_PREFERENCE", 0)
152 OP_ENABLE_MIDDLEBOX_COMPAT = getattr(ssl, "OP_ENABLE_MIDDLEBOX_COMPAT", 0)
153
154 # Ubuntu has patched OpenSSL and changed behavior of security level 2
155 # see https://bugs.python.org/issue41561#msg389003
156 def is_ubuntu():
157 try:
158 # Assume that any references of "ubuntu" implies Ubuntu-like distro
159 # The workaround is not required for 18.04, but doesn't hurt either.
160 with open("/etc/os-release", encoding="utf-8") as f:
161 return "ubuntu" in f.read()
162 except FileNotFoundError:
163 return False
164
165 if is_ubuntu():
166 def seclevel_workaround(*ctxs):
167 """Lower security level to '1' and allow all ciphers for TLS 1.0/1"""
168 for ctx in ctxs:
169 if (
170 hasattr(ctx, "minimum_version") and
171 ctx.minimum_version <= ssl.TLSVersion.TLSv1_1 and
172 ctx.security_level > 1
173 ):
174 ctx.set_ciphers("@SECLEVEL=1:ALL")
175 else:
176 def seclevel_workaround(*ctxs):
177 pass
178
179
180 def has_tls_protocol(protocol):
181 """Check if a TLS protocol is available and enabled
182
183 :param protocol: enum ssl._SSLMethod member or name
184 :return: bool
185 """
186 if isinstance(protocol, str):
187 assert protocol.startswith('PROTOCOL_')
188 protocol = getattr(ssl, protocol, None)
189 if protocol is None:
190 return False
191 if protocol in {
192 ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS_SERVER,
193 ssl.PROTOCOL_TLS_CLIENT
194 }:
195 # auto-negotiate protocols are always available
196 return True
197 name = protocol.name
198 return has_tls_version(name[len('PROTOCOL_'):])
199
200
201 @functools.lru_cache
202 def has_tls_version(version):
203 """Check if a TLS/SSL version is enabled
204
205 :param version: TLS version name or ssl.TLSVersion member
206 :return: bool
207 """
208 if isinstance(version, str):
209 version = ssl.TLSVersion.__members__[version]
210
211 # check compile time flags like ssl.HAS_TLSv1_2
212 if not getattr(ssl, f'HAS_{version.name}'):
213 return False
214
215 if IS_OPENSSL_3_0_0 and version < ssl.TLSVersion.TLSv1_2:
216 # bpo43791: 3.0.0-alpha14 fails with TLSV1_ALERT_INTERNAL_ERROR
217 return False
218
219 # check runtime and dynamic crypto policy settings. A TLS version may
220 # be compiled in but disabled by a policy or config option.
221 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
222 if (
223 hasattr(ctx, 'minimum_version') and
224 ctx.minimum_version != ssl.TLSVersion.MINIMUM_SUPPORTED and
225 version < ctx.minimum_version
226 ):
227 return False
228 if (
229 hasattr(ctx, 'maximum_version') and
230 ctx.maximum_version != ssl.TLSVersion.MAXIMUM_SUPPORTED and
231 version > ctx.maximum_version
232 ):
233 return False
234
235 return True
236
237
238 def requires_tls_version(version):
239 """Decorator to skip tests when a required TLS version is not available
240
241 :param version: TLS version name or ssl.TLSVersion member
242 :return:
243 """
244 def decorator(func):
245 @functools.wraps(func)
246 def wrapper(*args, **kw):
247 if not has_tls_version(version):
248 raise unittest.SkipTest(f"{version} is not available.")
249 else:
250 return func(*args, **kw)
251 return wrapper
252 return decorator
253
254
255 def handle_error(prefix):
256 exc_format = ' '.join(traceback.format_exception(sys.exception()))
257 if support.verbose:
258 sys.stdout.write(prefix + exc_format)
259
260
261 def utc_offset(): #NOTE: ignore issues like #1647654
262 # local time = utc time + utc offset
263 if time.daylight and time.localtime().tm_isdst > 0:
264 return -time.altzone # seconds
265 return -time.timezone
266
267
268 ignore_deprecation = warnings_helper.ignore_warnings(
269 category=DeprecationWarning
270 )
271
272
273 def make_test_context(
274 *,
275 server_side=False,
276 check_hostname=None,
277 cert_reqs=ssl.CERT_NONE,
278 ca_certs=None, certfile=None, keyfile=None,
279 ciphers=None,
280 min_version=None, max_version=None,
281 ):
282 if server_side:
283 context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
284 else:
285 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
286
287 if check_hostname is None:
288 if cert_reqs == ssl.CERT_NONE:
289 context.check_hostname = False
290 else:
291 context.check_hostname = check_hostname
292
293 if cert_reqs is not None:
294 context.verify_mode = cert_reqs
295
296 if ca_certs is not None:
297 context.load_verify_locations(ca_certs)
298 if certfile is not None or keyfile is not None:
299 context.load_cert_chain(certfile, keyfile)
300
301 if ciphers is not None:
302 context.set_ciphers(ciphers)
303
304 if min_version is not None:
305 context.minimum_version = min_version
306 if max_version is not None:
307 context.maximum_version = max_version
308
309 return context
310
311
312 def test_wrap_socket(
313 sock,
314 *,
315 server_side=False,
316 check_hostname=None,
317 cert_reqs=ssl.CERT_NONE,
318 ca_certs=None, certfile=None, keyfile=None,
319 ciphers=None,
320 min_version=None, max_version=None,
321 **kwargs,
322 ):
323 context = make_test_context(
324 server_side=server_side,
325 check_hostname=check_hostname,
326 cert_reqs=cert_reqs,
327 ca_certs=ca_certs, certfile=certfile, keyfile=keyfile,
328 ciphers=ciphers,
329 min_version=min_version, max_version=max_version,
330 )
331 if not server_side:
332 kwargs.setdefault("server_hostname", SIGNED_CERTFILE_HOSTNAME)
333 return context.wrap_socket(sock, server_side=server_side, **kwargs)
334
335
336 USE_SAME_TEST_CONTEXT = False
337 _TEST_CONTEXT = None
338
339 def testing_context(server_cert=SIGNED_CERTFILE, *, server_chain=True):
340 """Create context
341
342 client_context, server_context, hostname = testing_context()
343 """
344 global _TEST_CONTEXT
345 if USE_SAME_TEST_CONTEXT:
346 if _TEST_CONTEXT is not None:
347 return _TEST_CONTEXT
348
349 if server_cert == SIGNED_CERTFILE:
350 hostname = SIGNED_CERTFILE_HOSTNAME
351 elif server_cert == SIGNED_CERTFILE2:
352 hostname = SIGNED_CERTFILE2_HOSTNAME
353 elif server_cert == NOSANFILE:
354 hostname = NOSAN_HOSTNAME
355 else:
356 raise ValueError(server_cert)
357
358 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
359 client_context.load_verify_locations(SIGNING_CA)
360
361 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
362 server_context.load_cert_chain(server_cert)
363 if server_chain:
364 server_context.load_verify_locations(SIGNING_CA)
365
366 if USE_SAME_TEST_CONTEXT:
367 if _TEST_CONTEXT is not None:
368 _TEST_CONTEXT = client_context, server_context, hostname
369
370 return client_context, server_context, hostname
371
372
373 def do_ssl_object_handshake(sslobject, outgoing, max_retry=25):
374 """Call do_handshake() on the sslobject and return the sent data.
375
376 If do_handshake() fails more than *max_retry* times, return None.
377 """
378 data, attempt = None, 0
379 while not data and attempt < max_retry:
380 with contextlib.suppress(ssl.SSLWantReadError):
381 sslobject.do_handshake()
382 data = outgoing.read()
383 attempt += 1
384 return data
385
386
387 class BasicSocketTests(unittest.TestCase):
388
389 def test_constants(self):
390 ssl.CERT_NONE
391 ssl.CERT_OPTIONAL
392 ssl.CERT_REQUIRED
393 ssl.OP_CIPHER_SERVER_PREFERENCE
394 ssl.OP_SINGLE_DH_USE
395 ssl.OP_SINGLE_ECDH_USE
396 ssl.OP_NO_COMPRESSION
397 self.assertEqual(ssl.HAS_SNI, True)
398 self.assertEqual(ssl.HAS_ECDH, True)
399 self.assertEqual(ssl.HAS_TLSv1_2, True)
400 self.assertEqual(ssl.HAS_TLSv1_3, True)
401 ssl.OP_NO_SSLv2
402 ssl.OP_NO_SSLv3
403 ssl.OP_NO_TLSv1
404 ssl.OP_NO_TLSv1_3
405 ssl.OP_NO_TLSv1_1
406 ssl.OP_NO_TLSv1_2
407 self.assertEqual(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv23)
408
409 def test_options(self):
410 # gh-106687: SSL options values are unsigned integer (uint64_t)
411 for name in dir(ssl):
412 if not name.startswith('OP_'):
413 continue
414 with self.subTest(option=name):
415 value = getattr(ssl, name)
416 self.assertGreaterEqual(value, 0, f"ssl.{name}")
417
418 def test_ssl_types(self):
419 ssl_types = [
420 _ssl._SSLContext,
421 _ssl._SSLSocket,
422 _ssl.MemoryBIO,
423 _ssl.Certificate,
424 _ssl.SSLSession,
425 _ssl.SSLError,
426 ]
427 for ssl_type in ssl_types:
428 with self.subTest(ssl_type=ssl_type):
429 with self.assertRaisesRegex(TypeError, "immutable type"):
430 ssl_type.value = None
431 support.check_disallow_instantiation(self, _ssl.Certificate)
432
433 def test_private_init(self):
434 with self.assertRaisesRegex(TypeError, "public constructor"):
435 with socket.socket() as s:
436 ssl.SSLSocket(s)
437
438 def test_str_for_enums(self):
439 # Make sure that the PROTOCOL_* constants have enum-like string
440 # reprs.
441 proto = ssl.PROTOCOL_TLS_CLIENT
442 self.assertEqual(repr(proto), '<_SSLMethod.PROTOCOL_TLS_CLIENT: %r>' % proto.value)
443 self.assertEqual(str(proto), str(proto.value))
444 ctx = ssl.SSLContext(proto)
445 self.assertIs(ctx.protocol, proto)
446
447 def test_random(self):
448 v = ssl.RAND_status()
449 if support.verbose:
450 sys.stdout.write("\n RAND_status is %d (%s)\n"
451 % (v, (v and "sufficient randomness") or
452 "insufficient randomness"))
453
454 if v:
455 data = ssl.RAND_bytes(16)
456 self.assertEqual(len(data), 16)
457 else:
458 self.assertRaises(ssl.SSLError, ssl.RAND_bytes, 16)
459
460 # negative num is invalid
461 self.assertRaises(ValueError, ssl.RAND_bytes, -5)
462
463 ssl.RAND_add("this is a random string", 75.0)
464 ssl.RAND_add(b"this is a random bytes object", 75.0)
465 ssl.RAND_add(bytearray(b"this is a random bytearray object"), 75.0)
466
467 def test_parse_cert(self):
468 self.maxDiff = None
469 # note that this uses an 'unofficial' function in _ssl.c,
470 # provided solely for this test, to exercise the certificate
471 # parsing code
472 self.assertEqual(
473 ssl._ssl._test_decode_cert(CERTFILE),
474 CERTFILE_INFO
475 )
476 self.assertEqual(
477 ssl._ssl._test_decode_cert(SIGNED_CERTFILE),
478 SIGNED_CERTFILE_INFO
479 )
480
481 # Issue #13034: the subjectAltName in some certificates
482 # (notably projects.developer.nokia.com:443) wasn't parsed
483 p = ssl._ssl._test_decode_cert(NOKIACERT)
484 if support.verbose:
485 sys.stdout.write("\n" + pprint.pformat(p) + "\n")
486 self.assertEqual(p['subjectAltName'],
487 (('DNS', 'projects.developer.nokia.com'),
488 ('DNS', 'projects.forum.nokia.com'))
489 )
490 # extra OCSP and AIA fields
491 self.assertEqual(p['OCSP'], ('http://ocsp.verisign.com',))
492 self.assertEqual(p['caIssuers'],
493 ('http://SVRIntl-G3-aia.verisign.com/SVRIntlG3.cer',))
494 self.assertEqual(p['crlDistributionPoints'],
495 ('http://SVRIntl-G3-crl.verisign.com/SVRIntlG3.crl',))
496
497 def test_parse_cert_CVE_2019_5010(self):
498 p = ssl._ssl._test_decode_cert(TALOS_INVALID_CRLDP)
499 if support.verbose:
500 sys.stdout.write("\n" + pprint.pformat(p) + "\n")
501 self.assertEqual(
502 p,
503 {
504 'issuer': (
505 (('countryName', 'UK'),), (('commonName', 'cody-ca'),)),
506 'notAfter': 'Jun 14 18:00:58 2028 GMT',
507 'notBefore': 'Jun 18 18:00:58 2018 GMT',
508 'serialNumber': '02',
509 'subject': ((('countryName', 'UK'),),
510 (('commonName',
511 'codenomicon-vm-2.test.lal.cisco.com'),)),
512 'subjectAltName': (
513 ('DNS', 'codenomicon-vm-2.test.lal.cisco.com'),),
514 'version': 3
515 }
516 )
517
518 def test_parse_cert_CVE_2013_4238(self):
519 p = ssl._ssl._test_decode_cert(NULLBYTECERT)
520 if support.verbose:
521 sys.stdout.write("\n" + pprint.pformat(p) + "\n")
522 subject = ((('countryName', 'US'),),
523 (('stateOrProvinceName', 'Oregon'),),
524 (('localityName', 'Beaverton'),),
525 (('organizationName', 'Python Software Foundation'),),
526 (('organizationalUnitName', 'Python Core Development'),),
527 (('commonName', 'null.python.org\x00example.org'),),
528 (('emailAddress', '[email protected]'),))
529 self.assertEqual(p['subject'], subject)
530 self.assertEqual(p['issuer'], subject)
531 if ssl._OPENSSL_API_VERSION >= (0, 9, 8):
532 san = (('DNS', 'altnull.python.org\x00example.com'),
533 ('email', '[email protected]\[email protected]'),
534 ('URI', 'http://null.python.org\x00http://example.org'),
535 ('IP Address', '192.0.2.1'),
536 ('IP Address', '2001:DB8:0:0:0:0:0:1'))
537 else:
538 # OpenSSL 0.9.7 doesn't support IPv6 addresses in subjectAltName
539 san = (('DNS', 'altnull.python.org\x00example.com'),
540 ('email', '[email protected]\[email protected]'),
541 ('URI', 'http://null.python.org\x00http://example.org'),
542 ('IP Address', '192.0.2.1'),
543 ('IP Address', '<invalid>'))
544
545 self.assertEqual(p['subjectAltName'], san)
546
547 def test_parse_all_sans(self):
548 p = ssl._ssl._test_decode_cert(ALLSANFILE)
549 self.assertEqual(p['subjectAltName'],
550 (
551 ('DNS', 'allsans'),
552 ('othername', '<unsupported>'),
553 ('othername', '<unsupported>'),
554 ('email', '[email protected]'),
555 ('DNS', 'www.example.org'),
556 ('DirName',
557 ((('countryName', 'XY'),),
558 (('localityName', 'Castle Anthrax'),),
559 (('organizationName', 'Python Software Foundation'),),
560 (('commonName', 'dirname example'),))),
561 ('URI', 'https://www.python.org/'),
562 ('IP Address', '127.0.0.1'),
563 ('IP Address', '0:0:0:0:0:0:0:1'),
564 ('Registered ID', '1.2.3.4.5')
565 )
566 )
567
568 def test_DER_to_PEM(self):
569 with open(CAFILE_CACERT, 'r') as f:
570 pem = f.read()
571 d1 = ssl.PEM_cert_to_DER_cert(pem)
572 p2 = ssl.DER_cert_to_PEM_cert(d1)
573 d2 = ssl.PEM_cert_to_DER_cert(p2)
574 self.assertEqual(d1, d2)
575 if not p2.startswith(ssl.PEM_HEADER + '\n'):
576 self.fail("DER-to-PEM didn't include correct header:\n%r\n" % p2)
577 if not p2.endswith('\n' + ssl.PEM_FOOTER + '\n'):
578 self.fail("DER-to-PEM didn't include correct footer:\n%r\n" % p2)
579
580 def test_openssl_version(self):
581 n = ssl.OPENSSL_VERSION_NUMBER
582 t = ssl.OPENSSL_VERSION_INFO
583 s = ssl.OPENSSL_VERSION
584 self.assertIsInstance(n, int)
585 self.assertIsInstance(t, tuple)
586 self.assertIsInstance(s, str)
587 # Some sanity checks follow
588 # >= 1.1.1
589 self.assertGreaterEqual(n, 0x10101000)
590 # < 4.0
591 self.assertLess(n, 0x40000000)
592 major, minor, fix, patch, status = t
593 self.assertGreaterEqual(major, 1)
594 self.assertLess(major, 4)
595 self.assertGreaterEqual(minor, 0)
596 self.assertLess(minor, 256)
597 self.assertGreaterEqual(fix, 0)
598 self.assertLess(fix, 256)
599 self.assertGreaterEqual(patch, 0)
600 self.assertLessEqual(patch, 63)
601 self.assertGreaterEqual(status, 0)
602 self.assertLessEqual(status, 15)
603
604 libressl_ver = f"LibreSSL {major:d}"
605 if major >= 3:
606 # 3.x uses 0xMNN00PP0L
607 openssl_ver = f"OpenSSL {major:d}.{minor:d}.{patch:d}"
608 else:
609 openssl_ver = f"OpenSSL {major:d}.{minor:d}.{fix:d}"
610 self.assertStartsWith(
611 s, (openssl_ver, libressl_ver, "AWS-LC"),
612 (t, hex(n))
613 )
614
615 @support.cpython_only
616 def test_refcycle(self):
617 # Issue #7943: an SSL object doesn't create reference cycles with
618 # itself.
619 s = socket.socket(socket.AF_INET)
620 ss = test_wrap_socket(s)
621 wr = weakref.ref(ss)
622 with warnings_helper.check_warnings(("", ResourceWarning)):
623 del ss
624 self.assertEqual(wr(), None)
625
626 def test_wrapped_unconnected(self):
627 # Methods on an unconnected SSLSocket propagate the original
628 # OSError raise by the underlying socket object.
629 s = socket.socket(socket.AF_INET)
630 with test_wrap_socket(s) as ss:
631 self.assertRaises(OSError, ss.recv, 1)
632 self.assertRaises(OSError, ss.recv_into, bytearray(b'x'))
633 self.assertRaises(OSError, ss.recvfrom, 1)
634 self.assertRaises(OSError, ss.recvfrom_into, bytearray(b'x'), 1)
635 self.assertRaises(OSError, ss.send, b'x')
636 self.assertRaises(OSError, ss.sendto, b'x', ('0.0.0.0', 0))
637 self.assertRaises(NotImplementedError, ss.dup)
638 self.assertRaises(NotImplementedError, ss.sendmsg,
639 [b'x'], (), 0, ('0.0.0.0', 0))
640 self.assertRaises(NotImplementedError, ss.recvmsg, 100)
641 self.assertRaises(NotImplementedError, ss.recvmsg_into,
642 [bytearray(100)])
643
644 def test_timeout(self):
645 # Issue #8524: when creating an SSL socket, the timeout of the
646 # original socket should be retained.
647 for timeout in (None, 0.0, 5.0):
648 s = socket.socket(socket.AF_INET)
649 s.settimeout(timeout)
650 with test_wrap_socket(s) as ss:
651 self.assertEqual(timeout, ss.gettimeout())
652
653 def test_openssl111_deprecations(self):
654 options = [
655 ssl.OP_NO_TLSv1,
656 ssl.OP_NO_TLSv1_1,
657 ssl.OP_NO_TLSv1_2,
658 ssl.OP_NO_TLSv1_3
659 ]
660 protocols = [
661 ssl.PROTOCOL_TLSv1,
662 ssl.PROTOCOL_TLSv1_1,
663 ssl.PROTOCOL_TLSv1_2,
664 ssl.PROTOCOL_TLS
665 ]
666 versions = [
667 ssl.TLSVersion.SSLv3,
668 ssl.TLSVersion.TLSv1,
669 ssl.TLSVersion.TLSv1_1,
670 ]
671
672 for option in options:
673 with self.subTest(option=option):
674 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
675 with self.assertWarns(DeprecationWarning) as cm:
676 ctx.options |= option
677 self.assertEqual(
678 'ssl.OP_NO_SSL*/ssl.OP_NO_TLS* options are deprecated',
679 str(cm.warning)
680 )
681
682 for protocol in protocols:
683 if not has_tls_protocol(protocol):
684 continue
685 with self.subTest(protocol=protocol):
686 with self.assertWarns(DeprecationWarning) as cm:
687 ssl.SSLContext(protocol)
688 self.assertEqual(
689 f'ssl.{protocol.name} is deprecated',
690 str(cm.warning)
691 )
692
693 for version in versions:
694 if not has_tls_version(version):
695 continue
696 with self.subTest(version=version):
697 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
698 with self.assertWarns(DeprecationWarning) as cm:
699 ctx.minimum_version = version
700 version_text = '%s.%s' % (version.__class__.__name__, version.name)
701 self.assertEqual(
702 f'ssl.{version_text} is deprecated',
703 str(cm.warning)
704 )
705
706 def bad_cert_test(self, certfile):
707 """Check that trying to use the given client certificate fails"""
708 certfile = os.path.join(os.path.dirname(__file__) or os.curdir,
709 "certdata", certfile)
710 sock = socket.socket()
711 self.addCleanup(sock.close)
712 with self.assertRaises(ssl.SSLError):
713 test_wrap_socket(sock,
714 certfile=certfile)
715
716 def test_empty_cert(self):
717 """Wrapping with an empty cert file"""
718 self.bad_cert_test("nullcert.pem")
719
720 def test_malformed_cert(self):
721 """Wrapping with a badly formatted certificate (syntax error)"""
722 self.bad_cert_test("badcert.pem")
723
724 def test_malformed_key(self):
725 """Wrapping with a badly formatted key (syntax error)"""
726 self.bad_cert_test("badkey.pem")
727
728 def test_server_side(self):
729 # server_hostname doesn't work for server sockets
730 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
731 with socket.socket() as sock:
732 self.assertRaises(ValueError, ctx.wrap_socket, sock, True,
733 server_hostname="some.hostname")
734
735 def test_unknown_channel_binding(self):
736 # should raise ValueError for unknown type
737 s = socket.create_server(('127.0.0.1', 0))
738 c = socket.socket(socket.AF_INET)
739 c.connect(s.getsockname())
740 with test_wrap_socket(c, do_handshake_on_connect=False) as ss:
741 with self.assertRaises(ValueError):
742 ss.get_channel_binding("unknown-type")
743 s.close()
744
745 @unittest.skipUnless("tls-unique" in ssl.CHANNEL_BINDING_TYPES,
746 "'tls-unique' channel binding not available")
747 def test_tls_unique_channel_binding(self):
748 # unconnected should return None for known type
749 s = socket.socket(socket.AF_INET)
750 with test_wrap_socket(s) as ss:
751 self.assertIsNone(ss.get_channel_binding("tls-unique"))
752 # the same for server-side
753 s = socket.socket(socket.AF_INET)
754 with test_wrap_socket(s, server_side=True, certfile=CERTFILE) as ss:
755 self.assertIsNone(ss.get_channel_binding("tls-unique"))
756
757 def test_dealloc_warn(self):
758 ss = test_wrap_socket(socket.socket(socket.AF_INET))
759 r = repr(ss)
760 with self.assertWarns(ResourceWarning) as cm:
761 ss = None
762 support.gc_collect()
763 self.assertIn(r, str(cm.warning.args[0]))
764
765 def test_get_default_verify_paths(self):
766 paths = ssl.get_default_verify_paths()
767 self.assertEqual(len(paths), 6)
768 self.assertIsInstance(paths, ssl.DefaultVerifyPaths)
769
770 with os_helper.EnvironmentVarGuard() as env:
771 env["SSL_CERT_DIR"] = CAPATH
772 env["SSL_CERT_FILE"] = CERTFILE
773 paths = ssl.get_default_verify_paths()
774 self.assertEqual(paths.cafile, CERTFILE)
775 self.assertEqual(paths.capath, CAPATH)
776
777 @unittest.skipUnless(sys.platform == "win32", "Windows specific")
778 def test_enum_certificates(self):
779 self.assertTrue(ssl.enum_certificates("CA"))
780 self.assertTrue(ssl.enum_certificates("ROOT"))
781
782 self.assertRaises(TypeError, ssl.enum_certificates)
783 self.assertRaises(WindowsError, ssl.enum_certificates, "")
784
785 trust_oids = set()
786 for storename in ("CA", "ROOT"):
787 store = ssl.enum_certificates(storename)
788 self.assertIsInstance(store, list)
789 for element in store:
790 self.assertIsInstance(element, tuple)
791 self.assertEqual(len(element), 3)
792 cert, enc, trust = element
793 self.assertIsInstance(cert, bytes)
794 self.assertIn(enc, {"x509_asn", "pkcs_7_asn"})
795 self.assertIsInstance(trust, (frozenset, set, bool))
796 if isinstance(trust, (frozenset, set)):
797 trust_oids.update(trust)
798
799 serverAuth = "1.3.6.1.5.5.7.3.1"
800 self.assertIn(serverAuth, trust_oids)
801
802 @unittest.skipUnless(sys.platform == "win32", "Windows specific")
803 def test_enum_crls(self):
804 self.assertTrue(ssl.enum_crls("CA"))
805 self.assertRaises(TypeError, ssl.enum_crls)
806 self.assertRaises(WindowsError, ssl.enum_crls, "")
807
808 crls = ssl.enum_crls("CA")
809 self.assertIsInstance(crls, list)
810 for element in crls:
811 self.assertIsInstance(element, tuple)
812 self.assertEqual(len(element), 2)
813 self.assertIsInstance(element[0], bytes)
814 self.assertIn(element[1], {"x509_asn", "pkcs_7_asn"})
815
816
817 def test_asn1object(self):
818 expected = (129, 'serverAuth', 'TLS Web Server Authentication',
819 '1.3.6.1.5.5.7.3.1')
820
821 val = ssl._ASN1Object('1.3.6.1.5.5.7.3.1')
822 self.assertEqual(val, expected)
823 self.assertEqual(val.nid, 129)
824 self.assertEqual(val.shortname, 'serverAuth')
825 self.assertEqual(val.longname, 'TLS Web Server Authentication')
826 self.assertEqual(val.oid, '1.3.6.1.5.5.7.3.1')
827 self.assertIsInstance(val, ssl._ASN1Object)
828 self.assertRaises(ValueError, ssl._ASN1Object, 'serverAuth')
829
830 val = ssl._ASN1Object.fromnid(129)
831 self.assertEqual(val, expected)
832 self.assertIsInstance(val, ssl._ASN1Object)
833 self.assertRaises(ValueError, ssl._ASN1Object.fromnid, -1)
834 with self.assertRaisesRegex(ValueError, "unknown NID 100000"):
835 ssl._ASN1Object.fromnid(100000)
836 for i in range(1000):
837 try:
838 obj = ssl._ASN1Object.fromnid(i)
839 except ValueError:
840 pass
841 else:
842 self.assertIsInstance(obj.nid, int)
843 self.assertIsInstance(obj.shortname, str)
844 self.assertIsInstance(obj.longname, str)
845 self.assertIsInstance(obj.oid, (str, type(None)))
846
847 val = ssl._ASN1Object.fromname('TLS Web Server Authentication')
848 self.assertEqual(val, expected)
849 self.assertIsInstance(val, ssl._ASN1Object)
850 self.assertEqual(ssl._ASN1Object.fromname('serverAuth'), expected)
851 self.assertEqual(ssl._ASN1Object.fromname('1.3.6.1.5.5.7.3.1'),
852 expected)
853 with self.assertRaisesRegex(ValueError, "unknown object 'serverauth'"):
854 ssl._ASN1Object.fromname('serverauth')
855
856 def test_purpose_enum(self):
857 val = ssl._ASN1Object('1.3.6.1.5.5.7.3.1')
858 self.assertIsInstance(ssl.Purpose.SERVER_AUTH, ssl._ASN1Object)
859 self.assertEqual(ssl.Purpose.SERVER_AUTH, val)
860 self.assertEqual(ssl.Purpose.SERVER_AUTH.nid, 129)
861 self.assertEqual(ssl.Purpose.SERVER_AUTH.shortname, 'serverAuth')
862 self.assertEqual(ssl.Purpose.SERVER_AUTH.oid,
863 '1.3.6.1.5.5.7.3.1')
864
865 val = ssl._ASN1Object('1.3.6.1.5.5.7.3.2')
866 self.assertIsInstance(ssl.Purpose.CLIENT_AUTH, ssl._ASN1Object)
867 self.assertEqual(ssl.Purpose.CLIENT_AUTH, val)
868 self.assertEqual(ssl.Purpose.CLIENT_AUTH.nid, 130)
869 self.assertEqual(ssl.Purpose.CLIENT_AUTH.shortname, 'clientAuth')
870 self.assertEqual(ssl.Purpose.CLIENT_AUTH.oid,
871 '1.3.6.1.5.5.7.3.2')
872
873 def test_unsupported_dtls(self):
874 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
875 self.addCleanup(s.close)
876 with self.assertRaises(NotImplementedError) as cx:
877 test_wrap_socket(s, cert_reqs=ssl.CERT_NONE)
878 self.assertEqual(str(cx.exception), "only stream sockets are supported")
879 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
880 with self.assertRaises(NotImplementedError) as cx:
881 ctx.wrap_socket(s)
882 self.assertEqual(str(cx.exception), "only stream sockets are supported")
883
884 def cert_time_ok(self, timestring, timestamp):
885 self.assertEqual(ssl.cert_time_to_seconds(timestring), timestamp)
886
887 def cert_time_fail(self, timestring):
888 with self.assertRaises(ValueError):
889 ssl.cert_time_to_seconds(timestring)
890
891 @unittest.skipUnless(utc_offset(),
892 'local time needs to be different from UTC')
893 def test_cert_time_to_seconds_timezone(self):
894 # Issue #19940: ssl.cert_time_to_seconds() returns wrong
895 # results if local timezone is not UTC
896 self.cert_time_ok("May 9 00:00:00 2007 GMT", 1178668800.0)
897 self.cert_time_ok("Jan 5 09:34:43 2018 GMT", 1515144883.0)
898
899 def test_cert_time_to_seconds(self):
900 timestring = "Jan 5 09:34:43 2018 GMT"
901 ts = 1515144883.0
902 self.cert_time_ok(timestring, ts)
903 # accept keyword parameter, assert its name
904 self.assertEqual(ssl.cert_time_to_seconds(cert_time=timestring), ts)
905 # accept both %e and %d (space or zero generated by strftime)
906 self.cert_time_ok("Jan 05 09:34:43 2018 GMT", ts)
907 # case-insensitive
908 self.cert_time_ok("JaN 5 09:34:43 2018 GmT", ts)
909 self.cert_time_fail("Jan 5 09:34 2018 GMT") # no seconds
910 self.cert_time_fail("Jan 5 09:34:43 2018") # no GMT
911 self.cert_time_fail("Jan 5 09:34:43 2018 UTC") # not GMT timezone
912 self.cert_time_fail("Jan 35 09:34:43 2018 GMT") # invalid day
913 self.cert_time_fail("Jon 5 09:34:43 2018 GMT") # invalid month
914 self.cert_time_fail("Jan 5 24:00:00 2018 GMT") # invalid hour
915 self.cert_time_fail("Jan 5 09:60:43 2018 GMT") # invalid minute
916
917 newyear_ts = 1230768000.0
918 # leap seconds
919 self.cert_time_ok("Dec 31 23:59:60 2008 GMT", newyear_ts)
920 # same timestamp
921 self.cert_time_ok("Jan 1 00:00:00 2009 GMT", newyear_ts)
922
923 self.cert_time_ok("Jan 5 09:34:59 2018 GMT", 1515144899)
924 # allow 60th second (even if it is not a leap second)
925 self.cert_time_ok("Jan 5 09:34:60 2018 GMT", 1515144900)
926 # allow 2nd leap second for compatibility with time.strptime()
927 self.cert_time_ok("Jan 5 09:34:61 2018 GMT", 1515144901)
928 self.cert_time_fail("Jan 5 09:34:62 2018 GMT") # invalid seconds
929
930 # no special treatment for the special value:
931 # 99991231235959Z (rfc 5280)
932 self.cert_time_ok("Dec 31 23:59:59 9999 GMT", 253402300799.0)
933
934 @support.run_with_locale('LC_ALL', '')
935 def test_cert_time_to_seconds_locale(self):
936 # `cert_time_to_seconds()` should be locale independent
937
938 def local_february_name():
939 return time.strftime('%b', (1, 2, 3, 4, 5, 6, 0, 0, 0))
940
941 if local_february_name().lower() == 'feb':
942 self.skipTest("locale-specific month name needs to be "
943 "different from C locale")
944
945 # locale-independent
946 self.cert_time_ok("Feb 9 00:00:00 2007 GMT", 1170979200.0)
947 self.cert_time_fail(local_february_name() + " 9 00:00:00 2007 GMT")
948
949 def test_connect_ex_error(self):
950 server = socket.socket(socket.AF_INET)
951 self.addCleanup(server.close)
952 port = socket_helper.bind_port(server) # Reserve port but don't listen
953 s = test_wrap_socket(socket.socket(socket.AF_INET),
954 cert_reqs=ssl.CERT_REQUIRED)
955 self.addCleanup(s.close)
956 rc = s.connect_ex((HOST, port))
957 # Issue #19919: Windows machines or VMs hosted on Windows
958 # machines sometimes return EWOULDBLOCK.
959 errors = (
960 errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
961 errno.EWOULDBLOCK,
962 )
963 self.assertIn(rc, errors)
964
965 def test_read_write_zero(self):
966 # empty reads and writes now work, bpo-42854, bpo-31711
967 client_context, server_context, hostname = testing_context()
968 server = ThreadedEchoServer(context=server_context)
969 with server:
970 with client_context.wrap_socket(socket.socket(),
971 server_hostname=hostname) as s:
972 s.connect((HOST, server.port))
973 self.assertEqual(s.recv(0), b"")
974 self.assertEqual(s.send(b""), 0)
975
976
977 class ContextTests(unittest.TestCase):
978
979 def test_constructor(self):
980 for protocol in PROTOCOLS:
981 if has_tls_protocol(protocol):
982 with warnings_helper.check_warnings():
983 ctx = ssl.SSLContext(protocol)
984 self.assertEqual(ctx.protocol, protocol)
985 with warnings_helper.check_warnings():
986 ctx = ssl.SSLContext()
987 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS)
988 self.assertRaises(ValueError, ssl.SSLContext, -1)
989 self.assertRaises(ValueError, ssl.SSLContext, 42)
990
991 def test_ciphers(self):
992 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
993 ctx.set_ciphers("ALL")
994 ctx.set_ciphers("DEFAULT")
995 with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
996 ctx.set_ciphers("^$:,;?*'dorothyx")
997
998 @unittest.skipUnless(PY_SSL_DEFAULT_CIPHERS == 1,
999 "Test applies only to Python default ciphers")
1000 def test_python_ciphers(self):
1001 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1002 ciphers = ctx.get_ciphers()
1003 for suite in ciphers:
1004 name = suite['name']
1005 self.assertNotIn("PSK", name)
1006 self.assertNotIn("SRP", name)
1007 self.assertNotIn("MD5", name)
1008 self.assertNotIn("RC4", name)
1009 self.assertNotIn("3DES", name)
1010
1011 def test_get_ciphers(self):
1012 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1013 ctx.set_ciphers('AESGCM')
1014 names = set(d['name'] for d in ctx.get_ciphers())
1015 expected = {
1016 'AES128-GCM-SHA256',
1017 'ECDHE-ECDSA-AES128-GCM-SHA256',
1018 'ECDHE-RSA-AES128-GCM-SHA256',
1019 'DHE-RSA-AES128-GCM-SHA256',
1020 'AES256-GCM-SHA384',
1021 'ECDHE-ECDSA-AES256-GCM-SHA384',
1022 'ECDHE-RSA-AES256-GCM-SHA384',
1023 'DHE-RSA-AES256-GCM-SHA384',
1024 }
1025 intersection = names.intersection(expected)
1026 self.assertGreaterEqual(
1027 len(intersection), 2, f"\ngot: {sorted(names)}\nexpected: {sorted(expected)}"
1028 )
1029
1030 def test_options(self):
1031 # Test default SSLContext options
1032 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1033 # OP_ALL | OP_NO_SSLv2 | OP_NO_SSLv3 is the default value
1034 default = (ssl.OP_ALL | ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3)
1035 # SSLContext also enables these by default
1036 default |= (OP_NO_COMPRESSION | OP_CIPHER_SERVER_PREFERENCE |
1037 OP_SINGLE_DH_USE | OP_SINGLE_ECDH_USE |
1038 OP_ENABLE_MIDDLEBOX_COMPAT)
1039 self.assertEqual(default, ctx.options)
1040
1041 # disallow TLSv1
1042 with warnings_helper.check_warnings():
1043 ctx.options |= ssl.OP_NO_TLSv1
1044 self.assertEqual(default | ssl.OP_NO_TLSv1, ctx.options)
1045
1046 # allow TLSv1
1047 with warnings_helper.check_warnings():
1048 ctx.options = (ctx.options & ~ssl.OP_NO_TLSv1)
1049 self.assertEqual(default, ctx.options)
1050
1051 # clear all options
1052 ctx.options = 0
1053 # Ubuntu has OP_NO_SSLv3 forced on by default
1054 self.assertEqual(0, ctx.options & ~ssl.OP_NO_SSLv3)
1055
1056 # invalid options
1057 with self.assertRaises(ValueError):
1058 ctx.options = -1
1059 with self.assertRaises(OverflowError):
1060 ctx.options = 2 ** 100
1061 with self.assertRaises(TypeError):
1062 ctx.options = "abc"
1063
1064 def test_verify_mode_protocol(self):
1065 with warnings_helper.check_warnings():
1066 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS)
1067 # Default value
1068 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1069 ctx.verify_mode = ssl.CERT_OPTIONAL
1070 self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
1071 ctx.verify_mode = ssl.CERT_REQUIRED
1072 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1073 ctx.verify_mode = ssl.CERT_NONE
1074 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1075 with self.assertRaises(TypeError):
1076 ctx.verify_mode = None
1077 with self.assertRaises(ValueError):
1078 ctx.verify_mode = 42
1079
1080 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1081 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1082 self.assertFalse(ctx.check_hostname)
1083
1084 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1085 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1086 self.assertTrue(ctx.check_hostname)
1087
1088 def test_hostname_checks_common_name(self):
1089 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1090 self.assertTrue(ctx.hostname_checks_common_name)
1091 if ssl.HAS_NEVER_CHECK_COMMON_NAME:
1092 ctx.hostname_checks_common_name = True
1093 self.assertTrue(ctx.hostname_checks_common_name)
1094 ctx.hostname_checks_common_name = False
1095 self.assertFalse(ctx.hostname_checks_common_name)
1096 ctx.hostname_checks_common_name = True
1097 self.assertTrue(ctx.hostname_checks_common_name)
1098 else:
1099 with self.assertRaises(AttributeError):
1100 ctx.hostname_checks_common_name = True
1101
1102 @ignore_deprecation
1103 def test_min_max_version(self):
1104 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1105 # OpenSSL default is MINIMUM_SUPPORTED, however some vendors like
1106 # Fedora override the setting to TLS 1.0.
1107 minimum_range = {
1108 # stock OpenSSL
1109 ssl.TLSVersion.MINIMUM_SUPPORTED,
1110 # Fedora 29 uses TLS 1.0 by default
1111 ssl.TLSVersion.TLSv1,
1112 # RHEL 8 uses TLS 1.2 by default
1113 ssl.TLSVersion.TLSv1_2
1114 }
1115 maximum_range = {
1116 # stock OpenSSL
1117 ssl.TLSVersion.MAXIMUM_SUPPORTED,
1118 # Fedora 32 uses TLS 1.3 by default
1119 ssl.TLSVersion.TLSv1_3
1120 }
1121
1122 self.assertIn(
1123 ctx.minimum_version, minimum_range
1124 )
1125 self.assertIn(
1126 ctx.maximum_version, maximum_range
1127 )
1128
1129 ctx.minimum_version = ssl.TLSVersion.TLSv1_1
1130 ctx.maximum_version = ssl.TLSVersion.TLSv1_2
1131 self.assertEqual(
1132 ctx.minimum_version, ssl.TLSVersion.TLSv1_1
1133 )
1134 self.assertEqual(
1135 ctx.maximum_version, ssl.TLSVersion.TLSv1_2
1136 )
1137
1138 ctx.minimum_version = ssl.TLSVersion.MINIMUM_SUPPORTED
1139 ctx.maximum_version = ssl.TLSVersion.TLSv1
1140 self.assertEqual(
1141 ctx.minimum_version, ssl.TLSVersion.MINIMUM_SUPPORTED
1142 )
1143 self.assertEqual(
1144 ctx.maximum_version, ssl.TLSVersion.TLSv1
1145 )
1146
1147 ctx.maximum_version = ssl.TLSVersion.MAXIMUM_SUPPORTED
1148 self.assertEqual(
1149 ctx.maximum_version, ssl.TLSVersion.MAXIMUM_SUPPORTED
1150 )
1151
1152 ctx.maximum_version = ssl.TLSVersion.MINIMUM_SUPPORTED
1153 self.assertIn(
1154 ctx.maximum_version,
1155 {
1156 ssl.TLSVersion.TLSv1,
1157 ssl.TLSVersion.TLSv1_1,
1158 ssl.TLSVersion.TLSv1_2,
1159 ssl.TLSVersion.SSLv3,
1160 }
1161 )
1162
1163 ctx.minimum_version = ssl.TLSVersion.MAXIMUM_SUPPORTED
1164 self.assertIn(
1165 ctx.minimum_version,
1166 {ssl.TLSVersion.TLSv1_2, ssl.TLSVersion.TLSv1_3}
1167 )
1168
1169 with self.assertRaises(ValueError):
1170 ctx.minimum_version = 42
1171
1172 if has_tls_protocol(ssl.PROTOCOL_TLSv1_1):
1173 ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1_1)
1174
1175 self.assertIn(
1176 ctx.minimum_version, minimum_range
1177 )
1178 self.assertEqual(
1179 ctx.maximum_version, ssl.TLSVersion.MAXIMUM_SUPPORTED
1180 )
1181 with self.assertRaises(ValueError):
1182 ctx.minimum_version = ssl.TLSVersion.MINIMUM_SUPPORTED
1183 with self.assertRaises(ValueError):
1184 ctx.maximum_version = ssl.TLSVersion.TLSv1
1185
1186 @unittest.skipUnless(
1187 hasattr(ssl.SSLContext, 'security_level'),
1188 "requires OpenSSL >= 1.1.0"
1189 )
1190 def test_security_level(self):
1191 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1192 # The default security callback allows for levels between 0-5
1193 # with OpenSSL defaulting to 1, however some vendors override the
1194 # default value (e.g. Debian defaults to 2)
1195 security_level_range = {
1196 0,
1197 1, # OpenSSL default
1198 2, # Debian
1199 3,
1200 4,
1201 5,
1202 }
1203 self.assertIn(ctx.security_level, security_level_range)
1204
1205 def test_verify_flags(self):
1206 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1207 # default value
1208 tf = getattr(ssl, "VERIFY_X509_TRUSTED_FIRST", 0)
1209 self.assertEqual(ctx.verify_flags, ssl.VERIFY_DEFAULT | tf)
1210 ctx.verify_flags = ssl.VERIFY_CRL_CHECK_LEAF
1211 self.assertEqual(ctx.verify_flags, ssl.VERIFY_CRL_CHECK_LEAF)
1212 ctx.verify_flags = ssl.VERIFY_CRL_CHECK_CHAIN
1213 self.assertEqual(ctx.verify_flags, ssl.VERIFY_CRL_CHECK_CHAIN)
1214 ctx.verify_flags = ssl.VERIFY_DEFAULT
1215 self.assertEqual(ctx.verify_flags, ssl.VERIFY_DEFAULT)
1216 ctx.verify_flags = ssl.VERIFY_ALLOW_PROXY_CERTS
1217 self.assertEqual(ctx.verify_flags, ssl.VERIFY_ALLOW_PROXY_CERTS)
1218 # supports any value
1219 ctx.verify_flags = ssl.VERIFY_CRL_CHECK_LEAF | ssl.VERIFY_X509_STRICT
1220 self.assertEqual(ctx.verify_flags,
1221 ssl.VERIFY_CRL_CHECK_LEAF | ssl.VERIFY_X509_STRICT)
1222 with self.assertRaises(TypeError):
1223 ctx.verify_flags = None
1224
1225 def test_load_cert_chain(self):
1226 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1227 # Combined key and cert in a single file
1228 ctx.load_cert_chain(CERTFILE, keyfile=None)
1229 ctx.load_cert_chain(CERTFILE, keyfile=CERTFILE)
1230 self.assertRaises(TypeError, ctx.load_cert_chain, keyfile=CERTFILE)
1231 with self.assertRaises(OSError) as cm:
1232 ctx.load_cert_chain(NONEXISTINGCERT)
1233 self.assertEqual(cm.exception.errno, errno.ENOENT)
1234 with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
1235 ctx.load_cert_chain(BADCERT)
1236 with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
1237 ctx.load_cert_chain(EMPTYCERT)
1238 # Separate key and cert
1239 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1240 ctx.load_cert_chain(ONLYCERT, ONLYKEY)
1241 ctx.load_cert_chain(certfile=ONLYCERT, keyfile=ONLYKEY)
1242 ctx.load_cert_chain(certfile=BYTES_ONLYCERT, keyfile=BYTES_ONLYKEY)
1243 with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
1244 ctx.load_cert_chain(ONLYCERT)
1245 with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
1246 ctx.load_cert_chain(ONLYKEY)
1247 with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
1248 ctx.load_cert_chain(certfile=ONLYKEY, keyfile=ONLYCERT)
1249 # Mismatching key and cert
1250 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1251 # Allow for flexible libssl error messages.
1252 regex = re.compile(r"""(
1253 key values mismatch # OpenSSL
1254 |
1255 KEY_VALUES_MISMATCH # AWS-LC
1256 )""", re.X)
1257 with self.assertRaisesRegex(ssl.SSLError, regex):
1258 ctx.load_cert_chain(CAFILE_CACERT, ONLYKEY)
1259 # Password protected key and cert
1260 ctx.load_cert_chain(CERTFILE_PROTECTED, password=KEY_PASSWORD)
1261 ctx.load_cert_chain(CERTFILE_PROTECTED, password=KEY_PASSWORD.encode())
1262 ctx.load_cert_chain(CERTFILE_PROTECTED,
1263 password=bytearray(KEY_PASSWORD.encode()))
1264 ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED, KEY_PASSWORD)
1265 ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED, KEY_PASSWORD.encode())
1266 ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED,
1267 bytearray(KEY_PASSWORD.encode()))
1268 with self.assertRaisesRegex(TypeError, "should be a string"):
1269 ctx.load_cert_chain(CERTFILE_PROTECTED, password=True)
1270 with self.assertRaises(ssl.SSLError):
1271 ctx.load_cert_chain(CERTFILE_PROTECTED, password="badpass")
1272 with self.assertRaisesRegex(ValueError, "cannot be longer"):
1273 # openssl has a fixed limit on the password buffer.
1274 # PEM_BUFSIZE is generally set to 1kb.
1275 # Return a string larger than this.
1276 ctx.load_cert_chain(CERTFILE_PROTECTED, password=b'a' * 102400)
1277 # Password callback
1278 def getpass_unicode():
1279 return KEY_PASSWORD
1280 def getpass_bytes():
1281 return KEY_PASSWORD.encode()
1282 def getpass_bytearray():
1283 return bytearray(KEY_PASSWORD.encode())
1284 def getpass_badpass():
1285 return "badpass"
1286 def getpass_huge():
1287 return b'a' * (1024 * 1024)
1288 def getpass_bad_type():
1289 return 9
1290 def getpass_exception():
1291 raise Exception('getpass error')
1292 class GetPassCallable:
1293 def __call__(self):
1294 return KEY_PASSWORD
1295 def getpass(self):
1296 return KEY_PASSWORD
1297 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_unicode)
1298 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bytes)
1299 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bytearray)
1300 ctx.load_cert_chain(CERTFILE_PROTECTED, password=GetPassCallable())
1301 ctx.load_cert_chain(CERTFILE_PROTECTED,
1302 password=GetPassCallable().getpass)
1303 with self.assertRaises(ssl.SSLError):
1304 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_badpass)
1305 with self.assertRaisesRegex(ValueError, "cannot be longer"):
1306 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_huge)
1307 with self.assertRaisesRegex(TypeError, "must return a string"):
1308 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bad_type)
1309 with self.assertRaisesRegex(Exception, "getpass error"):
1310 ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_exception)
1311 # Make sure the password function isn't called if it isn't needed
1312 ctx.load_cert_chain(CERTFILE, password=getpass_exception)
1313
1314 @threading_helper.requires_working_threading()
1315 def test_load_cert_chain_thread_safety(self):
1316 # gh-134698: _ssl detaches the thread state (and as such,
1317 # releases the GIL and critical sections) around expensive
1318 # OpenSSL calls. Unfortunately, OpenSSL structures aren't
1319 # thread-safe, so executing these calls concurrently led
1320 # to crashes.
1321 ctx = ssl.create_default_context()
1322
1323 def race():
1324 ctx.load_cert_chain(CERTFILE)
1325
1326 threads = [threading.Thread(target=race) for _ in range(8)]
1327 with threading_helper.catch_threading_exception() as cm:
1328 with threading_helper.start_threads(threads):
1329 pass
1330
1331 self.assertIsNone(cm.exc_value)
1332
1333 def test_load_verify_locations(self):
1334 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1335 ctx.load_verify_locations(CERTFILE)
1336 ctx.load_verify_locations(cafile=CERTFILE, capath=None)
1337 ctx.load_verify_locations(BYTES_CERTFILE)
1338 ctx.load_verify_locations(cafile=BYTES_CERTFILE, capath=None)
1339 self.assertRaises(TypeError, ctx.load_verify_locations)
1340 self.assertRaises(TypeError, ctx.load_verify_locations, None, None, None)
1341 with self.assertRaises(OSError) as cm:
1342 ctx.load_verify_locations(NONEXISTINGCERT)
1343 self.assertEqual(cm.exception.errno, errno.ENOENT)
1344 with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
1345 ctx.load_verify_locations(BADCERT)
1346 ctx.load_verify_locations(CERTFILE, CAPATH)
1347 ctx.load_verify_locations(CERTFILE, capath=BYTES_CAPATH)
1348
1349 # Issue #10989: crash if the second argument type is invalid
1350 self.assertRaises(TypeError, ctx.load_verify_locations, None, True)
1351
1352 def test_load_verify_cadata(self):
1353 # test cadata
1354 with open(CAFILE_CACERT) as f:
1355 cacert_pem = f.read()
1356 cacert_der = ssl.PEM_cert_to_DER_cert(cacert_pem)
1357 with open(CAFILE_NEURONIO) as f:
1358 neuronio_pem = f.read()
1359 neuronio_der = ssl.PEM_cert_to_DER_cert(neuronio_pem)
1360
1361 # test PEM
1362 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1363 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 0)
1364 ctx.load_verify_locations(cadata=cacert_pem)
1365 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 1)
1366 ctx.load_verify_locations(cadata=neuronio_pem)
1367 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1368 # cert already in hash table
1369 ctx.load_verify_locations(cadata=neuronio_pem)
1370 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1371
1372 # combined
1373 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1374 combined = "\n".join((cacert_pem, neuronio_pem))
1375 ctx.load_verify_locations(cadata=combined)
1376 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1377
1378 # with junk around the certs
1379 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1380 combined = ["head", cacert_pem, "other", neuronio_pem, "again",
1381 neuronio_pem, "tail"]
1382 ctx.load_verify_locations(cadata="\n".join(combined))
1383 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1384
1385 # test DER
1386 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1387 ctx.load_verify_locations(cadata=cacert_der)
1388 ctx.load_verify_locations(cadata=neuronio_der)
1389 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1390 # cert already in hash table
1391 ctx.load_verify_locations(cadata=cacert_der)
1392 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1393
1394 # combined
1395 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1396 combined = b"".join((cacert_der, neuronio_der))
1397 ctx.load_verify_locations(cadata=combined)
1398 self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
1399
1400 # error cases
1401 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1402 self.assertRaises(TypeError, ctx.load_verify_locations, cadata=object)
1403
1404 with self.assertRaisesRegex(
1405 ssl.SSLError,
1406 "no start line: cadata does not contain a certificate"
1407 ):
1408 ctx.load_verify_locations(cadata="broken")
1409 with self.assertRaisesRegex(
1410 ssl.SSLError,
1411 "not enough data: cadata does not contain a certificate"
1412 ):
1413 ctx.load_verify_locations(cadata=b"broken")
1414 with self.assertRaises(ssl.SSLError):
1415 ctx.load_verify_locations(cadata=cacert_der + b"A")
1416
1417 def test_load_dh_params(self):
1418 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1419 try:
1420 ctx.load_dh_params(DHFILE)
1421 except RuntimeError:
1422 if Py_DEBUG_WIN32:
1423 self.skipTest("not supported on Win32 debug build")
1424 raise
1425 ctx.load_dh_params(BYTES_DHFILE)
1426 self.assertRaises(TypeError, ctx.load_dh_params)
1427 self.assertRaises(TypeError, ctx.load_dh_params, None)
1428 with self.assertRaises(FileNotFoundError) as cm:
1429 ctx.load_dh_params(NONEXISTINGCERT)
1430 self.assertEqual(cm.exception.errno, errno.ENOENT)
1431 with self.assertRaises(ssl.SSLError) as cm:
1432 ctx.load_dh_params(CERTFILE)
1433
1434 def test_session_stats(self):
1435 for proto in {ssl.PROTOCOL_TLS_CLIENT, ssl.PROTOCOL_TLS_SERVER}:
1436 ctx = ssl.SSLContext(proto)
1437 self.assertEqual(ctx.session_stats(), {
1438 'number': 0,
1439 'connect': 0,
1440 'connect_good': 0,
1441 'connect_renegotiate': 0,
1442 'accept': 0,
1443 'accept_good': 0,
1444 'accept_renegotiate': 0,
1445 'hits': 0,
1446 'misses': 0,
1447 'timeouts': 0,
1448 'cache_full': 0,
1449 })
1450
1451 def test_set_default_verify_paths(self):
1452 # There's not much we can do to test that it acts as expected,
1453 # so just check it doesn't crash or raise an exception.
1454 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1455 ctx.set_default_verify_paths()
1456
1457 @unittest.skipUnless(ssl.HAS_ECDH, "ECDH disabled on this OpenSSL build")
1458 def test_set_ecdh_curve(self):
1459 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1460 ctx.set_ecdh_curve("prime256v1")
1461 ctx.set_ecdh_curve(b"prime256v1")
1462 self.assertRaises(TypeError, ctx.set_ecdh_curve)
1463 self.assertRaises(TypeError, ctx.set_ecdh_curve, None)
1464 self.assertRaises(ValueError, ctx.set_ecdh_curve, "foo")
1465 self.assertRaises(ValueError, ctx.set_ecdh_curve, b"foo")
1466
1467 def test_sni_callback(self):
1468 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1469
1470 # set_servername_callback expects a callable, or None
1471 self.assertRaises(TypeError, ctx.set_servername_callback)
1472 self.assertRaises(TypeError, ctx.set_servername_callback, 4)
1473 self.assertRaises(TypeError, ctx.set_servername_callback, "")
1474 self.assertRaises(TypeError, ctx.set_servername_callback, ctx)
1475
1476 def dummycallback(sock, servername, ctx):
1477 pass
1478 ctx.set_servername_callback(None)
1479 ctx.set_servername_callback(dummycallback)
1480
1481 def test_sni_callback_on_dead_references(self):
1482 # See https://github.com/python/cpython/issues/146080.
1483 c_ctx = make_test_context()
1484 c_inc, c_out = ssl.MemoryBIO(), ssl.MemoryBIO()
1485 client = c_ctx.wrap_bio(c_inc, c_out, server_hostname=SIGNED_CERTFILE_HOSTNAME)
1486
1487 def sni_callback(sock, servername, ctx): pass
1488 sni_callback = unittest.mock.Mock(wraps=sni_callback)
1489 s_ctx = make_test_context(server_side=True, certfile=SIGNED_CERTFILE)
1490 s_ctx.set_servername_callback(sni_callback)
1491
1492 s_inc, s_out = ssl.MemoryBIO(), ssl.MemoryBIO()
1493 server = s_ctx.wrap_bio(s_inc, s_out, server_side=True)
1494 server_impl = server._sslobj
1495
1496 # Perform the handshake on the client side first.
1497 data = do_ssl_object_handshake(client, c_out)
1498 sni_callback.assert_not_called()
1499 if data is None:
1500 self.skipTest("cannot establish a handshake from the client")
1501 s_inc.write(data)
1502 sni_callback.assert_not_called()
1503 # Delete the server object before it starts doing its handshake
1504 # and ensure that we did not call the SNI callback yet.
1505 del server
1506 gc.collect()
1507 # Try to continue the server's handshake by directly using
1508 # the internal SSL object. The latter is a weak reference
1509 # stored in the server context and has now a dead owner.
1510 with self.assertRaises(ssl.SSLError) as cm:
1511 server_impl.do_handshake()
1512 # The SNI C callback raised an exception before calling our callback.
1513 sni_callback.assert_not_called()
1514
1515 # In AWS-LC, any handshake failures reports SSL_R_PARSE_TLSEXT,
1516 # while OpenSSL uses SSL_R_CALLBACK_FAILED on SNI callback failures.
1517 if IS_AWS_LC:
1518 libssl_error_reason = "PARSE_TLSEXT"
1519 else:
1520 libssl_error_reason = "callback failed"
1521 self.assertIn(libssl_error_reason, str(cm.exception))
1522 self.assertEqual(cm.exception.errno, ssl.SSL_ERROR_SSL)
1523
1524 def test_sni_callback_refcycle(self):
1525 # Reference cycles through the servername callback are detected
1526 # and cleared.
1527 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1528 def dummycallback(sock, servername, ctx, cycle=ctx):
1529 pass
1530 ctx.set_servername_callback(dummycallback)
1531 wr = weakref.ref(ctx)
1532 del ctx, dummycallback
1533 gc.collect()
1534 self.assertIs(wr(), None)
1535
1536 @unittest.skipUnless(support.Py_GIL_DISABLED,
1537 "test is only useful if the GIL is disabled")
1538 @threading_helper.requires_working_threading()
1539 def test_sni_callback_race(self):
1540 # Replacing sni_callback while handshakes are in-flight must not
1541 # crash (use-after-free on the callback in free-threaded builds).
1542 client_ctx, server_ctx, hostname = testing_context()
1543
1544 server_ctx.sni_callback = lambda *a: None
1545 done = threading.Event()
1546
1547 def do_handshakes():
1548 while not done.is_set():
1549 c_in = ssl.MemoryBIO()
1550 c_out = ssl.MemoryBIO()
1551 s_in = ssl.MemoryBIO()
1552 s_out = ssl.MemoryBIO()
1553 client = client_ctx.wrap_bio(
1554 c_in, c_out, server_hostname=hostname)
1555 server = server_ctx.wrap_bio(s_in, s_out, server_side=True)
1556 for _ in range(50):
1557 try:
1558 client.do_handshake()
1559 except ssl.SSLWantReadError:
1560 pass
1561 except ssl.SSLError:
1562 break
1563 if c_out.pending:
1564 s_in.write(c_out.read())
1565 try:
1566 server.do_handshake()
1567 except ssl.SSLWantReadError:
1568 pass
1569 except ssl.SSLError:
1570 break
1571 if s_out.pending:
1572 c_in.write(s_out.read())
1573
1574 def toggle_callback():
1575 while not done.is_set():
1576 server_ctx.sni_callback = lambda *a: None
1577 server_ctx.sni_callback = None
1578
1579 workers = max(4, (os.cpu_count() or 4) * 2)
1580 threads = [threading.Thread(target=do_handshakes)
1581 for _ in range(workers)]
1582 threads.append(threading.Thread(target=toggle_callback))
1583
1584 with threading_helper.catch_threading_exception() as cm:
1585 with threading_helper.start_threads(threads):
1586 done.set()
1587 self.assertIsNone(cm.exc_value)
1588
1589 def test_cert_store_stats(self):
1590 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1591 self.assertEqual(ctx.cert_store_stats(),
1592 {'x509_ca': 0, 'crl': 0, 'x509': 0})
1593 ctx.load_cert_chain(CERTFILE)
1594 self.assertEqual(ctx.cert_store_stats(),
1595 {'x509_ca': 0, 'crl': 0, 'x509': 0})
1596 ctx.load_verify_locations(CERTFILE)
1597 self.assertEqual(ctx.cert_store_stats(),
1598 {'x509_ca': 0, 'crl': 0, 'x509': 1})
1599 ctx.load_verify_locations(CAFILE_CACERT)
1600 self.assertEqual(ctx.cert_store_stats(),
1601 {'x509_ca': 1, 'crl': 0, 'x509': 2})
1602
1603 def test_get_ca_certs(self):
1604 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1605 self.assertEqual(ctx.get_ca_certs(), [])
1606 # CERTFILE is not flagged as X509v3 Basic Constraints: CA:TRUE
1607 ctx.load_verify_locations(CERTFILE)
1608 self.assertEqual(ctx.get_ca_certs(), [])
1609 # but CAFILE_CACERT is a CA cert
1610 ctx.load_verify_locations(CAFILE_CACERT)
1611 self.assertEqual(ctx.get_ca_certs(),
1612 [{'issuer': ((('organizationName', 'Root CA'),),
1613 (('organizationalUnitName', 'http://www.cacert.org'),),
1614 (('commonName', 'CA Cert Signing Authority'),),
1615 (('emailAddress', '[email protected]'),)),
1616 'notAfter': 'Mar 29 12:29:49 2033 GMT',
1617 'notBefore': 'Mar 30 12:29:49 2003 GMT',
1618 'serialNumber': '00',
1619 'crlDistributionPoints': ('https://www.cacert.org/revoke.crl',),
1620 'subject': ((('organizationName', 'Root CA'),),
1621 (('organizationalUnitName', 'http://www.cacert.org'),),
1622 (('commonName', 'CA Cert Signing Authority'),),
1623 (('emailAddress', '[email protected]'),)),
1624 'version': 3}])
1625
1626 with open(CAFILE_CACERT) as f:
1627 pem = f.read()
1628 der = ssl.PEM_cert_to_DER_cert(pem)
1629 self.assertEqual(ctx.get_ca_certs(True), [der])
1630
1631 def test_load_default_certs(self):
1632 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1633 ctx.load_default_certs()
1634
1635 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1636 ctx.load_default_certs(ssl.Purpose.SERVER_AUTH)
1637 ctx.load_default_certs()
1638
1639 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1640 ctx.load_default_certs(ssl.Purpose.CLIENT_AUTH)
1641
1642 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1643 self.assertRaises(TypeError, ctx.load_default_certs, None)
1644 self.assertRaises(TypeError, ctx.load_default_certs, 'SERVER_AUTH')
1645
1646 @unittest.skipIf(sys.platform == "win32", "not-Windows specific")
1647 def test_load_default_certs_env(self):
1648 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1649 with os_helper.EnvironmentVarGuard() as env:
1650 env["SSL_CERT_DIR"] = CAPATH
1651 env["SSL_CERT_FILE"] = CERTFILE
1652 ctx.load_default_certs()
1653 self.assertEqual(ctx.cert_store_stats(), {"crl": 0, "x509": 1, "x509_ca": 0})
1654
1655 @unittest.skipUnless(sys.platform == "win32", "Windows specific")
1656 @unittest.skipIf(support.Py_DEBUG,
1657 "Debug build does not share environment between CRTs")
1658 def test_load_default_certs_env_windows(self):
1659 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1660 ctx.load_default_certs()
1661 stats = ctx.cert_store_stats()
1662
1663 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1664 with os_helper.EnvironmentVarGuard() as env:
1665 env["SSL_CERT_DIR"] = CAPATH
1666 env["SSL_CERT_FILE"] = CERTFILE
1667 ctx.load_default_certs()
1668 stats["x509"] += 1
1669 self.assertEqual(ctx.cert_store_stats(), stats)
1670
1671 def _assert_context_options(self, ctx):
1672 self.assertEqual(ctx.options & ssl.OP_NO_SSLv2, ssl.OP_NO_SSLv2)
1673 if OP_NO_COMPRESSION != 0:
1674 self.assertEqual(ctx.options & OP_NO_COMPRESSION,
1675 OP_NO_COMPRESSION)
1676 if OP_SINGLE_DH_USE != 0:
1677 self.assertEqual(ctx.options & OP_SINGLE_DH_USE,
1678 OP_SINGLE_DH_USE)
1679 if OP_SINGLE_ECDH_USE != 0:
1680 self.assertEqual(ctx.options & OP_SINGLE_ECDH_USE,
1681 OP_SINGLE_ECDH_USE)
1682 if OP_CIPHER_SERVER_PREFERENCE != 0:
1683 self.assertEqual(ctx.options & OP_CIPHER_SERVER_PREFERENCE,
1684 OP_CIPHER_SERVER_PREFERENCE)
1685 self.assertEqual(ctx.options & ssl.OP_LEGACY_SERVER_CONNECT,
1686 0 if IS_OPENSSL_3_0_0 else ssl.OP_LEGACY_SERVER_CONNECT)
1687
1688 def test_create_default_context(self):
1689 ctx = ssl.create_default_context()
1690
1691 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_CLIENT)
1692 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1693 self.assertEqual(ctx.verify_flags & ssl.VERIFY_X509_PARTIAL_CHAIN,
1694 ssl.VERIFY_X509_PARTIAL_CHAIN)
1695 self.assertEqual(ctx.verify_flags & ssl.VERIFY_X509_STRICT,
1696 ssl.VERIFY_X509_STRICT)
1697 self.assertTrue(ctx.check_hostname)
1698 self._assert_context_options(ctx)
1699
1700 with open(SIGNING_CA) as f:
1701 cadata = f.read()
1702 ctx = ssl.create_default_context(cafile=SIGNING_CA, capath=CAPATH,
1703 cadata=cadata)
1704 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_CLIENT)
1705 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1706 self._assert_context_options(ctx)
1707
1708 ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
1709 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_SERVER)
1710 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1711 self._assert_context_options(ctx)
1712
1713 def test__create_stdlib_context(self):
1714 ctx = ssl._create_stdlib_context()
1715 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_CLIENT)
1716 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1717 self.assertFalse(ctx.check_hostname)
1718 self._assert_context_options(ctx)
1719
1720 if has_tls_protocol(ssl.PROTOCOL_TLSv1):
1721 with warnings_helper.check_warnings():
1722 ctx = ssl._create_stdlib_context(ssl.PROTOCOL_TLSv1)
1723 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLSv1)
1724 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1725 self._assert_context_options(ctx)
1726
1727 with warnings_helper.check_warnings():
1728 ctx = ssl._create_stdlib_context(
1729 ssl.PROTOCOL_TLSv1_2,
1730 cert_reqs=ssl.CERT_REQUIRED,
1731 check_hostname=True
1732 )
1733 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLSv1_2)
1734 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1735 self.assertTrue(ctx.check_hostname)
1736 self._assert_context_options(ctx)
1737
1738 ctx = ssl._create_stdlib_context(purpose=ssl.Purpose.CLIENT_AUTH)
1739 self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_SERVER)
1740 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1741 self._assert_context_options(ctx)
1742
1743 def test_check_hostname(self):
1744 with warnings_helper.check_warnings():
1745 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS)
1746 self.assertFalse(ctx.check_hostname)
1747 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1748
1749 # Auto set CERT_REQUIRED
1750 ctx.check_hostname = True
1751 self.assertTrue(ctx.check_hostname)
1752 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1753 ctx.check_hostname = False
1754 ctx.verify_mode = ssl.CERT_REQUIRED
1755 self.assertFalse(ctx.check_hostname)
1756 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1757
1758 # Changing verify_mode does not affect check_hostname
1759 ctx.check_hostname = False
1760 ctx.verify_mode = ssl.CERT_NONE
1761 ctx.check_hostname = False
1762 self.assertFalse(ctx.check_hostname)
1763 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1764 # Auto set
1765 ctx.check_hostname = True
1766 self.assertTrue(ctx.check_hostname)
1767 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1768
1769 ctx.check_hostname = False
1770 ctx.verify_mode = ssl.CERT_OPTIONAL
1771 ctx.check_hostname = False
1772 self.assertFalse(ctx.check_hostname)
1773 self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
1774 # keep CERT_OPTIONAL
1775 ctx.check_hostname = True
1776 self.assertTrue(ctx.check_hostname)
1777 self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
1778
1779 # Cannot set CERT_NONE with check_hostname enabled
1780 with self.assertRaises(ValueError):
1781 ctx.verify_mode = ssl.CERT_NONE
1782 ctx.check_hostname = False
1783 self.assertFalse(ctx.check_hostname)
1784 ctx.verify_mode = ssl.CERT_NONE
1785 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1786
1787 def test_context_client_server(self):
1788 # PROTOCOL_TLS_CLIENT has sane defaults
1789 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1790 self.assertTrue(ctx.check_hostname)
1791 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1792
1793 # PROTOCOL_TLS_SERVER has different but also sane defaults
1794 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1795 self.assertFalse(ctx.check_hostname)
1796 self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
1797
1798 def test_context_custom_class(self):
1799 class MySSLSocket(ssl.SSLSocket):
1800 pass
1801
1802 class MySSLObject(ssl.SSLObject):
1803 pass
1804
1805 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1806 ctx.sslsocket_class = MySSLSocket
1807 ctx.sslobject_class = MySSLObject
1808
1809 with ctx.wrap_socket(socket.socket(), server_side=True) as sock:
1810 self.assertIsInstance(sock, MySSLSocket)
1811 obj = ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(), server_side=True)
1812 self.assertIsInstance(obj, MySSLObject)
1813
1814 def test_num_tickest(self):
1815 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1816 self.assertEqual(ctx.num_tickets, 2)
1817 ctx.num_tickets = 1
1818 self.assertEqual(ctx.num_tickets, 1)
1819 ctx.num_tickets = 0
1820 self.assertEqual(ctx.num_tickets, 0)
1821 with self.assertRaises(ValueError):
1822 ctx.num_tickets = -1
1823 with self.assertRaises(TypeError):
1824 ctx.num_tickets = None
1825
1826 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1827 self.assertEqual(ctx.num_tickets, 2)
1828 with self.assertRaises(ValueError):
1829 ctx.num_tickets = 1
1830
1831 @support.cpython_only
1832 def test_refcycle_msg_callback(self):
1833 # See https://github.com/python/cpython/issues/142516.
1834 ctx = make_test_context()
1835 def msg_callback(*args, _=ctx, **kwargs): ...
1836 ctx._msg_callback = msg_callback
1837
1838 @support.cpython_only
1839 @requires_keylog_setter
1840 def test_refcycle_keylog_filename(self):
1841 # See https://github.com/python/cpython/issues/142516.
1842 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
1843 ctx = make_test_context()
1844 class KeylogFilename(str): ...
1845 ctx.keylog_filename = KeylogFilename(os_helper.TESTFN)
1846 ctx.keylog_filename._ = ctx
1847
1848 @support.cpython_only
1849 @unittest.skipUnless(ssl.HAS_PSK, 'requires TLS-PSK')
1850 def test_refcycle_psk_client_callback(self):
1851 # See https://github.com/python/cpython/issues/142516.
1852 ctx = make_test_context()
1853 def psk_client_callback(*args, _=ctx, **kwargs): ...
1854 ctx.set_psk_client_callback(psk_client_callback)
1855
1856 @support.cpython_only
1857 @unittest.skipUnless(ssl.HAS_PSK, 'requires TLS-PSK')
1858 def test_refcycle_psk_server_callback(self):
1859 # See https://github.com/python/cpython/issues/142516.
1860 ctx = make_test_context(server_side=True)
1861 def psk_server_callback(*args, _=ctx, **kwargs): ...
1862 ctx.set_psk_server_callback(psk_server_callback)
1863
1864
1865 class SSLErrorTests(unittest.TestCase):
1866
1867 def test_str(self):
1868 # The str() of a SSLError doesn't include the errno
1869 e = ssl.SSLError(1, "foo")
1870 self.assertEqual(str(e), "foo")
1871 self.assertEqual(e.errno, 1)
1872 # Same for a subclass
1873 e = ssl.SSLZeroReturnError(1, "foo")
1874 self.assertEqual(str(e), "foo")
1875 self.assertEqual(e.errno, 1)
1876
1877 def test_lib_reason(self):
1878 # Test the library and reason attributes
1879 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1880 try:
1881 with self.assertRaises(ssl.SSLError) as cm:
1882 ctx.load_dh_params(CERTFILE)
1883 except RuntimeError:
1884 if Py_DEBUG_WIN32:
1885 self.skipTest("not supported on Win32 debug build")
1886 raise
1887
1888 self.assertEqual(cm.exception.library, 'PEM')
1889 regex = "(NO_START_LINE|UNSUPPORTED_PUBLIC_KEY_TYPE)"
1890 self.assertRegex(cm.exception.reason, regex)
1891 s = str(cm.exception)
1892 self.assertIn("NO_START_LINE", s)
1893
1894 def test_subclass(self):
1895 # Check that the appropriate SSLError subclass is raised
1896 # (this only tests one of them)
1897 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1898 ctx.check_hostname = False
1899 ctx.verify_mode = ssl.CERT_NONE
1900 with socket.create_server(("127.0.0.1", 0)) as s:
1901 c = socket.create_connection(s.getsockname())
1902 c.setblocking(False)
1903 with ctx.wrap_socket(c, False, do_handshake_on_connect=False) as c:
1904 with self.assertRaises(ssl.SSLWantReadError) as cm:
1905 c.do_handshake()
1906 s = str(cm.exception)
1907 self.assertStartsWith(s, "The operation did not complete (read)")
1908 # For compatibility
1909 self.assertEqual(cm.exception.errno, ssl.SSL_ERROR_WANT_READ)
1910
1911
1912 def test_bad_server_hostname(self):
1913 ctx = ssl.create_default_context()
1914 with self.assertRaises(ValueError):
1915 ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(),
1916 server_hostname="")
1917 with self.assertRaises(ValueError):
1918 ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(),
1919 server_hostname=".example.org")
1920 with self.assertRaises(TypeError):
1921 ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(),
1922 server_hostname="example.org\x00evil.com")
1923
1924
1925 class MemoryBIOTests(unittest.TestCase):
1926
1927 def test_read_write(self):
1928 bio = ssl.MemoryBIO()
1929 bio.write(b'foo')
1930 self.assertEqual(bio.read(), b'foo')
1931 self.assertEqual(bio.read(), b'')
1932 bio.write(b'foo')
1933 bio.write(b'bar')
1934 self.assertEqual(bio.read(), b'foobar')
1935 self.assertEqual(bio.read(), b'')
1936 bio.write(b'baz')
1937 self.assertEqual(bio.read(2), b'ba')
1938 self.assertEqual(bio.read(1), b'z')
1939 self.assertEqual(bio.read(1), b'')
1940
1941 def test_eof(self):
1942 bio = ssl.MemoryBIO()
1943 self.assertFalse(bio.eof)
1944 self.assertEqual(bio.read(), b'')
1945 self.assertFalse(bio.eof)
1946 bio.write(b'foo')
1947 self.assertFalse(bio.eof)
1948 bio.write_eof()
1949 self.assertFalse(bio.eof)
1950 self.assertEqual(bio.read(2), b'fo')
1951 self.assertFalse(bio.eof)
1952 self.assertEqual(bio.read(1), b'o')
1953 self.assertTrue(bio.eof)
1954 self.assertEqual(bio.read(), b'')
1955 self.assertTrue(bio.eof)
1956
1957 def test_pending(self):
1958 bio = ssl.MemoryBIO()
1959 self.assertEqual(bio.pending, 0)
1960 bio.write(b'foo')
1961 self.assertEqual(bio.pending, 3)
1962 for i in range(3):
1963 bio.read(1)
1964 self.assertEqual(bio.pending, 3-i-1)
1965 for i in range(3):
1966 bio.write(b'x')
1967 self.assertEqual(bio.pending, i+1)
1968 bio.read()
1969 self.assertEqual(bio.pending, 0)
1970
1971 def test_buffer_types(self):
1972 bio = ssl.MemoryBIO()
1973 bio.write(b'foo')
1974 self.assertEqual(bio.read(), b'foo')
1975 bio.write(bytearray(b'bar'))
1976 self.assertEqual(bio.read(), b'bar')
1977 bio.write(memoryview(b'baz'))
1978 self.assertEqual(bio.read(), b'baz')
1979 m = memoryview(bytearray(b'noncontig'))
1980 noncontig_writable = m[::-2]
1981 with self.assertRaises(BufferError):
1982 bio.write(memoryview(noncontig_writable))
1983
1984 def test_error_types(self):
1985 bio = ssl.MemoryBIO()
1986 self.assertRaises(TypeError, bio.write, 'foo')
1987 self.assertRaises(TypeError, bio.write, None)
1988 self.assertRaises(TypeError, bio.write, True)
1989 self.assertRaises(TypeError, bio.write, 1)
1990
1991
1992 class SSLObjectTests(unittest.TestCase):
1993 def test_private_init(self):
1994 bio = ssl.MemoryBIO()
1995 with self.assertRaisesRegex(TypeError, "public constructor"):
1996 ssl.SSLObject(bio, bio)
1997
1998 def test_unwrap(self):
1999 client_ctx, server_ctx, hostname = testing_context()
2000 c_in = ssl.MemoryBIO()
2001 c_out = ssl.MemoryBIO()
2002 s_in = ssl.MemoryBIO()
2003 s_out = ssl.MemoryBIO()
2004 client = client_ctx.wrap_bio(c_in, c_out, server_hostname=hostname)
2005 server = server_ctx.wrap_bio(s_in, s_out, server_side=True)
2006
2007 # Loop on the handshake for a bit to get it settled
2008 for _ in range(5):
2009 try:
2010 client.do_handshake()
2011 except ssl.SSLWantReadError:
2012 pass
2013 if c_out.pending:
2014 s_in.write(c_out.read())
2015 try:
2016 server.do_handshake()
2017 except ssl.SSLWantReadError:
2018 pass
2019 if s_out.pending:
2020 c_in.write(s_out.read())
2021 # Now the handshakes should be complete (don't raise WantReadError)
2022 client.do_handshake()
2023 server.do_handshake()
2024
2025 # Now if we unwrap one side unilaterally, it should send close-notify
2026 # and raise WantReadError:
2027 with self.assertRaises(ssl.SSLWantReadError):
2028 client.unwrap()
2029
2030 # But server.unwrap() does not raise, because it reads the client's
2031 # close-notify:
2032 s_in.write(c_out.read())
2033 server.unwrap()
2034
2035 # And now that the client gets the server's close-notify, it doesn't
2036 # raise either.
2037 c_in.write(s_out.read())
2038 client.unwrap()
2039
2040 class SimpleBackgroundTests(unittest.TestCase):
2041 """Tests that connect to a simple server running in the background"""
2042
2043 def setUp(self):
2044 self.server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
2045 self.server_context.load_cert_chain(SIGNED_CERTFILE)
2046 server = ThreadedEchoServer(context=self.server_context)
2047 self.enterContext(server)
2048 self.server_addr = (HOST, server.port)
2049
2050 def test_connect(self):
2051 with test_wrap_socket(socket.socket(socket.AF_INET),
2052 cert_reqs=ssl.CERT_NONE) as s:
2053 s.connect(self.server_addr)
2054 self.assertEqual({}, s.getpeercert())
2055 self.assertFalse(s.server_side)
2056
2057 # this should succeed because we specify the root cert
2058 with test_wrap_socket(socket.socket(socket.AF_INET),
2059 cert_reqs=ssl.CERT_REQUIRED,
2060 ca_certs=SIGNING_CA) as s:
2061 s.connect(self.server_addr)
2062 self.assertTrue(s.getpeercert())
2063 self.assertFalse(s.server_side)
2064
2065 def test_connect_fail(self):
2066 # This should fail because we have no verification certs. Connection
2067 # failure crashes ThreadedEchoServer, so run this in an independent
2068 # test method.
2069 s = test_wrap_socket(socket.socket(socket.AF_INET),
2070 cert_reqs=ssl.CERT_REQUIRED)
2071 self.addCleanup(s.close)
2072 # Allow for flexible libssl error messages.
2073 regex = re.compile(r"""(
2074 certificate verify failed # OpenSSL
2075 |
2076 CERTIFICATE_VERIFY_FAILED # AWS-LC
2077 )""", re.X)
2078 self.assertRaisesRegex(ssl.SSLError, regex,
2079 s.connect, self.server_addr)
2080
2081 def test_connect_ex(self):
2082 # Issue #11326: check connect_ex() implementation
2083 s = test_wrap_socket(socket.socket(socket.AF_INET),
2084 cert_reqs=ssl.CERT_REQUIRED,
2085 ca_certs=SIGNING_CA)
2086 self.addCleanup(s.close)
2087 self.assertEqual(0, s.connect_ex(self.server_addr))
2088 self.assertTrue(s.getpeercert())
2089
2090 def test_non_blocking_connect_ex(self):
2091 # Issue #11326: non-blocking connect_ex() should allow handshake
2092 # to proceed after the socket gets ready.
2093 s = test_wrap_socket(socket.socket(socket.AF_INET),
2094 cert_reqs=ssl.CERT_REQUIRED,
2095 ca_certs=SIGNING_CA,
2096 do_handshake_on_connect=False)
2097 self.addCleanup(s.close)
2098 s.setblocking(False)
2099 rc = s.connect_ex(self.server_addr)
2100 # EWOULDBLOCK under Windows, EINPROGRESS elsewhere
2101 self.assertIn(rc, (0, errno.EINPROGRESS, errno.EWOULDBLOCK))
2102 # Wait for connect to finish
2103 select.select([], [s], [], 5.0)
2104 # Non-blocking handshake
2105 while True:
2106 try:
2107 s.do_handshake()
2108 break
2109 except ssl.SSLWantReadError:
2110 select.select([s], [], [], 5.0)
2111 except ssl.SSLWantWriteError:
2112 select.select([], [s], [], 5.0)
2113 # SSL established
2114 self.assertTrue(s.getpeercert())
2115
2116 def test_connect_with_context(self):
2117 # Same as test_connect, but with a separately created context
2118 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2119 ctx.check_hostname = False
2120 ctx.verify_mode = ssl.CERT_NONE
2121 with ctx.wrap_socket(socket.socket(socket.AF_INET)) as s:
2122 s.connect(self.server_addr)
2123 self.assertEqual({}, s.getpeercert())
2124 # Same with a server hostname
2125 with ctx.wrap_socket(socket.socket(socket.AF_INET),
2126 server_hostname="dummy") as s:
2127 s.connect(self.server_addr)
2128 ctx.verify_mode = ssl.CERT_REQUIRED
2129 # This should succeed because we specify the root cert
2130 ctx.load_verify_locations(SIGNING_CA)
2131 with ctx.wrap_socket(socket.socket(socket.AF_INET)) as s:
2132 s.connect(self.server_addr)
2133 cert = s.getpeercert()
2134 self.assertTrue(cert)
2135
2136 def test_connect_with_context_fail(self):
2137 # This should fail because we have no verification certs. Connection
2138 # failure crashes ThreadedEchoServer, so run this in an independent
2139 # test method.
2140 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2141 s = ctx.wrap_socket(
2142 socket.socket(socket.AF_INET),
2143 server_hostname=SIGNED_CERTFILE_HOSTNAME
2144 )
2145 self.addCleanup(s.close)
2146 # Allow for flexible libssl error messages.
2147 regex = re.compile(r"""(
2148 certificate verify failed # OpenSSL
2149 |
2150 CERTIFICATE_VERIFY_FAILED # AWS-LC
2151 )""", re.X)
2152 self.assertRaisesRegex(ssl.SSLError, regex,
2153 s.connect, self.server_addr)
2154
2155 def test_connect_capath(self):
2156 # Verify server certificates using the `capath` argument
2157 # NOTE: the subject hashing algorithm has been changed between
2158 # OpenSSL 0.9.8n and 1.0.0, as a result the capath directory must
2159 # contain both versions of each certificate (same content, different
2160 # filename) for this test to be portable across OpenSSL releases.
2161 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2162 ctx.load_verify_locations(capath=CAPATH)
2163 with ctx.wrap_socket(socket.socket(socket.AF_INET),
2164 server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
2165 s.connect(self.server_addr)
2166 cert = s.getpeercert()
2167 self.assertTrue(cert)
2168
2169 # Same with a bytes `capath` argument
2170 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2171 ctx.load_verify_locations(capath=BYTES_CAPATH)
2172 with ctx.wrap_socket(socket.socket(socket.AF_INET),
2173 server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
2174 s.connect(self.server_addr)
2175 cert = s.getpeercert()
2176 self.assertTrue(cert)
2177
2178 def test_connect_cadata(self):
2179 with open(SIGNING_CA) as f:
2180 pem = f.read()
2181 der = ssl.PEM_cert_to_DER_cert(pem)
2182 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2183 ctx.load_verify_locations(cadata=pem)
2184 with ctx.wrap_socket(socket.socket(socket.AF_INET),
2185 server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
2186 s.connect(self.server_addr)
2187 cert = s.getpeercert()
2188 self.assertTrue(cert)
2189
2190 # same with DER
2191 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2192 ctx.load_verify_locations(cadata=der)
2193 with ctx.wrap_socket(socket.socket(socket.AF_INET),
2194 server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
2195 s.connect(self.server_addr)
2196 cert = s.getpeercert()
2197 self.assertTrue(cert)
2198
2199 @unittest.skipIf(os.name == "nt", "Can't use a socket as a file under Windows")
2200 def test_makefile_close(self):
2201 # Issue #5238: creating a file-like object with makefile() shouldn't
2202 # delay closing the underlying "real socket" (here tested with its
2203 # file descriptor, hence skipping the test under Windows).
2204 ss = test_wrap_socket(socket.socket(socket.AF_INET))
2205 ss.connect(self.server_addr)
2206 fd = ss.fileno()
2207 f = ss.makefile()
2208 f.close()
2209 # The fd is still open
2210 os.read(fd, 0)
2211 # Closing the SSL socket should close the fd too
2212 ss.close()
2213 gc.collect()
2214 with self.assertRaises(OSError) as e:
2215 os.read(fd, 0)
2216 self.assertEqual(e.exception.errno, errno.EBADF)
2217
2218 def test_non_blocking_handshake(self):
2219 s = socket.socket(socket.AF_INET)
2220 s.connect(self.server_addr)
2221 s.setblocking(False)
2222 s = test_wrap_socket(s,
2223 cert_reqs=ssl.CERT_NONE,
2224 do_handshake_on_connect=False)
2225 self.addCleanup(s.close)
2226 count = 0
2227 while True:
2228 try:
2229 count += 1
2230 s.do_handshake()
2231 break
2232 except ssl.SSLWantReadError:
2233 select.select([s], [], [])
2234 except ssl.SSLWantWriteError:
2235 select.select([], [s], [])
2236 if support.verbose:
2237 sys.stdout.write("\nNeeded %d calls to do_handshake() to establish session.\n" % count)
2238
2239 def test_get_server_certificate(self):
2240 _test_get_server_certificate(self, *self.server_addr, cert=SIGNING_CA)
2241
2242 def test_get_server_certificate_sni(self):
2243 host, port = self.server_addr
2244 server_names = []
2245
2246 # We store servername_cb arguments to make sure they match the host
2247 def servername_cb(ssl_sock, server_name, initial_context):
2248 server_names.append(server_name)
2249 self.server_context.set_servername_callback(servername_cb)
2250
2251 pem = ssl.get_server_certificate((host, port))
2252 if not pem:
2253 self.fail("No server certificate on %s:%s!" % (host, port))
2254
2255 pem = ssl.get_server_certificate((host, port), ca_certs=SIGNING_CA)
2256 if not pem:
2257 self.fail("No server certificate on %s:%s!" % (host, port))
2258 if support.verbose:
2259 sys.stdout.write("\nVerified certificate for %s:%s is\n%s\n" % (host, port, pem))
2260
2261 self.assertEqual(server_names, [host, host])
2262
2263 def test_get_server_certificate_fail(self):
2264 # Connection failure crashes ThreadedEchoServer, so run this in an
2265 # independent test method
2266 _test_get_server_certificate_fail(self, *self.server_addr)
2267
2268 def test_get_server_certificate_timeout(self):
2269 def servername_cb(ssl_sock, server_name, initial_context):
2270 time.sleep(0.2)
2271 self.server_context.set_servername_callback(servername_cb)
2272
2273 with self.assertRaises(socket.timeout):
2274 ssl.get_server_certificate(self.server_addr, ca_certs=SIGNING_CA,
2275 timeout=0.1)
2276
2277 def test_ciphers(self):
2278 with test_wrap_socket(socket.socket(socket.AF_INET),
2279 cert_reqs=ssl.CERT_NONE, ciphers="ALL") as s:
2280 s.connect(self.server_addr)
2281 with test_wrap_socket(socket.socket(socket.AF_INET),
2282 cert_reqs=ssl.CERT_NONE, ciphers="DEFAULT") as s:
2283 s.connect(self.server_addr)
2284 # Error checking can happen at instantiation or when connecting
2285 with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
2286 with socket.socket(socket.AF_INET) as sock:
2287 s = test_wrap_socket(sock,
2288 cert_reqs=ssl.CERT_NONE, ciphers="^$:,;?*'dorothyx")
2289 s.connect(self.server_addr)
2290
2291 def test_get_ca_certs_capath(self):
2292 # capath certs are loaded on request
2293 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2294 ctx.load_verify_locations(capath=CAPATH)
2295 self.assertEqual(ctx.get_ca_certs(), [])
2296 with ctx.wrap_socket(socket.socket(socket.AF_INET),
2297 server_hostname='localhost') as s:
2298 s.connect(self.server_addr)
2299 cert = s.getpeercert()
2300 self.assertTrue(cert)
2301 self.assertEqual(len(ctx.get_ca_certs()), 1)
2302
2303 def test_context_setget(self):
2304 # Check that the context of a connected socket can be replaced.
2305 ctx1 = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2306 ctx1.load_verify_locations(capath=CAPATH)
2307 ctx2 = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2308 ctx2.load_verify_locations(capath=CAPATH)
2309 s = socket.socket(socket.AF_INET)
2310 with ctx1.wrap_socket(s, server_hostname='localhost') as ss:
2311 ss.connect(self.server_addr)
2312 self.assertIs(ss.context, ctx1)
2313 self.assertIs(ss._sslobj.context, ctx1)
2314 ss.context = ctx2
2315 self.assertIs(ss.context, ctx2)
2316 self.assertIs(ss._sslobj.context, ctx2)
2317
2318 def ssl_io_loop(self, sock, incoming, outgoing, func, *args, **kwargs):
2319 # A simple IO loop. Call func(*args) depending on the error we get
2320 # (WANT_READ or WANT_WRITE) move data between the socket and the BIOs.
2321 timeout = kwargs.get('timeout', support.SHORT_TIMEOUT)
2322 count = 0
2323 for _ in support.busy_retry(timeout):
2324 errno = None
2325 count += 1
2326 try:
2327 ret = func(*args)
2328 except ssl.SSLError as e:
2329 if e.errno not in (ssl.SSL_ERROR_WANT_READ,
2330 ssl.SSL_ERROR_WANT_WRITE):
2331 raise
2332 errno = e.errno
2333 # Get any data from the outgoing BIO irrespective of any error, and
2334 # send it to the socket.
2335 buf = outgoing.read()
2336 sock.sendall(buf)
2337 # If there's no error, we're done. For WANT_READ, we need to get
2338 # data from the socket and put it in the incoming BIO.
2339 if errno is None:
2340 break
2341 elif errno == ssl.SSL_ERROR_WANT_READ:
2342 buf = sock.recv(32768)
2343 if buf:
2344 incoming.write(buf)
2345 else:
2346 incoming.write_eof()
2347 if support.verbose:
2348 sys.stdout.write("Needed %d calls to complete %s().\n"
2349 % (count, func.__name__))
2350 return ret
2351
2352 def test_bio_handshake(self):
2353 sock = socket.socket(socket.AF_INET)
2354 self.addCleanup(sock.close)
2355 sock.connect(self.server_addr)
2356 incoming = ssl.MemoryBIO()
2357 outgoing = ssl.MemoryBIO()
2358 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2359 self.assertTrue(ctx.check_hostname)
2360 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
2361 ctx.load_verify_locations(SIGNING_CA)
2362 sslobj = ctx.wrap_bio(incoming, outgoing, False,
2363 SIGNED_CERTFILE_HOSTNAME)
2364 self.assertIs(sslobj._sslobj.owner, sslobj)
2365 self.assertIsNone(sslobj.cipher())
2366 self.assertIsNone(sslobj.version())
2367 self.assertIsNone(sslobj.shared_ciphers())
2368 self.assertRaises(ValueError, sslobj.getpeercert)
2369 # tls-unique is not defined for TLSv1.3
2370 # https://datatracker.ietf.org/doc/html/rfc8446#appendix-C.5
2371 if 'tls-unique' in ssl.CHANNEL_BINDING_TYPES and sslobj.version() != "TLSv1.3":
2372 self.assertIsNone(sslobj.get_channel_binding('tls-unique'))
2373 self.ssl_io_loop(sock, incoming, outgoing, sslobj.do_handshake)
2374 self.assertTrue(sslobj.cipher())
2375 self.assertIsNone(sslobj.shared_ciphers())
2376 self.assertIsNotNone(sslobj.version())
2377 self.assertTrue(sslobj.getpeercert())
2378 if 'tls-unique' in ssl.CHANNEL_BINDING_TYPES and sslobj.version() != "TLSv1.3":
2379 self.assertTrue(sslobj.get_channel_binding('tls-unique'))
2380 try:
2381 self.ssl_io_loop(sock, incoming, outgoing, sslobj.unwrap)
2382 except ssl.SSLSyscallError:
2383 # If the server shuts down the TCP connection without sending a
2384 # secure shutdown message, this is reported as SSL_ERROR_SYSCALL
2385 pass
2386 self.assertRaises(ssl.SSLError, sslobj.write, b'foo')
2387
2388 def test_bio_read_write_data(self):
2389 sock = socket.socket(socket.AF_INET)
2390 self.addCleanup(sock.close)
2391 sock.connect(self.server_addr)
2392 incoming = ssl.MemoryBIO()
2393 outgoing = ssl.MemoryBIO()
2394 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
2395 ctx.check_hostname = False
2396 ctx.verify_mode = ssl.CERT_NONE
2397 sslobj = ctx.wrap_bio(incoming, outgoing, False)
2398 self.ssl_io_loop(sock, incoming, outgoing, sslobj.do_handshake)
2399 req = b'FOO\n'
2400 self.ssl_io_loop(sock, incoming, outgoing, sslobj.write, req)
2401 buf = self.ssl_io_loop(sock, incoming, outgoing, sslobj.read, 1024)
2402 self.assertEqual(buf, b'foo\n')
2403 self.ssl_io_loop(sock, incoming, outgoing, sslobj.unwrap)
2404
2405 def test_transport_eof(self):
2406 client_context, server_context, hostname = testing_context()
2407 with socket.socket(socket.AF_INET) as sock:
2408 sock.connect(self.server_addr)
2409 incoming = ssl.MemoryBIO()
2410 outgoing = ssl.MemoryBIO()
2411 sslobj = client_context.wrap_bio(incoming, outgoing,
2412 server_hostname=hostname)
2413 self.ssl_io_loop(sock, incoming, outgoing, sslobj.do_handshake)
2414
2415 # Simulate EOF from the transport.
2416 incoming.write_eof()
2417 self.assertRaises(ssl.SSLEOFError, sslobj.read)
2418
2419
2420 @support.requires_resource('network')
2421 class NetworkedTests(unittest.TestCase):
2422
2423 def test_timeout_connect_ex(self):
2424 # Issue #12065: on a timeout, connect_ex() should return the original
2425 # errno (mimicking the behaviour of non-SSL sockets).
2426 with socket_helper.transient_internet(REMOTE_HOST):
2427 s = test_wrap_socket(socket.socket(socket.AF_INET),
2428 cert_reqs=ssl.CERT_REQUIRED,
2429 do_handshake_on_connect=False)
2430 self.addCleanup(s.close)
2431 s.settimeout(0.0000001)
2432 rc = s.connect_ex((REMOTE_HOST, 443))
2433 if rc == 0:
2434 self.skipTest("REMOTE_HOST responded too quickly")
2435 elif rc == errno.ENETUNREACH:
2436 self.skipTest("Network unreachable.")
2437 self.assertIn(rc, (errno.EAGAIN, errno.EWOULDBLOCK))
2438
2439 @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'Needs IPv6')
2440 @support.requires_resource('walltime')
2441 def test_get_server_certificate_ipv6(self):
2442 with socket_helper.transient_internet('ipv6.google.com'):
2443 _test_get_server_certificate(self, 'ipv6.google.com', 443)
2444 _test_get_server_certificate_fail(self, 'ipv6.google.com', 443)
2445
2446
2447 def _test_get_server_certificate(test, host, port, cert=None):
2448 pem = ssl.get_server_certificate((host, port))
2449 if not pem:
2450 test.fail("No server certificate on %s:%s!" % (host, port))
2451
2452 pem = ssl.get_server_certificate((host, port), ca_certs=cert)
2453 if not pem:
2454 test.fail("No server certificate on %s:%s!" % (host, port))
2455 if support.verbose:
2456 sys.stdout.write("\nVerified certificate for %s:%s is\n%s\n" % (host, port ,pem))
2457
2458 def _test_get_server_certificate_fail(test, host, port):
2459 with warnings_helper.check_no_resource_warning(test):
2460 try:
2461 pem = ssl.get_server_certificate((host, port), ca_certs=CERTFILE)
2462 except ssl.SSLError as x:
2463 #should fail
2464 if support.verbose:
2465 sys.stdout.write("%s\n" % x)
2466 else:
2467 test.fail("Got server certificate %s for %s:%s!" % (pem, host, port))
2468
2469
2470 from test.ssl_servers import make_https_server
2471
2472 class ThreadedEchoServer(threading.Thread):
2473
2474 class ConnectionHandler(threading.Thread):
2475
2476 """A mildly complicated class, because we want it to work both
2477 with and without the SSL wrapper around the socket connection, so
2478 that we can test the STARTTLS functionality."""
2479
2480 def __init__(self, server, connsock, addr):
2481 self.server = server
2482 self.running = False
2483 self.sock = connsock
2484 self.addr = addr
2485 self.sock.setblocking(True)
2486 self.sslconn = None
2487 threading.Thread.__init__(self)
2488 self.daemon = True
2489
2490 def wrap_conn(self):
2491 try:
2492 self.sslconn = self.server.context.wrap_socket(
2493 self.sock, server_side=True)
2494 self.server.selected_alpn_protocols.append(self.sslconn.selected_alpn_protocol())
2495 except (ConnectionResetError, BrokenPipeError, ConnectionAbortedError) as e:
2496 # We treat ConnectionResetError as though it were an
2497 # SSLError - OpenSSL on Ubuntu abruptly closes the
2498 # connection when asked to use an unsupported protocol.
2499 #
2500 # BrokenPipeError is raised in TLS 1.3 mode, when OpenSSL
2501 # tries to send session tickets after handshake.
2502 # https://github.com/openssl/openssl/issues/6342
2503 #
2504 # ConnectionAbortedError is raised in TLS 1.3 mode, when OpenSSL
2505 # tries to send session tickets after handshake when using WinSock.
2506 self.server.conn_errors.append(str(e))
2507 if self.server.chatty:
2508 handle_error("\n server: bad connection attempt from " + repr(self.addr) + ":\n")
2509 self.running = False
2510 self.close()
2511 return False
2512 except (ssl.SSLError, OSError) as e:
2513 # OSError may occur with wrong protocols, e.g. both
2514 # sides use PROTOCOL_TLS_SERVER.
2515 #
2516 # XXX Various errors can have happened here, for example
2517 # a mismatching protocol version, an invalid certificate,
2518 # or a low-level bug. This should be made more discriminating.
2519 #
2520 # bpo-31323: Store the exception as string to prevent
2521 # a reference leak: server -> conn_errors -> exception
2522 # -> traceback -> self (ConnectionHandler) -> server
2523 self.server.conn_errors.append(str(e))
2524 if self.server.chatty:
2525 handle_error("\n server: bad connection attempt from " + repr(self.addr) + ":\n")
2526
2527 # bpo-44229, bpo-43855, bpo-44237, and bpo-33450:
2528 # Ignore spurious EPROTOTYPE returned by write() on macOS.
2529 # See also http://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/
2530 if e.errno != errno.EPROTOTYPE and sys.platform != "darwin":
2531 self.running = False
2532 self.close()
2533 return False
2534 else:
2535 self.server.shared_ciphers.append(self.sslconn.shared_ciphers())
2536 if self.server.context.verify_mode == ssl.CERT_REQUIRED:
2537 cert = self.sslconn.getpeercert()
2538 if support.verbose and self.server.chatty:
2539 sys.stdout.write(" client cert is " + pprint.pformat(cert) + "\n")
2540 cert_binary = self.sslconn.getpeercert(True)
2541 if support.verbose and self.server.chatty:
2542 if cert_binary is None:
2543 sys.stdout.write(" client did not provide a cert\n")
2544 else:
2545 sys.stdout.write(f" cert binary is {len(cert_binary)}b\n")
2546 cipher = self.sslconn.cipher()
2547 if support.verbose and self.server.chatty:
2548 sys.stdout.write(" server: connection cipher is now " + str(cipher) + "\n")
2549 return True
2550
2551 def read(self):
2552 if self.sslconn:
2553 return self.sslconn.read()
2554 else:
2555 return self.sock.recv(1024)
2556
2557 def write(self, bytes):
2558 if self.sslconn:
2559 return self.sslconn.write(bytes)
2560 else:
2561 return self.sock.send(bytes)
2562
2563 def close(self):
2564 if self.sslconn:
2565 self.sslconn.close()
2566 else:
2567 self.sock.close()
2568
2569 def run(self):
2570 self.running = True
2571 if not self.server.starttls_server:
2572 if not self.wrap_conn():
2573 return
2574 while self.running:
2575 try:
2576 msg = self.read()
2577 stripped = msg.strip()
2578 if not stripped:
2579 # eof, so quit this handler
2580 self.running = False
2581 try:
2582 self.sock = self.sslconn.unwrap()
2583 except OSError:
2584 # Many tests shut the TCP connection down
2585 # without an SSL shutdown. This causes
2586 # unwrap() to raise OSError with errno=0!
2587 pass
2588 else:
2589 self.sslconn = None
2590 self.close()
2591 elif stripped == b'over':
2592 if support.verbose and self.server.connectionchatty:
2593 sys.stdout.write(" server: client closed connection\n")
2594 self.close()
2595 return
2596 elif (self.server.starttls_server and
2597 stripped == b'STARTTLS'):
2598 if support.verbose and self.server.connectionchatty:
2599 sys.stdout.write(" server: read STARTTLS from client, sending OK...\n")
2600 self.write(b"OK\n")
2601 if not self.wrap_conn():
2602 return
2603 elif (self.server.starttls_server and self.sslconn
2604 and stripped == b'ENDTLS'):
2605 if support.verbose and self.server.connectionchatty:
2606 sys.stdout.write(" server: read ENDTLS from client, sending OK...\n")
2607 self.write(b"OK\n")
2608 self.sock = self.sslconn.unwrap()
2609 self.sslconn = None
2610 if support.verbose and self.server.connectionchatty:
2611 sys.stdout.write(" server: connection is now unencrypted...\n")
2612 elif stripped == b'CB tls-unique':
2613 if support.verbose and self.server.connectionchatty:
2614 sys.stdout.write(" server: read CB tls-unique from client, sending our CB data...\n")
2615 data = self.sslconn.get_channel_binding("tls-unique")
2616 self.write(repr(data).encode("us-ascii") + b"\n")
2617 elif stripped == b'PHA':
2618 if support.verbose and self.server.connectionchatty:
2619 sys.stdout.write(" server: initiating post handshake auth\n")
2620 try:
2621 self.sslconn.verify_client_post_handshake()
2622 except ssl.SSLError as e:
2623 self.write(repr(e).encode("us-ascii") + b"\n")
2624 else:
2625 self.write(b"OK\n")
2626 elif stripped == b'HASCERT':
2627 if self.sslconn.getpeercert() is not None:
2628 self.write(b'TRUE\n')
2629 else:
2630 self.write(b'FALSE\n')
2631 elif stripped == b'GETCERT':
2632 cert = self.sslconn.getpeercert()
2633 self.write(repr(cert).encode("us-ascii") + b"\n")
2634 elif stripped == b'VERIFIEDCHAIN':
2635 certs = self.sslconn._sslobj.get_verified_chain()
2636 self.write(len(certs).to_bytes(1, "big") + b"\n")
2637 elif stripped == b'UNVERIFIEDCHAIN':
2638 certs = self.sslconn._sslobj.get_unverified_chain()
2639 self.write(len(certs).to_bytes(1, "big") + b"\n")
2640 else:
2641 if (support.verbose and
2642 self.server.connectionchatty):
2643 ctype = (self.sslconn and "encrypted") or "unencrypted"
2644 sys.stdout.write(" server: read %r (%s), sending back %r (%s)...\n"
2645 % (msg, ctype, msg.lower(), ctype))
2646 self.write(msg.lower())
2647 except OSError as e:
2648 # handles SSLError and socket errors
2649 if isinstance(e, ConnectionError):
2650 # OpenSSL 1.1.1 sometimes raises
2651 # ConnectionResetError when connection is not
2652 # shut down gracefully.
2653 if self.server.chatty and support.verbose:
2654 print(f" Connection reset by peer: {self.addr}")
2655
2656 self.close()
2657 self.running = False
2658 return
2659 if self.server.chatty and support.verbose:
2660 handle_error("Test server failure:\n")
2661 try:
2662 self.write(b"ERROR\n")
2663 except OSError:
2664 pass
2665 self.close()
2666 self.running = False
2667
2668 def __init__(self, certificate=None, ssl_version=None,
2669 certreqs=None, cacerts=None,
2670 chatty=True, connectionchatty=False, starttls_server=False,
2671 alpn_protocols=None,
2672 ciphers=None, context=None):
2673 if context:
2674 self.context = context
2675 else:
2676 self.context = ssl.SSLContext(ssl_version
2677 if ssl_version is not None
2678 else ssl.PROTOCOL_TLS_SERVER)
2679 self.context.verify_mode = (certreqs if certreqs is not None
2680 else ssl.CERT_NONE)
2681 if cacerts:
2682 self.context.load_verify_locations(cacerts)
2683 if certificate:
2684 self.context.load_cert_chain(certificate)
2685 if alpn_protocols:
2686 self.context.set_alpn_protocols(alpn_protocols)
2687 if ciphers:
2688 self.context.set_ciphers(ciphers)
2689 self.chatty = chatty
2690 self.connectionchatty = connectionchatty
2691 self.starttls_server = starttls_server
2692 self.sock = socket.socket()
2693 self.port = socket_helper.bind_port(self.sock)
2694 self.flag = None
2695 self.active = False
2696 self.selected_alpn_protocols = []
2697 self.shared_ciphers = []
2698 self.conn_errors = []
2699 threading.Thread.__init__(self)
2700 self.daemon = True
2701 self._in_context = False
2702
2703 def __enter__(self):
2704 if self._in_context:
2705 raise ValueError('Re-entering ThreadedEchoServer context')
2706 self._in_context = True
2707 self.start(threading.Event())
2708 self.flag.wait()
2709 return self
2710
2711 def __exit__(self, *args):
2712 assert self._in_context
2713 self._in_context = False
2714 self.stop()
2715 self.join()
2716
2717 def start(self, flag=None):
2718 if not self._in_context:
2719 raise ValueError(
2720 'ThreadedEchoServer must be used as a context manager')
2721 self.flag = flag
2722 threading.Thread.start(self)
2723
2724 def run(self):
2725 if not self._in_context:
2726 raise ValueError(
2727 'ThreadedEchoServer must be used as a context manager')
2728 self.sock.settimeout(1.0)
2729 self.sock.listen(5)
2730 self.active = True
2731 if self.flag:
2732 # signal an event
2733 self.flag.set()
2734 while self.active:
2735 try:
2736 newconn, connaddr = self.sock.accept()
2737 if support.verbose and self.chatty:
2738 sys.stdout.write(' server: new connection from '
2739 + repr(connaddr) + '\n')
2740 handler = self.ConnectionHandler(self, newconn, connaddr)
2741 handler.start()
2742 handler.join()
2743 except TimeoutError as e:
2744 if support.verbose:
2745 sys.stdout.write(f' connection timeout {e!r}\n')
2746 except KeyboardInterrupt:
2747 self.stop()
2748 except BaseException as e:
2749 if support.verbose and self.chatty:
2750 sys.stdout.write(
2751 ' connection handling failed: ' + repr(e) + '\n')
2752
2753 self.close()
2754
2755 def close(self):
2756 if self.sock is not None:
2757 self.sock.close()
2758 self.sock = None
2759
2760 def stop(self):
2761 self.active = False
2762
2763 class AsyncoreEchoServer(threading.Thread):
2764
2765 # this one's based on asyncore.dispatcher
2766
2767 class EchoServer (asyncore.dispatcher):
2768
2769 class ConnectionHandler(asyncore.dispatcher_with_send):
2770
2771 def __init__(self, conn, certfile):
2772 self.socket = test_wrap_socket(conn, server_side=True,
2773 certfile=certfile,
2774 do_handshake_on_connect=False)
2775 asyncore.dispatcher_with_send.__init__(self, self.socket)
2776 self._ssl_accepting = True
2777 self._do_ssl_handshake()
2778
2779 def readable(self):
2780 if isinstance(self.socket, ssl.SSLSocket):
2781 while self.socket.pending() > 0:
2782 self.handle_read_event()
2783 return True
2784
2785 def _do_ssl_handshake(self):
2786 try:
2787 self.socket.do_handshake()
2788 except (ssl.SSLWantReadError, ssl.SSLWantWriteError):
2789 return
2790 except ssl.SSLEOFError:
2791 return self.handle_close()
2792 except ssl.SSLError:
2793 raise
2794 except OSError as err:
2795 if err.args[0] == errno.ECONNABORTED:
2796 return self.handle_close()
2797 else:
2798 self._ssl_accepting = False
2799
2800 def handle_read(self):
2801 if self._ssl_accepting:
2802 self._do_ssl_handshake()
2803 else:
2804 data = self.recv(1024)
2805 if support.verbose:
2806 sys.stdout.write(" server: read %s from client\n" % repr(data))
2807 if not data:
2808 self.close()
2809 else:
2810 self.send(data.lower())
2811
2812 def handle_close(self):
2813 self.close()
2814 if support.verbose:
2815 sys.stdout.write(" server: closed connection %s\n" % self.socket)
2816
2817 def handle_error(self):
2818 raise
2819
2820 def __init__(self, certfile):
2821 self.certfile = certfile
2822 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
2823 self.port = socket_helper.bind_port(sock, '')
2824 asyncore.dispatcher.__init__(self, sock)
2825 self.listen(5)
2826
2827 def handle_accepted(self, sock_obj, addr):
2828 if support.verbose:
2829 sys.stdout.write(" server: new connection from %s:%s\n" %addr)
2830 self.ConnectionHandler(sock_obj, self.certfile)
2831
2832 def handle_error(self):
2833 raise
2834
2835 def __init__(self, certfile):
2836 self.flag = None
2837 self.active = False
2838 self.server = self.EchoServer(certfile)
2839 self.port = self.server.port
2840 threading.Thread.__init__(self)
2841 self.daemon = True
2842
2843 def __str__(self):
2844 return "<%s %s>" % (self.__class__.__name__, self.server)
2845
2846 def __enter__(self):
2847 self.start(threading.Event())
2848 self.flag.wait()
2849 return self
2850
2851 def __exit__(self, *args):
2852 if support.verbose:
2853 sys.stdout.write(" cleanup: stopping server.\n")
2854 self.stop()
2855 if support.verbose:
2856 sys.stdout.write(" cleanup: joining server thread.\n")
2857 self.join()
2858 if support.verbose:
2859 sys.stdout.write(" cleanup: successfully joined.\n")
2860 # make sure that ConnectionHandler is removed from socket_map
2861 asyncore.close_all(ignore_all=True)
2862
2863 def start (self, flag=None):
2864 self.flag = flag
2865 threading.Thread.start(self)
2866
2867 def run(self):
2868 self.active = True
2869 if self.flag:
2870 self.flag.set()
2871 while self.active:
2872 try:
2873 asyncore.loop(1)
2874 except:
2875 pass
2876
2877 def stop(self):
2878 self.active = False
2879 self.server.close()
2880
2881 def server_params_test(client_context, server_context, indata=b"FOO\n",
2882 chatty=True, connectionchatty=False, sni_name=None,
2883 session=None):
2884 """
2885 Launch a server, connect a client to it and try various reads
2886 and writes.
2887 """
2888 stats = {}
2889 server = ThreadedEchoServer(context=server_context,
2890 chatty=chatty,
2891 connectionchatty=False)
2892 with server:
2893 with client_context.wrap_socket(socket.socket(),
2894 server_hostname=sni_name, session=session) as s:
2895 s.connect((HOST, server.port))
2896 for arg in [indata, bytearray(indata), memoryview(indata)]:
2897 if connectionchatty:
2898 if support.verbose:
2899 sys.stdout.write(
2900 " client: sending %r...\n" % indata)
2901 s.write(arg)
2902 outdata = s.read()
2903 if connectionchatty:
2904 if support.verbose:
2905 sys.stdout.write(" client: read %r\n" % outdata)
2906 if outdata != indata.lower():
2907 raise AssertionError(
2908 "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
2909 % (outdata[:20], len(outdata),
2910 indata[:20].lower(), len(indata)))
2911 s.write(b"over\n")
2912 if connectionchatty:
2913 if support.verbose:
2914 sys.stdout.write(" client: closing connection.\n")
2915 stats.update({
2916 'compression': s.compression(),
2917 'cipher': s.cipher(),
2918 'peercert': s.getpeercert(),
2919 'client_alpn_protocol': s.selected_alpn_protocol(),
2920 'version': s.version(),
2921 'session_reused': s.session_reused,
2922 'session': s.session,
2923 })
2924 s.close()
2925 stats['server_alpn_protocols'] = server.selected_alpn_protocols
2926 stats['server_shared_ciphers'] = server.shared_ciphers
2927 return stats
2928
2929 def try_protocol_combo(server_protocol, client_protocol, expect_success,
2930 certsreqs=None, server_options=0, client_options=0):
2931 """
2932 Try to SSL-connect using *client_protocol* to *server_protocol*.
2933 If *expect_success* is true, assert that the connection succeeds,
2934 if it's false, assert that the connection fails.
2935 Also, if *expect_success* is a string, assert that it is the protocol
2936 version actually used by the connection.
2937 """
2938 if certsreqs is None:
2939 certsreqs = ssl.CERT_NONE
2940 certtype = {
2941 ssl.CERT_NONE: "CERT_NONE",
2942 ssl.CERT_OPTIONAL: "CERT_OPTIONAL",
2943 ssl.CERT_REQUIRED: "CERT_REQUIRED",
2944 }[certsreqs]
2945 if support.verbose:
2946 formatstr = (expect_success and " %s->%s %s\n") or " {%s->%s} %s\n"
2947 sys.stdout.write(formatstr %
2948 (ssl.get_protocol_name(client_protocol),
2949 ssl.get_protocol_name(server_protocol),
2950 certtype))
2951
2952 with warnings_helper.check_warnings():
2953 # ignore Deprecation warnings
2954 client_context = ssl.SSLContext(client_protocol)
2955 client_context.options |= client_options
2956 server_context = ssl.SSLContext(server_protocol)
2957 server_context.options |= server_options
2958
2959 min_version = PROTOCOL_TO_TLS_VERSION.get(client_protocol, None)
2960 if (min_version is not None
2961 # SSLContext.minimum_version is only available on recent OpenSSL
2962 # (setter added in OpenSSL 1.1.0, getter added in OpenSSL 1.1.1)
2963 and hasattr(server_context, 'minimum_version')
2964 and server_protocol == ssl.PROTOCOL_TLS
2965 and server_context.minimum_version > min_version
2966 ):
2967 # If OpenSSL configuration is strict and requires more recent TLS
2968 # version, we have to change the minimum to test old TLS versions.
2969 with warnings_helper.check_warnings():
2970 server_context.minimum_version = min_version
2971
2972 # NOTE: we must enable "ALL" ciphers on the client, otherwise an
2973 # SSLv23 client will send an SSLv3 hello (rather than SSLv2)
2974 # starting from OpenSSL 1.0.0 (see issue #8322).
2975 if client_context.protocol == ssl.PROTOCOL_TLS:
2976 client_context.set_ciphers("ALL")
2977
2978 seclevel_workaround(server_context, client_context)
2979
2980 for ctx in (client_context, server_context):
2981 ctx.verify_mode = certsreqs
2982 ctx.load_cert_chain(SIGNED_CERTFILE)
2983 ctx.load_verify_locations(SIGNING_CA)
2984 try:
2985 stats = server_params_test(client_context, server_context,
2986 chatty=False, connectionchatty=False)
2987 # Protocol mismatch can result in either an SSLError, or a
2988 # "Connection reset by peer" error.
2989 except ssl.SSLError:
2990 if expect_success:
2991 raise
2992 except OSError as e:
2993 if expect_success or e.errno != errno.ECONNRESET:
2994 raise
2995 else:
2996 if not expect_success:
2997 raise AssertionError(
2998 "Client protocol %s succeeded with server protocol %s!"
2999 % (ssl.get_protocol_name(client_protocol),
3000 ssl.get_protocol_name(server_protocol)))
3001 elif (expect_success is not True
3002 and expect_success != stats['version']):
3003 raise AssertionError("version mismatch: expected %r, got %r"
3004 % (expect_success, stats['version']))
3005
3006
3007 def supports_kx_alias(ctx, aliases):
3008 for cipher in ctx.get_ciphers():
3009 for alias in aliases:
3010 if f"Kx={alias}" in cipher['description']:
3011 return True
3012 return False
3013
3014
3015 class ThreadedTests(unittest.TestCase):
3016
3017 @support.requires_resource('walltime')
3018 def test_echo(self):
3019 """Basic test of an SSL client connecting to a server"""
3020 if support.verbose:
3021 sys.stdout.write("\n")
3022
3023 client_context, server_context, hostname = testing_context()
3024
3025 with self.subTest(client=ssl.PROTOCOL_TLS_CLIENT, server=ssl.PROTOCOL_TLS_SERVER):
3026 server_params_test(client_context=client_context,
3027 server_context=server_context,
3028 chatty=True, connectionchatty=True,
3029 sni_name=hostname)
3030
3031 client_context.check_hostname = False
3032 with self.subTest(client=ssl.PROTOCOL_TLS_SERVER, server=ssl.PROTOCOL_TLS_CLIENT):
3033 with self.assertRaises(ssl.SSLError) as e:
3034 server_params_test(client_context=server_context,
3035 server_context=client_context,
3036 chatty=True, connectionchatty=True,
3037 sni_name=hostname)
3038 self.assertIn(
3039 'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
3040 str(e.exception)
3041 )
3042
3043 with self.subTest(client=ssl.PROTOCOL_TLS_SERVER, server=ssl.PROTOCOL_TLS_SERVER):
3044 with self.assertRaises(ssl.SSLError) as e:
3045 server_params_test(client_context=server_context,
3046 server_context=server_context,
3047 chatty=True, connectionchatty=True)
3048 self.assertIn(
3049 'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
3050 str(e.exception)
3051 )
3052
3053 with self.subTest(client=ssl.PROTOCOL_TLS_CLIENT, server=ssl.PROTOCOL_TLS_CLIENT):
3054 with self.assertRaises(ssl.SSLError) as e:
3055 server_params_test(client_context=server_context,
3056 server_context=client_context,
3057 chatty=True, connectionchatty=True)
3058 self.assertIn(
3059 'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
3060 str(e.exception))
3061
3062 @unittest.skipUnless(support.Py_GIL_DISABLED, "test is only useful if the GIL is disabled")
3063 def test_ssl_in_multiple_threads(self):
3064 # See GH-124984: OpenSSL is not thread safe.
3065 threads = []
3066
3067 warnings_filters = sys.flags.context_aware_warnings
3068 global USE_SAME_TEST_CONTEXT
3069 USE_SAME_TEST_CONTEXT = True
3070 try:
3071 for func in (
3072 self.test_echo,
3073 self.test_alpn_protocols,
3074 self.test_getpeercert,
3075 self.test_crl_check,
3076 functools.partial(
3077 self.test_check_hostname_idn,
3078 warnings_filters=warnings_filters,
3079 ),
3080 self.test_wrong_cert_tls12,
3081 self.test_wrong_cert_tls13,
3082 ):
3083 # Be careful with the number of threads here.
3084 # Too many can result in failing tests.
3085 for num in range(5):
3086 with self.subTest(func=func, num=num):
3087 threads.append(Thread(target=func))
3088
3089 with threading_helper.catch_threading_exception() as cm:
3090 for thread in threads:
3091 with self.subTest(thread=thread):
3092 thread.start()
3093
3094 for thread in threads:
3095 with self.subTest(thread=thread):
3096 thread.join()
3097 if cm.exc_value is not None:
3098 # Some threads can skip their test
3099 if not isinstance(cm.exc_value, unittest.SkipTest):
3100 raise cm.exc_value
3101 finally:
3102 USE_SAME_TEST_CONTEXT = False
3103
3104 def test_getpeercert(self):
3105 if support.verbose:
3106 sys.stdout.write("\n")
3107
3108 client_context, server_context, hostname = testing_context()
3109 server = ThreadedEchoServer(context=server_context, chatty=False)
3110 with server:
3111 with client_context.wrap_socket(socket.socket(),
3112 do_handshake_on_connect=False,
3113 server_hostname=hostname) as s:
3114 s.connect((HOST, server.port))
3115 # getpeercert() raise ValueError while the handshake isn't
3116 # done.
3117 with self.assertRaises(ValueError):
3118 s.getpeercert()
3119 s.do_handshake()
3120 cert = s.getpeercert()
3121 self.assertTrue(cert, "Can't get peer certificate.")
3122 cipher = s.cipher()
3123 if support.verbose:
3124 sys.stdout.write(pprint.pformat(cert) + '\n')
3125 sys.stdout.write("Connection cipher is " + str(cipher) + '.\n')
3126 if 'subject' not in cert:
3127 self.fail("No subject field in certificate: %s." %
3128 pprint.pformat(cert))
3129 if ((('organizationName', 'Python Software Foundation'),)
3130 not in cert['subject']):
3131 self.fail(
3132 "Missing or invalid 'organizationName' field in certificate subject; "
3133 "should be 'Python Software Foundation'.")
3134 self.assertIn('notBefore', cert)
3135 self.assertIn('notAfter', cert)
3136 before = ssl.cert_time_to_seconds(cert['notBefore'])
3137 after = ssl.cert_time_to_seconds(cert['notAfter'])
3138 self.assertLess(before, after)
3139
3140 def test_crl_check(self):
3141 if support.verbose:
3142 sys.stdout.write("\n")
3143
3144 client_context, server_context, hostname = testing_context()
3145
3146 tf = getattr(ssl, "VERIFY_X509_TRUSTED_FIRST", 0)
3147 self.assertEqual(client_context.verify_flags, ssl.VERIFY_DEFAULT | tf)
3148
3149 # VERIFY_DEFAULT should pass
3150 server = ThreadedEchoServer(context=server_context, chatty=True)
3151 with server:
3152 with client_context.wrap_socket(socket.socket(),
3153 server_hostname=hostname) as s:
3154 s.connect((HOST, server.port))
3155 cert = s.getpeercert()
3156 self.assertTrue(cert, "Can't get peer certificate.")
3157
3158 # VERIFY_CRL_CHECK_LEAF without a loaded CRL file fails
3159 client_context.verify_flags |= ssl.VERIFY_CRL_CHECK_LEAF
3160
3161 server = ThreadedEchoServer(context=server_context, chatty=True)
3162 # Allow for flexible libssl error messages.
3163 regex = re.compile(r"""(
3164 certificate verify failed # OpenSSL
3165 |
3166 CERTIFICATE_VERIFY_FAILED # AWS-LC
3167 )""", re.X)
3168 with server:
3169 with client_context.wrap_socket(socket.socket(),
3170 server_hostname=hostname) as s:
3171 with self.assertRaisesRegex(ssl.SSLError, regex):
3172 s.connect((HOST, server.port))
3173
3174 # now load a CRL file. The CRL file is signed by the CA.
3175 client_context.load_verify_locations(CRLFILE)
3176
3177 server = ThreadedEchoServer(context=server_context, chatty=True)
3178 with server:
3179 with client_context.wrap_socket(socket.socket(),
3180 server_hostname=hostname) as s:
3181 s.connect((HOST, server.port))
3182 cert = s.getpeercert()
3183 self.assertTrue(cert, "Can't get peer certificate.")
3184
3185 def test_check_hostname(self):
3186 if support.verbose:
3187 sys.stdout.write("\n")
3188
3189 client_context, server_context, hostname = testing_context()
3190
3191 # correct hostname should verify
3192 server = ThreadedEchoServer(context=server_context, chatty=True)
3193 with server:
3194 with client_context.wrap_socket(socket.socket(),
3195 server_hostname=hostname) as s:
3196 s.connect((HOST, server.port))
3197 cert = s.getpeercert()
3198 self.assertTrue(cert, "Can't get peer certificate.")
3199
3200 # incorrect hostname should raise an exception
3201 server = ThreadedEchoServer(context=server_context, chatty=True)
3202 # Allow for flexible libssl error messages.
3203 regex = re.compile(r"""(
3204 certificate verify failed # OpenSSL
3205 |
3206 CERTIFICATE_VERIFY_FAILED # AWS-LC
3207 )""", re.X)
3208 with server:
3209 with client_context.wrap_socket(socket.socket(),
3210 server_hostname="invalid") as s:
3211 with self.assertRaisesRegex(ssl.CertificateError, regex):
3212 s.connect((HOST, server.port))
3213
3214 # missing server_hostname arg should cause an exception, too
3215 server = ThreadedEchoServer(context=server_context, chatty=True)
3216 with server:
3217 with socket.socket() as s:
3218 with self.assertRaisesRegex(ValueError,
3219 "check_hostname requires server_hostname"):
3220 client_context.wrap_socket(s)
3221
3222 @unittest.skipUnless(
3223 ssl.HAS_NEVER_CHECK_COMMON_NAME, "test requires hostname_checks_common_name"
3224 )
3225 def test_hostname_checks_common_name(self):
3226 client_context, server_context, hostname = testing_context()
3227 assert client_context.hostname_checks_common_name
3228 client_context.hostname_checks_common_name = False
3229
3230 # default cert has a SAN
3231 server = ThreadedEchoServer(context=server_context, chatty=True)
3232 with server:
3233 with client_context.wrap_socket(socket.socket(),
3234 server_hostname=hostname) as s:
3235 s.connect((HOST, server.port))
3236
3237 client_context, server_context, hostname = testing_context(NOSANFILE)
3238 client_context.hostname_checks_common_name = False
3239 server = ThreadedEchoServer(context=server_context, chatty=True)
3240 with server:
3241 with client_context.wrap_socket(socket.socket(),
3242 server_hostname=hostname) as s:
3243 with self.assertRaises(ssl.SSLCertVerificationError):
3244 s.connect((HOST, server.port))
3245
3246 def test_ecc_cert(self):
3247 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
3248 client_context.load_verify_locations(SIGNING_CA)
3249 client_context.set_ciphers('ECDHE:ECDSA:!NULL:!aRSA')
3250 hostname = SIGNED_CERTFILE_ECC_HOSTNAME
3251
3252 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
3253 # load ECC cert
3254 server_context.load_cert_chain(SIGNED_CERTFILE_ECC)
3255
3256 # correct hostname should verify
3257 server = ThreadedEchoServer(context=server_context, chatty=True)
3258 with server:
3259 with client_context.wrap_socket(socket.socket(),
3260 server_hostname=hostname) as s:
3261 s.connect((HOST, server.port))
3262 cert = s.getpeercert()
3263 self.assertTrue(cert, "Can't get peer certificate.")
3264 cipher = s.cipher()[0].split('-')
3265 self.assertTrue(cipher[:2], ('ECDHE', 'ECDSA'))
3266
3267 @unittest.skipUnless(IS_OPENSSL_3_0_0,
3268 "test requires RFC 5280 check added in OpenSSL 3.0+")
3269 def test_verify_strict(self):
3270 # verification fails by default, since the server cert is non-conforming
3271 client_context = ssl.create_default_context()
3272 client_context.load_verify_locations(LEAF_MISSING_AKI_CA)
3273 hostname = LEAF_MISSING_AKI_CERTFILE_HOSTNAME
3274
3275 server_context = ssl.create_default_context(purpose=Purpose.CLIENT_AUTH)
3276 server_context.load_cert_chain(LEAF_MISSING_AKI_CERTFILE)
3277 server = ThreadedEchoServer(context=server_context, chatty=True)
3278 with server:
3279 with client_context.wrap_socket(socket.socket(),
3280 server_hostname=hostname) as s:
3281 with self.assertRaises(ssl.SSLError):
3282 s.connect((HOST, server.port))
3283
3284 # explicitly disabling VERIFY_X509_STRICT allows it to succeed
3285 client_context = ssl.create_default_context()
3286 client_context.load_verify_locations(LEAF_MISSING_AKI_CA)
3287 client_context.verify_flags &= ~ssl.VERIFY_X509_STRICT
3288
3289 server_context = ssl.create_default_context(purpose=Purpose.CLIENT_AUTH)
3290 server_context.load_cert_chain(LEAF_MISSING_AKI_CERTFILE)
3291 server = ThreadedEchoServer(context=server_context, chatty=True)
3292 with server:
3293 with client_context.wrap_socket(socket.socket(),
3294 server_hostname=hostname) as s:
3295 s.connect((HOST, server.port))
3296 cert = s.getpeercert()
3297 self.assertTrue(cert, "Can't get peer certificate.")
3298
3299 def test_dual_rsa_ecc(self):
3300 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
3301 client_context.load_verify_locations(SIGNING_CA)
3302 # TODO: fix TLSv1.3 once SSLContext can restrict signature
3303 # algorithms.
3304 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
3305 # only ECDSA certs
3306 client_context.set_ciphers('ECDHE:ECDSA:!NULL:!aRSA')
3307 hostname = SIGNED_CERTFILE_ECC_HOSTNAME
3308
3309 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
3310 # load ECC and RSA key/cert pairs
3311 server_context.load_cert_chain(SIGNED_CERTFILE_ECC)
3312 server_context.load_cert_chain(SIGNED_CERTFILE)
3313
3314 # correct hostname should verify
3315 server = ThreadedEchoServer(context=server_context, chatty=True)
3316 with server:
3317 with client_context.wrap_socket(socket.socket(),
3318 server_hostname=hostname) as s:
3319 s.connect((HOST, server.port))
3320 cert = s.getpeercert()
3321 self.assertTrue(cert, "Can't get peer certificate.")
3322 cipher = s.cipher()[0].split('-')
3323 self.assertTrue(cipher[:2], ('ECDHE', 'ECDSA'))
3324
3325 def test_check_hostname_idn(self, warnings_filters=True):
3326 if support.verbose:
3327 sys.stdout.write("\n")
3328
3329 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
3330 server_context.load_cert_chain(IDNSANSFILE)
3331
3332 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
3333 context.verify_mode = ssl.CERT_REQUIRED
3334 context.check_hostname = True
3335 context.load_verify_locations(SIGNING_CA)
3336
3337 # correct hostname should verify, when specified in several
3338 # different ways
3339 idn_hostnames = [
3340 ('könig.idn.pythontest.net',
3341 'xn--knig-5qa.idn.pythontest.net'),
3342 ('xn--knig-5qa.idn.pythontest.net',
3343 'xn--knig-5qa.idn.pythontest.net'),
3344 (b'xn--knig-5qa.idn.pythontest.net',
3345 'xn--knig-5qa.idn.pythontest.net'),
3346
3347 ('königsgäßchen.idna2003.pythontest.net',
3348 'xn--knigsgsschen-lcb0w.idna2003.pythontest.net'),
3349 ('xn--knigsgsschen-lcb0w.idna2003.pythontest.net',
3350 'xn--knigsgsschen-lcb0w.idna2003.pythontest.net'),
3351 (b'xn--knigsgsschen-lcb0w.idna2003.pythontest.net',
3352 'xn--knigsgsschen-lcb0w.idna2003.pythontest.net'),
3353
3354 # ('königsgäßchen.idna2008.pythontest.net',
3355 # 'xn--knigsgchen-b4a3dun.idna2008.pythontest.net'),
3356 ('xn--knigsgchen-b4a3dun.idna2008.pythontest.net',
3357 'xn--knigsgchen-b4a3dun.idna2008.pythontest.net'),
3358 (b'xn--knigsgchen-b4a3dun.idna2008.pythontest.net',
3359 'xn--knigsgchen-b4a3dun.idna2008.pythontest.net'),
3360
3361 ]
3362 for server_hostname, expected_hostname in idn_hostnames:
3363 server = ThreadedEchoServer(context=server_context, chatty=True)
3364 with server:
3365 with context.wrap_socket(socket.socket(),
3366 server_hostname=server_hostname) as s:
3367 self.assertEqual(s.server_hostname, expected_hostname)
3368 s.connect((HOST, server.port))
3369 cert = s.getpeercert()
3370 self.assertEqual(s.server_hostname, expected_hostname)
3371 self.assertTrue(cert, "Can't get peer certificate.")
3372
3373 # incorrect hostname should raise an exception
3374 server = ThreadedEchoServer(context=server_context, chatty=True)
3375 with server:
3376 with context.wrap_socket(socket.socket(),
3377 server_hostname="python.example.org") as s:
3378 with self.assertRaises(ssl.CertificateError):
3379 s.connect((HOST, server.port))
3380 with (
3381 ThreadedEchoServer(context=server_context, chatty=True) as server,
3382 (
3383 warnings_helper.check_no_resource_warning(self)
3384 if warnings_filters
3385 else nullcontext()
3386 ),
3387 self.assertRaises(UnicodeError),
3388 ):
3389 context.wrap_socket(socket.socket(), server_hostname='.pythontest.net')
3390
3391 with (
3392 ThreadedEchoServer(context=server_context, chatty=True) as server,
3393 (
3394 warnings_helper.check_no_resource_warning(self)
3395 if warnings_filters
3396 else nullcontext()
3397 ),
3398 self.assertRaises(UnicodeDecodeError),
3399 ):
3400 context.wrap_socket(
3401 socket.socket(),
3402 server_hostname=b'k\xf6nig.idn.pythontest.net',
3403 )
3404
3405 def test_wrong_cert_tls12(self):
3406 """Connecting when the server rejects the client's certificate
3407
3408 Launch a server with CERT_REQUIRED, and check that trying to
3409 connect to it with a wrong client certificate fails.
3410 """
3411 client_context, server_context, hostname = testing_context()
3412 # load client cert that is not signed by trusted CA
3413 client_context.load_cert_chain(CERTFILE)
3414 # require TLS client authentication
3415 server_context.verify_mode = ssl.CERT_REQUIRED
3416 # TLS 1.3 has different handshake
3417 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
3418
3419 server = ThreadedEchoServer(
3420 context=server_context, chatty=True, connectionchatty=True,
3421 )
3422
3423 with server, \
3424 client_context.wrap_socket(socket.socket(),
3425 server_hostname=hostname) as s:
3426 try:
3427 # Expect either an SSL error about the server rejecting
3428 # the connection, or a low-level connection reset (which
3429 # sometimes happens on Windows)
3430 s.connect((HOST, server.port))
3431 except ssl.SSLError as e:
3432 if support.verbose:
3433 sys.stdout.write("\nSSLError is %r\n" % e)
3434 except OSError as e:
3435 if e.errno != errno.ECONNRESET:
3436 raise
3437 if support.verbose:
3438 sys.stdout.write("\nsocket.error is %r\n" % e)
3439 else:
3440 self.fail("Use of invalid cert should have failed!")
3441
3442 @requires_tls_version('TLSv1_3')
3443 def test_wrong_cert_tls13(self):
3444 client_context, server_context, hostname = testing_context()
3445 # load client cert that is not signed by trusted CA
3446 client_context.load_cert_chain(CERTFILE)
3447 server_context.verify_mode = ssl.CERT_REQUIRED
3448 server_context.minimum_version = ssl.TLSVersion.TLSv1_3
3449 client_context.minimum_version = ssl.TLSVersion.TLSv1_3
3450
3451 server = ThreadedEchoServer(
3452 context=server_context, chatty=True, connectionchatty=True,
3453 )
3454 with server, \
3455 client_context.wrap_socket(socket.socket(),
3456 server_hostname=hostname,
3457 suppress_ragged_eofs=False) as s:
3458 s.connect((HOST, server.port))
3459 with self.assertRaisesRegex(
3460 OSError,
3461 'alert unknown ca|EOF occurred|TLSV1_ALERT_UNKNOWN_CA|'
3462 'closed by the remote host|Connection reset by peer|'
3463 'Broken pipe'
3464 ):
3465 # TLS 1.3 perform client cert exchange after handshake
3466 s.write(b'data')
3467 s.read(1000)
3468 s.write(b'should have failed already')
3469 s.read(1000)
3470
3471 def test_rude_shutdown(self):
3472 """A brutal shutdown of an SSL server should raise an OSError
3473 in the client when attempting handshake.
3474 """
3475 listener_ready = threading.Event()
3476 listener_gone = threading.Event()
3477
3478 s = socket.socket()
3479 port = socket_helper.bind_port(s, HOST)
3480
3481 # `listener` runs in a thread. It sits in an accept() until
3482 # the main thread connects. Then it rudely closes the socket,
3483 # and sets Event `listener_gone` to let the main thread know
3484 # the socket is gone.
3485 def listener():
3486 s.listen()
3487 listener_ready.set()
3488 newsock, addr = s.accept()
3489 newsock.close()
3490 s.close()
3491 listener_gone.set()
3492
3493 def connector():
3494 listener_ready.wait()
3495 with socket.socket() as c:
3496 c.connect((HOST, port))
3497 listener_gone.wait()
3498 try:
3499 ssl_sock = test_wrap_socket(c)
3500 except OSError:
3501 pass
3502 else:
3503 self.fail('connecting to closed SSL socket should have failed')
3504
3505 t = threading.Thread(target=listener)
3506 t.start()
3507 try:
3508 connector()
3509 finally:
3510 t.join()
3511
3512 def test_ssl_cert_verify_error(self):
3513 if support.verbose:
3514 sys.stdout.write("\n")
3515
3516 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
3517 server_context.load_cert_chain(SIGNED_CERTFILE)
3518
3519 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
3520
3521 server = ThreadedEchoServer(context=server_context, chatty=True)
3522 with server:
3523 with context.wrap_socket(socket.socket(),
3524 server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
3525 try:
3526 s.connect((HOST, server.port))
3527 self.fail("Expected connection failure")
3528 except ssl.SSLError as e:
3529 msg = 'unable to get local issuer certificate'
3530 self.assertIsInstance(e, ssl.SSLCertVerificationError)
3531 self.assertEqual(e.verify_code, 20)
3532 self.assertEqual(e.verify_message, msg)
3533 # Allow for flexible libssl error messages.
3534 regex = f"({msg}|CERTIFICATE_VERIFY_FAILED)"
3535 self.assertRegex(repr(e), regex)
3536 regex = re.compile(r"""(
3537 certificate verify failed # OpenSSL
3538 |
3539 CERTIFICATE_VERIFY_FAILED # AWS-LC
3540 )""", re.X)
3541 self.assertRegex(repr(e), regex)
3542
3543 def test_PROTOCOL_TLS(self):
3544 """Connecting to an SSLv23 server with various client options"""
3545 if support.verbose:
3546 sys.stdout.write("\n")
3547 if has_tls_version('SSLv3'):
3548 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False)
3549 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True)
3550 if has_tls_version('TLSv1'):
3551 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, 'TLSv1')
3552
3553 if has_tls_version('SSLv3'):
3554 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False, ssl.CERT_OPTIONAL)
3555 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True, ssl.CERT_OPTIONAL)
3556 if has_tls_version('TLSv1'):
3557 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_OPTIONAL)
3558
3559 if has_tls_version('SSLv3'):
3560 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False, ssl.CERT_REQUIRED)
3561 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True, ssl.CERT_REQUIRED)
3562 if has_tls_version('TLSv1'):
3563 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_REQUIRED)
3564
3565 # Server with specific SSL options
3566 if has_tls_version('SSLv3'):
3567 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False,
3568 server_options=ssl.OP_NO_SSLv3)
3569 # Will choose TLSv1
3570 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True,
3571 server_options=ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3)
3572 if has_tls_version('TLSv1'):
3573 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, False,
3574 server_options=ssl.OP_NO_TLSv1)
3575
3576 @requires_tls_version('SSLv3')
3577 def test_protocol_sslv3(self):
3578 """Connecting to an SSLv3 server with various client options"""
3579 if support.verbose:
3580 sys.stdout.write("\n")
3581 try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, 'SSLv3')
3582 try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, 'SSLv3', ssl.CERT_OPTIONAL)
3583 try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, 'SSLv3', ssl.CERT_REQUIRED)
3584 try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_TLS, False,
3585 client_options=ssl.OP_NO_SSLv3)
3586 try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_TLSv1, False)
3587
3588 @requires_tls_version('TLSv1')
3589 def test_protocol_tlsv1(self):
3590 """Connecting to a TLSv1 server with various client options"""
3591 if support.verbose:
3592 sys.stdout.write("\n")
3593 try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, 'TLSv1')
3594 try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_OPTIONAL)
3595 try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_REQUIRED)
3596 if has_tls_version('SSLv3'):
3597 try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_SSLv3, False)
3598 try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLS, False,
3599 client_options=ssl.OP_NO_TLSv1)
3600
3601 @requires_tls_version('TLSv1_1')
3602 def test_protocol_tlsv1_1(self):
3603 """Connecting to a TLSv1.1 server with various client options.
3604 Testing against older TLS versions."""
3605 if support.verbose:
3606 sys.stdout.write("\n")
3607 try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLSv1_1, 'TLSv1.1')
3608 if has_tls_version('SSLv3'):
3609 try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_SSLv3, False)
3610 try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLS, False,
3611 client_options=ssl.OP_NO_TLSv1_1)
3612
3613 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1_1, 'TLSv1.1')
3614 try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLSv1_2, False)
3615 try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_1, False)
3616
3617 @requires_tls_version('TLSv1_2')
3618 def test_protocol_tlsv1_2(self):
3619 """Connecting to a TLSv1.2 server with various client options.
3620 Testing against older TLS versions."""
3621 if support.verbose:
3622 sys.stdout.write("\n")
3623 try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_2, 'TLSv1.2',
3624 server_options=ssl.OP_NO_SSLv3|ssl.OP_NO_SSLv2,
3625 client_options=ssl.OP_NO_SSLv3|ssl.OP_NO_SSLv2,)
3626 if has_tls_version('SSLv3'):
3627 try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_SSLv3, False)
3628 try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLS, False,
3629 client_options=ssl.OP_NO_TLSv1_2)
3630
3631 try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1_2, 'TLSv1.2')
3632 if has_tls_protocol(ssl.PROTOCOL_TLSv1):
3633 try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1, False)
3634 try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1_2, False)
3635 if has_tls_protocol(ssl.PROTOCOL_TLSv1_1):
3636 try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_1, False)
3637 try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLSv1_2, False)
3638
3639 def test_starttls(self):
3640 """Switching from clear text to encrypted and back again."""
3641 msgs = (b"msg 1", b"MSG 2", b"STARTTLS", b"MSG 3", b"msg 4", b"ENDTLS", b"msg 5", b"msg 6")
3642
3643 server = ThreadedEchoServer(CERTFILE,
3644 starttls_server=True,
3645 chatty=True,
3646 connectionchatty=True)
3647 wrapped = False
3648 with server:
3649 s = socket.socket()
3650 s.setblocking(True)
3651 s.connect((HOST, server.port))
3652 if support.verbose:
3653 sys.stdout.write("\n")
3654 for indata in msgs:
3655 if support.verbose:
3656 sys.stdout.write(
3657 " client: sending %r...\n" % indata)
3658 if wrapped:
3659 conn.write(indata)
3660 outdata = conn.read()
3661 else:
3662 s.send(indata)
3663 outdata = s.recv(1024)
3664 msg = outdata.strip().lower()
3665 if indata == b"STARTTLS" and msg.startswith(b"ok"):
3666 # STARTTLS ok, switch to secure mode
3667 if support.verbose:
3668 sys.stdout.write(
3669 " client: read %r from server, starting TLS...\n"
3670 % msg)
3671 conn = test_wrap_socket(s)
3672 wrapped = True
3673 elif indata == b"ENDTLS" and msg.startswith(b"ok"):
3674 # ENDTLS ok, switch back to clear text
3675 if support.verbose:
3676 sys.stdout.write(
3677 " client: read %r from server, ending TLS...\n"
3678 % msg)
3679 s = conn.unwrap()
3680 wrapped = False
3681 else:
3682 if support.verbose:
3683 sys.stdout.write(
3684 " client: read %r from server\n" % msg)
3685 if support.verbose:
3686 sys.stdout.write(" client: closing connection.\n")
3687 if wrapped:
3688 conn.write(b"over\n")
3689 else:
3690 s.send(b"over\n")
3691 if wrapped:
3692 conn.close()
3693 else:
3694 s.close()
3695
3696 def test_socketserver(self):
3697 """Using socketserver to create and manage SSL connections."""
3698 server = make_https_server(self, certfile=SIGNED_CERTFILE)
3699 # try to connect
3700 if support.verbose:
3701 sys.stdout.write('\n')
3702 # Get this test file itself:
3703 with open(__file__, 'rb') as f:
3704 d1 = f.read()
3705 d2 = ''
3706 # now fetch the same data from the HTTPS server
3707 url = f'https://localhost:{server.port}/test_ssl.py'
3708 context = ssl.create_default_context(cafile=SIGNING_CA)
3709 f = urllib.request.urlopen(url, context=context)
3710 try:
3711 dlen = f.info().get("content-length")
3712 if dlen and (int(dlen) > 0):
3713 d2 = f.read(int(dlen))
3714 if support.verbose:
3715 sys.stdout.write(
3716 " client: read %d bytes from remote server '%s'\n"
3717 % (len(d2), server))
3718 finally:
3719 f.close()
3720 self.assertEqual(d1, d2)
3721
3722 def test_asyncore_server(self):
3723 """Check the example asyncore integration."""
3724 if support.verbose:
3725 sys.stdout.write("\n")
3726
3727 indata = b"FOO\n"
3728 server = AsyncoreEchoServer(CERTFILE)
3729 with server:
3730 s = test_wrap_socket(socket.socket())
3731 s.connect(('127.0.0.1', server.port))
3732 if support.verbose:
3733 sys.stdout.write(
3734 " client: sending %r...\n" % indata)
3735 s.write(indata)
3736 outdata = s.read()
3737 if support.verbose:
3738 sys.stdout.write(" client: read %r\n" % outdata)
3739 if outdata != indata.lower():
3740 self.fail(
3741 "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
3742 % (outdata[:20], len(outdata),
3743 indata[:20].lower(), len(indata)))
3744 s.write(b"over\n")
3745 if support.verbose:
3746 sys.stdout.write(" client: closing connection.\n")
3747 s.close()
3748 if support.verbose:
3749 sys.stdout.write(" client: connection closed.\n")
3750
3751 def test_recv_send(self):
3752 """Test recv(), send() and friends."""
3753 if support.verbose:
3754 sys.stdout.write("\n")
3755
3756 server = ThreadedEchoServer(CERTFILE,
3757 certreqs=ssl.CERT_NONE,
3758 ssl_version=ssl.PROTOCOL_TLS_SERVER,
3759 cacerts=CERTFILE,
3760 chatty=True,
3761 connectionchatty=False)
3762 with server:
3763 s = test_wrap_socket(socket.socket(),
3764 server_side=False,
3765 certfile=CERTFILE,
3766 ca_certs=CERTFILE,
3767 cert_reqs=ssl.CERT_NONE)
3768 s.connect((HOST, server.port))
3769 # helper methods for standardising recv* method signatures
3770 def _recv_into():
3771 b = bytearray(b"\0"*100)
3772 count = s.recv_into(b)
3773 return b[:count]
3774
3775 def _recvfrom_into():
3776 b = bytearray(b"\0"*100)
3777 count, addr = s.recvfrom_into(b)
3778 return b[:count]
3779
3780 # (name, method, expect success?, *args, return value func)
3781 send_methods = [
3782 ('send', s.send, True, [], len),
3783 ('sendto', s.sendto, False, ["some.address"], len),
3784 ('sendall', s.sendall, True, [], lambda x: None),
3785 ]
3786 # (name, method, whether to expect success, *args)
3787 recv_methods = [
3788 ('recv', s.recv, True, []),
3789 ('recvfrom', s.recvfrom, False, ["some.address"]),
3790 ('recv_into', _recv_into, True, []),
3791 ('recvfrom_into', _recvfrom_into, False, []),
3792 ]
3793 data_prefix = "PREFIX_"
3794
3795 for (meth_name, send_meth, expect_success, args,
3796 ret_val_meth) in send_methods:
3797 indata = (data_prefix + meth_name).encode('ascii')
3798 try:
3799 ret = send_meth(indata, *args)
3800 msg = "sending with {}".format(meth_name)
3801 self.assertEqual(ret, ret_val_meth(indata), msg=msg)
3802 outdata = s.read()
3803 if outdata != indata.lower():
3804 self.fail(
3805 "While sending with <<{name:s}>> bad data "
3806 "<<{outdata:r}>> ({nout:d}) received; "
3807 "expected <<{indata:r}>> ({nin:d})\n".format(
3808 name=meth_name, outdata=outdata[:20],
3809 nout=len(outdata),
3810 indata=indata[:20], nin=len(indata)
3811 )
3812 )
3813 except ValueError as e:
3814 if expect_success:
3815 self.fail(
3816 "Failed to send with method <<{name:s}>>; "
3817 "expected to succeed.\n".format(name=meth_name)
3818 )
3819 if not str(e).startswith(meth_name):
3820 self.fail(
3821 "Method <<{name:s}>> failed with unexpected "
3822 "exception message: {exp:s}\n".format(
3823 name=meth_name, exp=e
3824 )
3825 )
3826
3827 for meth_name, recv_meth, expect_success, args in recv_methods:
3828 indata = (data_prefix + meth_name).encode('ascii')
3829 try:
3830 s.send(indata)
3831 outdata = recv_meth(*args)
3832 if outdata != indata.lower():
3833 self.fail(
3834 "While receiving with <<{name:s}>> bad data "
3835 "<<{outdata:r}>> ({nout:d}) received; "
3836 "expected <<{indata:r}>> ({nin:d})\n".format(
3837 name=meth_name, outdata=outdata[:20],
3838 nout=len(outdata),
3839 indata=indata[:20], nin=len(indata)
3840 )
3841 )
3842 except ValueError as e:
3843 if expect_success:
3844 self.fail(
3845 "Failed to receive with method <<{name:s}>>; "
3846 "expected to succeed.\n".format(name=meth_name)
3847 )
3848 if not str(e).startswith(meth_name):
3849 self.fail(
3850 "Method <<{name:s}>> failed with unexpected "
3851 "exception message: {exp:s}\n".format(
3852 name=meth_name, exp=e
3853 )
3854 )
3855 # consume data
3856 s.read()
3857
3858 # read(-1, buffer) is supported, even though read(-1) is not
3859 data = b"data"
3860 s.send(data)
3861 buffer = bytearray(len(data))
3862 self.assertEqual(s.read(-1, buffer), len(data))
3863 self.assertEqual(buffer, data)
3864
3865 # sendall accepts bytes-like objects
3866 if ctypes is not None:
3867 ubyte = ctypes.c_ubyte * len(data)
3868 byteslike = ubyte.from_buffer_copy(data)
3869 s.sendall(byteslike)
3870 self.assertEqual(s.read(), data)
3871
3872 # Make sure sendmsg et al are disallowed to avoid
3873 # inadvertent disclosure of data and/or corruption
3874 # of the encrypted data stream
3875 self.assertRaises(NotImplementedError, s.dup)
3876 self.assertRaises(NotImplementedError, s.sendmsg, [b"data"])
3877 self.assertRaises(NotImplementedError, s.recvmsg, 100)
3878 self.assertRaises(NotImplementedError,
3879 s.recvmsg_into, [bytearray(100)])
3880 s.write(b"over\n")
3881
3882 self.assertRaises(ValueError, s.recv, -1)
3883 self.assertRaises(ValueError, s.read, -1)
3884
3885 s.close()
3886
3887 def test_recv_zero(self):
3888 server = ThreadedEchoServer(CERTFILE)
3889 self.enterContext(server)
3890 s = socket.create_connection((HOST, server.port))
3891 self.addCleanup(s.close)
3892 s = test_wrap_socket(s, suppress_ragged_eofs=False)
3893 self.addCleanup(s.close)
3894
3895 # recv/read(0) should return no data
3896 s.send(b"data")
3897 self.assertEqual(s.recv(0), b"")
3898 self.assertEqual(s.read(0), b"")
3899 self.assertEqual(s.read(), b"data")
3900
3901 # Should not block if the other end sends no data
3902 s.setblocking(False)
3903 self.assertEqual(s.recv(0), b"")
3904 self.assertEqual(s.recv_into(bytearray()), 0)
3905
3906 def test_recv_into_buffer_protocol_len(self):
3907 server = ThreadedEchoServer(CERTFILE)
3908 self.enterContext(server)
3909 s = socket.create_connection((HOST, server.port))
3910 self.addCleanup(s.close)
3911 s = test_wrap_socket(s, suppress_ragged_eofs=False)
3912 self.addCleanup(s.close)
3913
3914 s.send(b"data")
3915 buf = array.array('I', [0, 0])
3916 self.assertEqual(s.recv_into(buf), 4)
3917 self.assertEqual(bytes(buf)[:4], b"data")
3918
3919 class B(bytearray):
3920 def __len__(self):
3921 1/0
3922 s.send(b"data")
3923 buf = B(6)
3924 self.assertEqual(s.recv_into(buf), 4)
3925 self.assertEqual(bytes(buf), b"data\0\0")
3926
3927 def test_nonblocking_send(self):
3928 server = ThreadedEchoServer(CERTFILE,
3929 certreqs=ssl.CERT_NONE,
3930 ssl_version=ssl.PROTOCOL_TLS_SERVER,
3931 cacerts=CERTFILE,
3932 chatty=True,
3933 connectionchatty=False)
3934 with server:
3935 s = test_wrap_socket(socket.socket(),
3936 server_side=False,
3937 certfile=CERTFILE,
3938 ca_certs=CERTFILE,
3939 cert_reqs=ssl.CERT_NONE)
3940 s.connect((HOST, server.port))
3941 s.setblocking(False)
3942
3943 # If we keep sending data, at some point the buffers
3944 # will be full and the call will block
3945 buf = bytearray(8192)
3946 def fill_buffer():
3947 while True:
3948 s.send(buf)
3949 self.assertRaises((ssl.SSLWantWriteError,
3950 ssl.SSLWantReadError), fill_buffer)
3951
3952 # Now read all the output and discard it
3953 s.setblocking(True)
3954 s.close()
3955
3956 def test_handshake_timeout(self):
3957 # Issue #5103: SSL handshake must respect the socket timeout
3958 server = socket.socket(socket.AF_INET)
3959 host = "127.0.0.1"
3960 port = socket_helper.bind_port(server)
3961 started = threading.Event()
3962 finish = False
3963
3964 def serve():
3965 server.listen()
3966 started.set()
3967 conns = []
3968 while not finish:
3969 r, w, e = select.select([server], [], [], 0.1)
3970 if server in r:
3971 # Let the socket hang around rather than having
3972 # it closed by garbage collection.
3973 conns.append(server.accept()[0])
3974 for sock in conns:
3975 sock.close()
3976
3977 t = threading.Thread(target=serve)
3978 t.start()
3979 started.wait()
3980
3981 try:
3982 try:
3983 c = socket.socket(socket.AF_INET)
3984 c.settimeout(0.2)
3985 c.connect((host, port))
3986 # Will attempt handshake and time out
3987 self.assertRaisesRegex(TimeoutError, "timed out",
3988 test_wrap_socket, c)
3989 finally:
3990 c.close()
3991 try:
3992 c = socket.socket(socket.AF_INET)
3993 c = test_wrap_socket(c)
3994 c.settimeout(0.2)
3995 # Will attempt handshake and time out
3996 self.assertRaisesRegex(TimeoutError, "timed out",
3997 c.connect, (host, port))
3998 finally:
3999 c.close()
4000 finally:
4001 finish = True
4002 t.join()
4003 server.close()
4004
4005 def test_server_accept(self):
4006 # Issue #16357: accept() on a SSLSocket created through
4007 # SSLContext.wrap_socket().
4008 client_ctx, server_ctx, hostname = testing_context()
4009 server = socket.socket(socket.AF_INET)
4010 host = "127.0.0.1"
4011 port = socket_helper.bind_port(server)
4012 server = server_ctx.wrap_socket(server, server_side=True)
4013 self.assertTrue(server.server_side)
4014
4015 evt = threading.Event()
4016 remote = None
4017 peer = None
4018 def serve():
4019 nonlocal remote, peer
4020 server.listen()
4021 # Block on the accept and wait on the connection to close.
4022 evt.set()
4023 remote, peer = server.accept()
4024 remote.send(remote.recv(4))
4025
4026 t = threading.Thread(target=serve)
4027 t.start()
4028 # Client wait until server setup and perform a connect.
4029 evt.wait()
4030 client = client_ctx.wrap_socket(
4031 socket.socket(), server_hostname=hostname
4032 )
4033 client.connect((hostname, port))
4034 client.send(b'data')
4035 client.recv()
4036 client_addr = client.getsockname()
4037 client.close()
4038 t.join()
4039 remote.close()
4040 server.close()
4041 # Sanity checks.
4042 self.assertIsInstance(remote, ssl.SSLSocket)
4043 self.assertEqual(peer, client_addr)
4044
4045 def test_getpeercert_enotconn(self):
4046 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4047 context.check_hostname = False
4048 with context.wrap_socket(socket.socket()) as sock:
4049 with self.assertRaises(OSError) as cm:
4050 sock.getpeercert()
4051 self.assertEqual(cm.exception.errno, errno.ENOTCONN)
4052
4053 def test_do_handshake_enotconn(self):
4054 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4055 context.check_hostname = False
4056 with context.wrap_socket(socket.socket()) as sock:
4057 with self.assertRaises(OSError) as cm:
4058 sock.do_handshake()
4059 self.assertEqual(cm.exception.errno, errno.ENOTCONN)
4060
4061 def test_no_shared_ciphers(self):
4062 client_context, server_context, hostname = testing_context()
4063 # OpenSSL enables all TLS 1.3 ciphers, enforce TLS 1.2 for test
4064 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4065 # Force different suites on client and server
4066 client_context.set_ciphers("AES128")
4067 server_context.set_ciphers("AES256")
4068 with ThreadedEchoServer(context=server_context) as server:
4069 with client_context.wrap_socket(socket.socket(),
4070 server_hostname=hostname) as s:
4071 with self.assertRaises(OSError):
4072 s.connect((HOST, server.port))
4073 self.assertIn("NO_SHARED_CIPHER", server.conn_errors[0])
4074
4075 def test_version_basic(self):
4076 """
4077 Basic tests for SSLSocket.version().
4078 More tests are done in the test_protocol_*() methods.
4079 """
4080 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4081 context.check_hostname = False
4082 context.verify_mode = ssl.CERT_NONE
4083 with ThreadedEchoServer(CERTFILE,
4084 ssl_version=ssl.PROTOCOL_TLS_SERVER,
4085 chatty=False) as server:
4086 with context.wrap_socket(socket.socket()) as s:
4087 self.assertIs(s.version(), None)
4088 self.assertIs(s._sslobj, None)
4089 s.connect((HOST, server.port))
4090 self.assertEqual(s.version(), 'TLSv1.3')
4091 self.assertIs(s._sslobj, None)
4092 self.assertIs(s.version(), None)
4093
4094 @requires_tls_version('TLSv1_3')
4095 def test_tls1_3(self):
4096 client_context, server_context, hostname = testing_context()
4097 client_context.minimum_version = ssl.TLSVersion.TLSv1_3
4098 with ThreadedEchoServer(context=server_context) as server:
4099 with client_context.wrap_socket(socket.socket(),
4100 server_hostname=hostname) as s:
4101 s.connect((HOST, server.port))
4102 self.assertIn(s.cipher()[0], {
4103 'TLS_AES_256_GCM_SHA384',
4104 'TLS_CHACHA20_POLY1305_SHA256',
4105 'TLS_AES_128_GCM_SHA256',
4106 })
4107 self.assertEqual(s.version(), 'TLSv1.3')
4108
4109 @requires_tls_version('TLSv1_2')
4110 @requires_tls_version('TLSv1')
4111 @ignore_deprecation
4112 def test_min_max_version_tlsv1_2(self):
4113 client_context, server_context, hostname = testing_context()
4114 # client TLSv1.0 to 1.2
4115 client_context.minimum_version = ssl.TLSVersion.TLSv1
4116 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4117 # server only TLSv1.2
4118 server_context.minimum_version = ssl.TLSVersion.TLSv1_2
4119 server_context.maximum_version = ssl.TLSVersion.TLSv1_2
4120
4121 with ThreadedEchoServer(context=server_context) as server:
4122 with client_context.wrap_socket(socket.socket(),
4123 server_hostname=hostname) as s:
4124 s.connect((HOST, server.port))
4125 self.assertEqual(s.version(), 'TLSv1.2')
4126
4127 @requires_tls_version('TLSv1_1')
4128 @ignore_deprecation
4129 def test_min_max_version_tlsv1_1(self):
4130 client_context, server_context, hostname = testing_context()
4131 # client 1.0 to 1.2, server 1.0 to 1.1
4132 client_context.minimum_version = ssl.TLSVersion.TLSv1
4133 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4134 server_context.minimum_version = ssl.TLSVersion.TLSv1
4135 server_context.maximum_version = ssl.TLSVersion.TLSv1_1
4136 seclevel_workaround(client_context, server_context)
4137
4138 with ThreadedEchoServer(context=server_context) as server:
4139 with client_context.wrap_socket(socket.socket(),
4140 server_hostname=hostname) as s:
4141 s.connect((HOST, server.port))
4142 self.assertEqual(s.version(), 'TLSv1.1')
4143
4144 @requires_tls_version('TLSv1_2')
4145 @requires_tls_version('TLSv1')
4146 @ignore_deprecation
4147 def test_min_max_version_mismatch(self):
4148 client_context, server_context, hostname = testing_context()
4149 # client 1.0, server 1.2 (mismatch)
4150 server_context.maximum_version = ssl.TLSVersion.TLSv1_2
4151 server_context.minimum_version = ssl.TLSVersion.TLSv1_2
4152 client_context.maximum_version = ssl.TLSVersion.TLSv1
4153 client_context.minimum_version = ssl.TLSVersion.TLSv1
4154 seclevel_workaround(client_context, server_context)
4155
4156 with ThreadedEchoServer(context=server_context) as server:
4157 with client_context.wrap_socket(socket.socket(),
4158 server_hostname=hostname) as s:
4159 with self.assertRaises(ssl.SSLError) as e:
4160 s.connect((HOST, server.port))
4161 self.assertRegex(str(e.exception), "(alert|ALERT)")
4162
4163 @requires_tls_version('SSLv3')
4164 def test_min_max_version_sslv3(self):
4165 client_context, server_context, hostname = testing_context()
4166 server_context.minimum_version = ssl.TLSVersion.SSLv3
4167 client_context.minimum_version = ssl.TLSVersion.SSLv3
4168 client_context.maximum_version = ssl.TLSVersion.SSLv3
4169 seclevel_workaround(client_context, server_context)
4170
4171 with ThreadedEchoServer(context=server_context) as server:
4172 with client_context.wrap_socket(socket.socket(),
4173 server_hostname=hostname) as s:
4174 s.connect((HOST, server.port))
4175 self.assertEqual(s.version(), 'SSLv3')
4176
4177 def test_default_ecdh_curve(self):
4178 # Issue #21015: elliptic curve-based Diffie Hellman key exchange
4179 # should be enabled by default on SSL contexts.
4180 client_context, server_context, hostname = testing_context()
4181 # TLSv1.3 defaults to PFS key agreement and no longer has KEA in
4182 # cipher name.
4183 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4184 # Prior to OpenSSL 1.0.0, ECDH ciphers have to be enabled
4185 # explicitly using the 'ECCdraft' cipher alias. Otherwise,
4186 # our default cipher list should prefer ECDH-based ciphers
4187 # automatically.
4188 with ThreadedEchoServer(context=server_context) as server:
4189 with client_context.wrap_socket(socket.socket(),
4190 server_hostname=hostname) as s:
4191 s.connect((HOST, server.port))
4192 self.assertIn("ECDH", s.cipher()[0])
4193
4194 @unittest.skipUnless("tls-unique" in ssl.CHANNEL_BINDING_TYPES,
4195 "'tls-unique' channel binding not available")
4196 def test_tls_unique_channel_binding(self):
4197 """Test tls-unique channel binding."""
4198 if support.verbose:
4199 sys.stdout.write("\n")
4200
4201 client_context, server_context, hostname = testing_context()
4202
4203 # tls-unique is not defined for TLSv1.3
4204 # https://datatracker.ietf.org/doc/html/rfc8446#appendix-C.5
4205 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4206
4207 server = ThreadedEchoServer(context=server_context,
4208 chatty=True,
4209 connectionchatty=False)
4210
4211 with server:
4212 with client_context.wrap_socket(
4213 socket.socket(),
4214 server_hostname=hostname) as s:
4215 s.connect((HOST, server.port))
4216 # get the data
4217 cb_data = s.get_channel_binding("tls-unique")
4218 if support.verbose:
4219 sys.stdout.write(
4220 " got channel binding data: {0!r}\n".format(cb_data))
4221
4222 # check if it is sane
4223 self.assertIsNotNone(cb_data)
4224 if s.version() == 'TLSv1.3':
4225 self.assertEqual(len(cb_data), 48)
4226 else:
4227 self.assertEqual(len(cb_data), 12) # True for TLSv1
4228
4229 # and compare with the peers version
4230 s.write(b"CB tls-unique\n")
4231 peer_data_repr = s.read().strip()
4232 self.assertEqual(peer_data_repr,
4233 repr(cb_data).encode("us-ascii"))
4234
4235 # now, again
4236 with client_context.wrap_socket(
4237 socket.socket(),
4238 server_hostname=hostname) as s:
4239 s.connect((HOST, server.port))
4240 new_cb_data = s.get_channel_binding("tls-unique")
4241 if support.verbose:
4242 sys.stdout.write(
4243 "got another channel binding data: {0!r}\n".format(
4244 new_cb_data)
4245 )
4246 # is it really unique
4247 self.assertNotEqual(cb_data, new_cb_data)
4248 self.assertIsNotNone(cb_data)
4249 if s.version() == 'TLSv1.3':
4250 self.assertEqual(len(cb_data), 48)
4251 else:
4252 self.assertEqual(len(cb_data), 12) # True for TLSv1
4253 s.write(b"CB tls-unique\n")
4254 peer_data_repr = s.read().strip()
4255 self.assertEqual(peer_data_repr,
4256 repr(new_cb_data).encode("us-ascii"))
4257
4258 def test_compression(self):
4259 client_context, server_context, hostname = testing_context()
4260 stats = server_params_test(client_context, server_context,
4261 chatty=True, connectionchatty=True,
4262 sni_name=hostname)
4263 if support.verbose:
4264 sys.stdout.write(" got compression: {!r}\n".format(stats['compression']))
4265 self.assertIn(stats['compression'], { None, 'ZLIB', 'RLE' })
4266
4267 @unittest.skipUnless(hasattr(ssl, 'OP_NO_COMPRESSION'),
4268 "ssl.OP_NO_COMPRESSION needed for this test")
4269 def test_compression_disabled(self):
4270 client_context, server_context, hostname = testing_context()
4271 client_context.options |= ssl.OP_NO_COMPRESSION
4272 server_context.options |= ssl.OP_NO_COMPRESSION
4273 stats = server_params_test(client_context, server_context,
4274 chatty=True, connectionchatty=True,
4275 sni_name=hostname)
4276 self.assertIs(stats['compression'], None)
4277
4278 def test_legacy_server_connect(self):
4279 client_context, server_context, hostname = testing_context()
4280 client_context.options |= ssl.OP_LEGACY_SERVER_CONNECT
4281 server_params_test(client_context, server_context,
4282 chatty=True, connectionchatty=True,
4283 sni_name=hostname)
4284
4285 def test_no_legacy_server_connect(self):
4286 client_context, server_context, hostname = testing_context()
4287 client_context.options &= ~ssl.OP_LEGACY_SERVER_CONNECT
4288 server_params_test(client_context, server_context,
4289 chatty=True, connectionchatty=True,
4290 sni_name=hostname)
4291
4292 def test_dh_params(self):
4293 # Check we can get a connection with ephemeral finite-field
4294 # Diffie-Hellman (if supported).
4295 client_context, server_context, hostname = testing_context()
4296 dhe_aliases = {"ADH", "EDH", "DHE"}
4297 if not (supports_kx_alias(client_context, dhe_aliases)
4298 and supports_kx_alias(server_context, dhe_aliases)):
4299 self.skipTest("libssl doesn't support ephemeral DH")
4300 # test scenario needs TLS <= 1.2
4301 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4302 try:
4303 server_context.load_dh_params(DHFILE)
4304 except RuntimeError:
4305 if Py_DEBUG_WIN32:
4306 self.skipTest("not supported on Win32 debug build")
4307 raise
4308 server_context.set_ciphers("kEDH")
4309 server_context.maximum_version = ssl.TLSVersion.TLSv1_2
4310 stats = server_params_test(client_context, server_context,
4311 chatty=True, connectionchatty=True,
4312 sni_name=hostname)
4313 cipher = stats["cipher"][0]
4314 parts = cipher.split("-")
4315 if not dhe_aliases.intersection(parts):
4316 self.fail("Non-DH key exchange: " + cipher[0])
4317
4318 def test_ecdh_curve(self):
4319 # server secp384r1, client auto
4320 client_context, server_context, hostname = testing_context()
4321
4322 server_context.set_ecdh_curve("secp384r1")
4323 server_context.set_ciphers("ECDHE:!eNULL:!aNULL")
4324 server_context.minimum_version = ssl.TLSVersion.TLSv1_2
4325 stats = server_params_test(client_context, server_context,
4326 chatty=True, connectionchatty=True,
4327 sni_name=hostname)
4328
4329 # server auto, client secp384r1
4330 client_context, server_context, hostname = testing_context()
4331 client_context.set_ecdh_curve("secp384r1")
4332 server_context.set_ciphers("ECDHE:!eNULL:!aNULL")
4333 server_context.minimum_version = ssl.TLSVersion.TLSv1_2
4334 stats = server_params_test(client_context, server_context,
4335 chatty=True, connectionchatty=True,
4336 sni_name=hostname)
4337
4338 # server / client curve mismatch
4339 client_context, server_context, hostname = testing_context()
4340 client_context.set_ecdh_curve("prime256v1")
4341 server_context.set_ecdh_curve("secp384r1")
4342 server_context.set_ciphers("ECDHE:!eNULL:!aNULL")
4343 server_context.minimum_version = ssl.TLSVersion.TLSv1_2
4344 with self.assertRaises(ssl.SSLError):
4345 server_params_test(client_context, server_context,
4346 chatty=True, connectionchatty=True,
4347 sni_name=hostname)
4348
4349 def test_selected_alpn_protocol(self):
4350 # selected_alpn_protocol() is None unless ALPN is used.
4351 client_context, server_context, hostname = testing_context()
4352 stats = server_params_test(client_context, server_context,
4353 chatty=True, connectionchatty=True,
4354 sni_name=hostname)
4355 self.assertIs(stats['client_alpn_protocol'], None)
4356
4357 def test_selected_alpn_protocol_if_server_uses_alpn(self):
4358 # selected_alpn_protocol() is None unless ALPN is used by the client.
4359 client_context, server_context, hostname = testing_context()
4360 server_context.set_alpn_protocols(['foo', 'bar'])
4361 stats = server_params_test(client_context, server_context,
4362 chatty=True, connectionchatty=True,
4363 sni_name=hostname)
4364 self.assertIs(stats['client_alpn_protocol'], None)
4365
4366 def test_alpn_protocols(self):
4367 server_protocols = ['foo', 'bar', 'milkshake']
4368 protocol_tests = [
4369 (['foo', 'bar'], 'foo'),
4370 (['bar', 'foo'], 'foo'),
4371 (['milkshake'], 'milkshake'),
4372 (['http/3.0', 'http/4.0'], None)
4373 ]
4374 for client_protocols, expected in protocol_tests:
4375 client_context, server_context, hostname = testing_context()
4376 server_context.set_alpn_protocols(server_protocols)
4377 client_context.set_alpn_protocols(client_protocols)
4378
4379 try:
4380 stats = server_params_test(client_context,
4381 server_context,
4382 chatty=True,
4383 connectionchatty=True,
4384 sni_name=hostname)
4385 except ssl.SSLError as e:
4386 stats = e
4387
4388 msg = "failed trying %s (s) and %s (c).\n" \
4389 "was expecting %s, but got %%s from the %%s" \
4390 % (str(server_protocols), str(client_protocols),
4391 str(expected))
4392 client_result = stats['client_alpn_protocol']
4393 self.assertEqual(client_result, expected,
4394 msg % (client_result, "client"))
4395 server_result = stats['server_alpn_protocols'][-1] \
4396 if len(stats['server_alpn_protocols']) else 'nothing'
4397 self.assertEqual(server_result, expected,
4398 msg % (server_result, "server"))
4399
4400 def test_npn_protocols(self):
4401 assert not ssl.HAS_NPN
4402
4403 def sni_contexts(self):
4404 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
4405 server_context.load_cert_chain(SIGNED_CERTFILE)
4406 other_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
4407 other_context.load_cert_chain(SIGNED_CERTFILE2)
4408 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4409 client_context.load_verify_locations(SIGNING_CA)
4410 return server_context, other_context, client_context
4411
4412 def check_common_name(self, stats, name):
4413 cert = stats['peercert']
4414 self.assertIn((('commonName', name),), cert['subject'])
4415
4416 def test_sni_callback(self):
4417 calls = []
4418 server_context, other_context, client_context = self.sni_contexts()
4419
4420 client_context.check_hostname = False
4421
4422 def servername_cb(ssl_sock, server_name, initial_context):
4423 calls.append((server_name, initial_context))
4424 if server_name is not None:
4425 ssl_sock.context = other_context
4426 server_context.set_servername_callback(servername_cb)
4427
4428 stats = server_params_test(client_context, server_context,
4429 chatty=True,
4430 sni_name='supermessage')
4431 # The hostname was fetched properly, and the certificate was
4432 # changed for the connection.
4433 self.assertEqual(calls, [("supermessage", server_context)])
4434 # CERTFILE4 was selected
4435 self.check_common_name(stats, 'fakehostname')
4436
4437 calls = []
4438 # The callback is called with server_name=None
4439 stats = server_params_test(client_context, server_context,
4440 chatty=True,
4441 sni_name=None)
4442 self.assertEqual(calls, [(None, server_context)])
4443 self.check_common_name(stats, SIGNED_CERTFILE_HOSTNAME)
4444
4445 # Check disabling the callback
4446 calls = []
4447 server_context.set_servername_callback(None)
4448
4449 stats = server_params_test(client_context, server_context,
4450 chatty=True,
4451 sni_name='notfunny')
4452 # Certificate didn't change
4453 self.check_common_name(stats, SIGNED_CERTFILE_HOSTNAME)
4454 self.assertEqual(calls, [])
4455
4456 def test_sni_callback_alert(self):
4457 # Returning a TLS alert is reflected to the connecting client
4458 server_context, other_context, client_context = self.sni_contexts()
4459
4460 def cb_returning_alert(ssl_sock, server_name, initial_context):
4461 return ssl.ALERT_DESCRIPTION_ACCESS_DENIED
4462 server_context.set_servername_callback(cb_returning_alert)
4463 with self.assertRaises(ssl.SSLError) as cm:
4464 stats = server_params_test(client_context, server_context,
4465 chatty=False,
4466 sni_name='supermessage')
4467 self.assertEqual(cm.exception.reason, 'TLSV1_ALERT_ACCESS_DENIED')
4468
4469 def test_sni_callback_raising(self):
4470 # Raising fails the connection with a TLS handshake failure alert.
4471 server_context, other_context, client_context = self.sni_contexts()
4472
4473 def cb_raising(ssl_sock, server_name, initial_context):
4474 1/0
4475 server_context.set_servername_callback(cb_raising)
4476
4477 with support.catch_unraisable_exception() as catch:
4478 with self.assertRaises(ssl.SSLError) as cm:
4479 stats = server_params_test(client_context, server_context,
4480 chatty=False,
4481 sni_name='supermessage')
4482
4483 # Allow for flexible libssl error messages.
4484 regex = "(SSLV3_ALERT_HANDSHAKE_FAILURE|NO_PRIVATE_VALUE)"
4485 self.assertRegex(cm.exception.reason, regex)
4486 self.assertEqual(catch.unraisable.exc_type, ZeroDivisionError)
4487
4488 def test_sni_callback_wrong_return_type(self):
4489 # Returning the wrong return type terminates the TLS connection
4490 # with an internal error alert.
4491 server_context, other_context, client_context = self.sni_contexts()
4492
4493 def cb_wrong_return_type(ssl_sock, server_name, initial_context):
4494 return "foo"
4495 server_context.set_servername_callback(cb_wrong_return_type)
4496
4497 with support.catch_unraisable_exception() as catch:
4498 with self.assertRaises(ssl.SSLError) as cm:
4499 stats = server_params_test(client_context, server_context,
4500 chatty=False,
4501 sni_name='supermessage')
4502
4503
4504 self.assertEqual(cm.exception.reason, 'TLSV1_ALERT_INTERNAL_ERROR')
4505 self.assertEqual(catch.unraisable.exc_type, TypeError)
4506
4507 def test_shared_ciphers(self):
4508 client_context, server_context, hostname = testing_context()
4509 client_context.set_ciphers("AES128:AES256")
4510 server_context.set_ciphers("AES256:eNULL")
4511 expected_algs = [
4512 "AES256", "AES-256",
4513 # TLS 1.3 ciphers are always enabled
4514 "TLS_CHACHA20", "TLS_AES",
4515 ]
4516
4517 stats = server_params_test(client_context, server_context,
4518 sni_name=hostname)
4519 ciphers = stats['server_shared_ciphers'][0]
4520 self.assertGreater(len(ciphers), 0)
4521 for name, tls_version, bits in ciphers:
4522 if not any(alg in name for alg in expected_algs):
4523 self.fail(name)
4524
4525 def test_read_write_after_close_raises_valuerror(self):
4526 client_context, server_context, hostname = testing_context()
4527 server = ThreadedEchoServer(context=server_context, chatty=False)
4528
4529 with server:
4530 s = client_context.wrap_socket(socket.socket(),
4531 server_hostname=hostname)
4532 s.connect((HOST, server.port))
4533 s.close()
4534
4535 self.assertRaises(ValueError, s.read, 1024)
4536 self.assertRaises(ValueError, s.write, b'hello')
4537
4538 def test_sendfile(self):
4539 TEST_DATA = b"x" * 512
4540 with open(os_helper.TESTFN, 'wb') as f:
4541 f.write(TEST_DATA)
4542 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
4543 client_context, server_context, hostname = testing_context()
4544 server = ThreadedEchoServer(context=server_context, chatty=False)
4545 with server:
4546 with client_context.wrap_socket(socket.socket(),
4547 server_hostname=hostname) as s:
4548 s.connect((HOST, server.port))
4549 with open(os_helper.TESTFN, 'rb') as file:
4550 s.sendfile(file)
4551 self.assertEqual(s.recv(1024), TEST_DATA)
4552
4553 def test_session(self):
4554 client_context, server_context, hostname = testing_context()
4555 # TODO: sessions aren't compatible with TLSv1.3 yet
4556 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4557
4558 # first connection without session
4559 stats = server_params_test(client_context, server_context,
4560 sni_name=hostname)
4561 session = stats['session']
4562 self.assertTrue(session.id)
4563 self.assertGreater(session.time, 0)
4564 self.assertGreater(session.timeout, 0)
4565 self.assertTrue(session.has_ticket)
4566 self.assertGreater(session.ticket_lifetime_hint, 0)
4567 self.assertFalse(stats['session_reused'])
4568 sess_stat = server_context.session_stats()
4569 self.assertEqual(sess_stat['accept'], 1)
4570 self.assertEqual(sess_stat['hits'], 0)
4571
4572 # reuse session
4573 stats = server_params_test(client_context, server_context,
4574 session=session, sni_name=hostname)
4575 sess_stat = server_context.session_stats()
4576 self.assertEqual(sess_stat['accept'], 2)
4577 self.assertEqual(sess_stat['hits'], 1)
4578 self.assertTrue(stats['session_reused'])
4579 session2 = stats['session']
4580 self.assertEqual(session2.id, session.id)
4581 self.assertEqual(session2, session)
4582 self.assertIsNot(session2, session)
4583 self.assertGreaterEqual(session2.time, session.time)
4584 self.assertGreaterEqual(session2.timeout, session.timeout)
4585
4586 # another one without session
4587 stats = server_params_test(client_context, server_context,
4588 sni_name=hostname)
4589 self.assertFalse(stats['session_reused'])
4590 session3 = stats['session']
4591 self.assertNotEqual(session3.id, session.id)
4592 self.assertNotEqual(session3, session)
4593 sess_stat = server_context.session_stats()
4594 self.assertEqual(sess_stat['accept'], 3)
4595 self.assertEqual(sess_stat['hits'], 1)
4596
4597 # reuse session again
4598 stats = server_params_test(client_context, server_context,
4599 session=session, sni_name=hostname)
4600 self.assertTrue(stats['session_reused'])
4601 session4 = stats['session']
4602 self.assertEqual(session4.id, session.id)
4603 self.assertEqual(session4, session)
4604 self.assertGreaterEqual(session4.time, session.time)
4605 self.assertGreaterEqual(session4.timeout, session.timeout)
4606 sess_stat = server_context.session_stats()
4607 self.assertEqual(sess_stat['accept'], 4)
4608 self.assertEqual(sess_stat['hits'], 2)
4609
4610 def test_session_handling(self):
4611 client_context, server_context, hostname = testing_context()
4612 client_context2, _, _ = testing_context()
4613
4614 # TODO: session reuse does not work with TLSv1.3
4615 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4616 client_context2.maximum_version = ssl.TLSVersion.TLSv1_2
4617
4618 server = ThreadedEchoServer(context=server_context, chatty=False)
4619 with server:
4620 with client_context.wrap_socket(socket.socket(),
4621 server_hostname=hostname) as s:
4622 # session is None before handshake
4623 self.assertEqual(s.session, None)
4624 self.assertEqual(s.session_reused, None)
4625 s.connect((HOST, server.port))
4626 session = s.session
4627 self.assertTrue(session)
4628 with self.assertRaises(TypeError) as e:
4629 s.session = object
4630 self.assertEqual(str(e.exception), 'Value is not a SSLSession.')
4631
4632 with client_context.wrap_socket(socket.socket(),
4633 server_hostname=hostname) as s:
4634 s.connect((HOST, server.port))
4635 # cannot set session after handshake
4636 with self.assertRaises(ValueError) as e:
4637 s.session = session
4638 self.assertEqual(str(e.exception),
4639 'Cannot set session after handshake.')
4640
4641 with client_context.wrap_socket(socket.socket(),
4642 server_hostname=hostname) as s:
4643 # can set session before handshake and before the
4644 # connection was established
4645 s.session = session
4646 s.connect((HOST, server.port))
4647 self.assertEqual(s.session.id, session.id)
4648 self.assertEqual(s.session, session)
4649 self.assertEqual(s.session_reused, True)
4650
4651 with client_context2.wrap_socket(socket.socket(),
4652 server_hostname=hostname) as s:
4653 # cannot re-use session with a different SSLContext
4654 with self.assertRaises(ValueError) as e:
4655 s.session = session
4656 s.connect((HOST, server.port))
4657 self.assertEqual(str(e.exception),
4658 'Session refers to a different SSLContext.')
4659
4660 @requires_tls_version('TLSv1_2')
4661 @unittest.skipUnless(ssl.HAS_PSK, 'TLS-PSK disabled on this OpenSSL build')
4662 def test_psk(self):
4663 psk = bytes.fromhex('deadbeef')
4664
4665 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4666 client_context.check_hostname = False
4667 client_context.verify_mode = ssl.CERT_NONE
4668 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4669 client_context.set_ciphers('PSK')
4670 client_context.set_psk_client_callback(lambda hint: (None, psk))
4671
4672 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
4673 server_context.maximum_version = ssl.TLSVersion.TLSv1_2
4674 server_context.set_ciphers('PSK')
4675 server_context.set_psk_server_callback(lambda identity: psk)
4676
4677 # correct PSK should connect
4678 server = ThreadedEchoServer(context=server_context)
4679 with server:
4680 with client_context.wrap_socket(socket.socket()) as s:
4681 s.connect((HOST, server.port))
4682
4683 # incorrect PSK should fail
4684 incorrect_psk = bytes.fromhex('cafebabe')
4685 client_context.set_psk_client_callback(lambda hint: (None, incorrect_psk))
4686 server = ThreadedEchoServer(context=server_context)
4687 with server:
4688 with client_context.wrap_socket(socket.socket()) as s:
4689 with self.assertRaises(ssl.SSLError):
4690 s.connect((HOST, server.port))
4691
4692 # identity_hint and client_identity should be sent to the other side
4693 identity_hint = 'identity-hint'
4694 client_identity = 'client-identity'
4695
4696 def client_callback(hint):
4697 self.assertEqual(hint, identity_hint)
4698 return client_identity, psk
4699
4700 def server_callback(identity):
4701 self.assertEqual(identity, client_identity)
4702 return psk
4703
4704 client_context.set_psk_client_callback(client_callback)
4705 server_context.set_psk_server_callback(server_callback, identity_hint)
4706 server = ThreadedEchoServer(context=server_context)
4707 with server:
4708 with client_context.wrap_socket(socket.socket()) as s:
4709 s.connect((HOST, server.port))
4710
4711 # adding client callback to server or vice versa raises an exception
4712 with self.assertRaisesRegex(ssl.SSLError, 'Cannot add PSK server callback'):
4713 client_context.set_psk_server_callback(server_callback, identity_hint)
4714 with self.assertRaisesRegex(ssl.SSLError, 'Cannot add PSK client callback'):
4715 server_context.set_psk_client_callback(client_callback)
4716
4717 # test with UTF-8 identities
4718 identity_hint = '身份暗示' # Translation: "Identity hint"
4719 client_identity = '客户身份' # Translation: "Customer identity"
4720
4721 client_context.set_psk_client_callback(client_callback)
4722 server_context.set_psk_server_callback(server_callback, identity_hint)
4723 server = ThreadedEchoServer(context=server_context)
4724 with server:
4725 with client_context.wrap_socket(socket.socket()) as s:
4726 s.connect((HOST, server.port))
4727
4728 @requires_tls_version('TLSv1_3')
4729 @unittest.skipUnless(ssl.HAS_PSK, 'TLS-PSK disabled on this OpenSSL build')
4730 def test_psk_tls1_3(self):
4731 psk = bytes.fromhex('deadbeef')
4732 identity_hint = 'identity-hint'
4733 client_identity = 'client-identity'
4734
4735 def client_callback(hint):
4736 # identity_hint is not sent to the client in TLS 1.3
4737 self.assertIsNone(hint)
4738 return client_identity, psk
4739
4740 def server_callback(identity):
4741 self.assertEqual(identity, client_identity)
4742 return psk
4743
4744 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4745 client_context.check_hostname = False
4746 client_context.verify_mode = ssl.CERT_NONE
4747 client_context.minimum_version = ssl.TLSVersion.TLSv1_3
4748 client_context.set_ciphers('PSK')
4749 client_context.set_psk_client_callback(client_callback)
4750
4751 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
4752 server_context.minimum_version = ssl.TLSVersion.TLSv1_3
4753 server_context.set_ciphers('PSK')
4754 server_context.set_psk_server_callback(server_callback, identity_hint)
4755
4756 server = ThreadedEchoServer(context=server_context)
4757 with server:
4758 with client_context.wrap_socket(socket.socket()) as s:
4759 s.connect((HOST, server.port))
4760
4761 def test_thread_recv_while_main_thread_sends(self):
4762 # GH-137583: Locking was added to calls to send() and recv() on SSL
4763 # socket objects. This seemed fine at the surface level because those
4764 # calls weren't re-entrant, but recv() calls would implicitly mimick
4765 # holding a lock by blocking until it received data. This means that
4766 # if a thread started to infinitely block until data was received, calls
4767 # to send() would deadlock, because it would wait forever on the lock
4768 # that the recv() call held.
4769 data = b"1" * 1024
4770 event = threading.Event()
4771 def background(sock):
4772 event.set()
4773 received = sock.recv(len(data))
4774 self.assertEqual(received, data)
4775
4776 client_context, server_context, hostname = testing_context()
4777 server = ThreadedEchoServer(context=server_context)
4778 with server:
4779 with client_context.wrap_socket(socket.socket(),
4780 server_hostname=hostname) as sock:
4781 sock.connect((HOST, server.port))
4782 sock.settimeout(1)
4783 sock.setblocking(1)
4784 # Ensure that the server is ready to accept requests
4785 sock.sendall(b"123")
4786 self.assertEqual(sock.recv(3), b"123")
4787 with threading_helper.catch_threading_exception() as cm:
4788 thread = threading.Thread(target=background,
4789 args=(sock,), daemon=True)
4790 thread.start()
4791 event.wait()
4792 sock.sendall(data)
4793 thread.join()
4794 if cm.exc_value is not None:
4795 raise cm.exc_value
4796
4797
4798 @unittest.skipUnless(has_tls_version('TLSv1_3') and ssl.HAS_PHA,
4799 "Test needs TLS 1.3 PHA")
4800 class TestPostHandshakeAuth(unittest.TestCase):
4801 def test_pha_setter(self):
4802 protocols = [
4803 ssl.PROTOCOL_TLS_SERVER, ssl.PROTOCOL_TLS_CLIENT
4804 ]
4805 for protocol in protocols:
4806 ctx = ssl.SSLContext(protocol)
4807 self.assertEqual(ctx.post_handshake_auth, False)
4808
4809 ctx.post_handshake_auth = True
4810 self.assertEqual(ctx.post_handshake_auth, True)
4811
4812 ctx.verify_mode = ssl.CERT_REQUIRED
4813 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
4814 self.assertEqual(ctx.post_handshake_auth, True)
4815
4816 ctx.post_handshake_auth = False
4817 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
4818 self.assertEqual(ctx.post_handshake_auth, False)
4819
4820 ctx.verify_mode = ssl.CERT_OPTIONAL
4821 ctx.post_handshake_auth = True
4822 self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
4823 self.assertEqual(ctx.post_handshake_auth, True)
4824
4825 def test_pha_required(self):
4826 client_context, server_context, hostname = testing_context()
4827 server_context.post_handshake_auth = True
4828 server_context.verify_mode = ssl.CERT_REQUIRED
4829 client_context.post_handshake_auth = True
4830 client_context.load_cert_chain(SIGNED_CERTFILE)
4831
4832 server = ThreadedEchoServer(context=server_context, chatty=False)
4833 with server:
4834 with client_context.wrap_socket(socket.socket(),
4835 server_hostname=hostname) as s:
4836 s.connect((HOST, server.port))
4837 s.write(b'HASCERT')
4838 self.assertEqual(s.recv(1024), b'FALSE\n')
4839 s.write(b'PHA')
4840 self.assertEqual(s.recv(1024), b'OK\n')
4841 s.write(b'HASCERT')
4842 self.assertEqual(s.recv(1024), b'TRUE\n')
4843 # PHA method just returns true when cert is already available
4844 s.write(b'PHA')
4845 self.assertEqual(s.recv(1024), b'OK\n')
4846 s.write(b'GETCERT')
4847 cert_text = s.recv(4096).decode('us-ascii')
4848 self.assertIn('Python Software Foundation CA', cert_text)
4849
4850 def test_pha_required_nocert(self):
4851 client_context, server_context, hostname = testing_context()
4852 server_context.post_handshake_auth = True
4853 server_context.verify_mode = ssl.CERT_REQUIRED
4854 client_context.post_handshake_auth = True
4855
4856 def msg_cb(conn, direction, version, content_type, msg_type, data):
4857 if support.verbose and content_type == _TLSContentType.ALERT:
4858 info = (conn, direction, version, content_type, msg_type, data)
4859 sys.stdout.write(f"TLS: {info!r}\n")
4860
4861 server_context._msg_callback = msg_cb
4862 client_context._msg_callback = msg_cb
4863
4864 server = ThreadedEchoServer(context=server_context, chatty=True)
4865 with server:
4866 with client_context.wrap_socket(socket.socket(),
4867 server_hostname=hostname,
4868 suppress_ragged_eofs=False) as s:
4869 s.connect((HOST, server.port))
4870 s.write(b'PHA')
4871 # test sometimes fails with EOF error. Test passes as long as
4872 # server aborts connection with an error.
4873 with self.assertRaisesRegex(
4874 OSError,
4875 ('certificate required'
4876 '|EOF occurred'
4877 '|closed by the remote host'
4878 '|Connection reset by peer'
4879 '|Broken pipe')
4880 ):
4881 # receive CertificateRequest
4882 data = s.recv(1024)
4883 self.assertEqual(data, b'OK\n')
4884
4885 # send empty Certificate + Finish
4886 s.write(b'HASCERT')
4887
4888 # receive alert
4889 s.recv(1024)
4890
4891 def test_pha_optional(self):
4892 if support.verbose:
4893 sys.stdout.write("\n")
4894
4895 client_context, server_context, hostname = testing_context()
4896 server_context.post_handshake_auth = True
4897 server_context.verify_mode = ssl.CERT_REQUIRED
4898 client_context.post_handshake_auth = True
4899 client_context.load_cert_chain(SIGNED_CERTFILE)
4900
4901 # check CERT_OPTIONAL
4902 server_context.verify_mode = ssl.CERT_OPTIONAL
4903 server = ThreadedEchoServer(context=server_context, chatty=False)
4904 with server:
4905 with client_context.wrap_socket(socket.socket(),
4906 server_hostname=hostname) as s:
4907 s.connect((HOST, server.port))
4908 s.write(b'HASCERT')
4909 self.assertEqual(s.recv(1024), b'FALSE\n')
4910 s.write(b'PHA')
4911 self.assertEqual(s.recv(1024), b'OK\n')
4912 s.write(b'HASCERT')
4913 self.assertEqual(s.recv(1024), b'TRUE\n')
4914
4915 def test_pha_optional_nocert(self):
4916 if support.verbose:
4917 sys.stdout.write("\n")
4918
4919 client_context, server_context, hostname = testing_context()
4920 server_context.post_handshake_auth = True
4921 server_context.verify_mode = ssl.CERT_OPTIONAL
4922 client_context.post_handshake_auth = True
4923
4924 server = ThreadedEchoServer(context=server_context, chatty=False)
4925 with server:
4926 with client_context.wrap_socket(socket.socket(),
4927 server_hostname=hostname) as s:
4928 s.connect((HOST, server.port))
4929 s.write(b'HASCERT')
4930 self.assertEqual(s.recv(1024), b'FALSE\n')
4931 s.write(b'PHA')
4932 self.assertEqual(s.recv(1024), b'OK\n')
4933 # optional doesn't fail when client does not have a cert
4934 s.write(b'HASCERT')
4935 self.assertEqual(s.recv(1024), b'FALSE\n')
4936
4937 def test_pha_no_pha_client(self):
4938 client_context, server_context, hostname = testing_context()
4939 server_context.post_handshake_auth = True
4940 server_context.verify_mode = ssl.CERT_REQUIRED
4941 client_context.load_cert_chain(SIGNED_CERTFILE)
4942
4943 server = ThreadedEchoServer(context=server_context, chatty=False)
4944 with server:
4945 with client_context.wrap_socket(socket.socket(),
4946 server_hostname=hostname) as s:
4947 s.connect((HOST, server.port))
4948 with self.assertRaisesRegex(ssl.SSLError, 'not server'):
4949 s.verify_client_post_handshake()
4950 s.write(b'PHA')
4951 self.assertIn(b'extension not received', s.recv(1024))
4952
4953 def test_pha_no_pha_server(self):
4954 # server doesn't have PHA enabled, cert is requested in handshake
4955 client_context, server_context, hostname = testing_context()
4956 server_context.verify_mode = ssl.CERT_REQUIRED
4957 client_context.post_handshake_auth = True
4958 client_context.load_cert_chain(SIGNED_CERTFILE)
4959
4960 server = ThreadedEchoServer(context=server_context, chatty=False)
4961 with server:
4962 with client_context.wrap_socket(socket.socket(),
4963 server_hostname=hostname) as s:
4964 s.connect((HOST, server.port))
4965 s.write(b'HASCERT')
4966 self.assertEqual(s.recv(1024), b'TRUE\n')
4967 # PHA doesn't fail if there is already a cert
4968 s.write(b'PHA')
4969 self.assertEqual(s.recv(1024), b'OK\n')
4970 s.write(b'HASCERT')
4971 self.assertEqual(s.recv(1024), b'TRUE\n')
4972
4973 def test_pha_not_tls13(self):
4974 # TLS 1.2
4975 client_context, server_context, hostname = testing_context()
4976 server_context.verify_mode = ssl.CERT_REQUIRED
4977 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
4978 client_context.post_handshake_auth = True
4979 client_context.load_cert_chain(SIGNED_CERTFILE)
4980
4981 server = ThreadedEchoServer(context=server_context, chatty=False)
4982 with server:
4983 with client_context.wrap_socket(socket.socket(),
4984 server_hostname=hostname) as s:
4985 s.connect((HOST, server.port))
4986 # PHA fails for TLS != 1.3
4987 s.write(b'PHA')
4988 self.assertIn(b'WRONG_SSL_VERSION', s.recv(1024))
4989
4990 def test_bpo37428_pha_cert_none(self):
4991 # verify that post_handshake_auth does not implicitly enable cert
4992 # validation.
4993 hostname = SIGNED_CERTFILE_HOSTNAME
4994 client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
4995 client_context.post_handshake_auth = True
4996 client_context.load_cert_chain(SIGNED_CERTFILE)
4997 # no cert validation and CA on client side
4998 client_context.check_hostname = False
4999 client_context.verify_mode = ssl.CERT_NONE
5000
5001 server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
5002 server_context.load_cert_chain(SIGNED_CERTFILE)
5003 server_context.load_verify_locations(SIGNING_CA)
5004 server_context.post_handshake_auth = True
5005 server_context.verify_mode = ssl.CERT_REQUIRED
5006
5007 server = ThreadedEchoServer(context=server_context, chatty=False)
5008 with server:
5009 with client_context.wrap_socket(socket.socket(),
5010 server_hostname=hostname) as s:
5011 s.connect((HOST, server.port))
5012 s.write(b'HASCERT')
5013 self.assertEqual(s.recv(1024), b'FALSE\n')
5014 s.write(b'PHA')
5015 self.assertEqual(s.recv(1024), b'OK\n')
5016 s.write(b'HASCERT')
5017 self.assertEqual(s.recv(1024), b'TRUE\n')
5018 # server cert has not been validated
5019 self.assertEqual(s.getpeercert(), {})
5020
5021 def test_internal_chain_client(self):
5022 client_context, server_context, hostname = testing_context(
5023 server_chain=False
5024 )
5025 server = ThreadedEchoServer(context=server_context, chatty=False)
5026 with server:
5027 with client_context.wrap_socket(
5028 socket.socket(),
5029 server_hostname=hostname
5030 ) as s:
5031 s.connect((HOST, server.port))
5032 vc = s._sslobj.get_verified_chain()
5033 self.assertEqual(len(vc), 2)
5034 ee, ca = vc
5035 uvc = s._sslobj.get_unverified_chain()
5036 self.assertEqual(len(uvc), 1)
5037
5038 self.assertEqual(ee, uvc[0])
5039 self.assertEqual(hash(ee), hash(uvc[0]))
5040 self.assertEqual(repr(ee), repr(uvc[0]))
5041
5042 self.assertNotEqual(ee, ca)
5043 self.assertNotEqual(hash(ee), hash(ca))
5044 self.assertNotEqual(repr(ee), repr(ca))
5045 self.assertNotEqual(ee.get_info(), ca.get_info())
5046 self.assertIn("CN=localhost", repr(ee))
5047 self.assertIn("CN=our-ca-server", repr(ca))
5048
5049 pem = ee.public_bytes(_ssl.ENCODING_PEM)
5050 der = ee.public_bytes(_ssl.ENCODING_DER)
5051 self.assertIsInstance(pem, str)
5052 self.assertIn("-----BEGIN CERTIFICATE-----", pem)
5053 self.assertIsInstance(der, bytes)
5054 self.assertEqual(
5055 ssl.PEM_cert_to_DER_cert(pem), der
5056 )
5057
5058 def test_certificate_chain(self):
5059 client_context, server_context, hostname = testing_context(
5060 server_chain=False
5061 )
5062 server = ThreadedEchoServer(context=server_context, chatty=False)
5063
5064 with open(SIGNING_CA) as f:
5065 expected_ca_cert = ssl.PEM_cert_to_DER_cert(f.read())
5066
5067 with open(SINGED_CERTFILE_ONLY) as f:
5068 expected_ee_cert = ssl.PEM_cert_to_DER_cert(f.read())
5069
5070 with server:
5071 with client_context.wrap_socket(
5072 socket.socket(),
5073 server_hostname=hostname
5074 ) as s:
5075 s.connect((HOST, server.port))
5076 vc = s.get_verified_chain()
5077 self.assertEqual(len(vc), 2)
5078
5079 ee, ca = vc
5080 self.assertIsInstance(ee, bytes)
5081 self.assertIsInstance(ca, bytes)
5082 self.assertEqual(expected_ca_cert, ca)
5083 self.assertEqual(expected_ee_cert, ee)
5084
5085 uvc = s.get_unverified_chain()
5086 self.assertEqual(len(uvc), 1)
5087 self.assertIsInstance(uvc[0], bytes)
5088
5089 self.assertEqual(ee, uvc[0])
5090 self.assertNotEqual(ee, ca)
5091
5092 def test_internal_chain_server(self):
5093 client_context, server_context, hostname = testing_context()
5094 client_context.load_cert_chain(SIGNED_CERTFILE)
5095 server_context.verify_mode = ssl.CERT_REQUIRED
5096 server_context.maximum_version = ssl.TLSVersion.TLSv1_2
5097
5098 server = ThreadedEchoServer(context=server_context, chatty=False)
5099 with server:
5100 with client_context.wrap_socket(
5101 socket.socket(),
5102 server_hostname=hostname
5103 ) as s:
5104 s.connect((HOST, server.port))
5105 s.write(b'VERIFIEDCHAIN\n')
5106 res = s.recv(1024)
5107 self.assertEqual(res, b'\x02\n')
5108 s.write(b'UNVERIFIEDCHAIN\n')
5109 res = s.recv(1024)
5110 self.assertEqual(res, b'\x02\n')
5111
5112
5113 class TestSSLDebug(unittest.TestCase):
5114
5115 def keylog_lines(self, fname=os_helper.TESTFN):
5116 with open(fname) as f:
5117 return len(list(f))
5118
5119 @requires_keylog
5120 def test_keylog_defaults(self):
5121 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
5122 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
5123 self.assertEqual(ctx.keylog_filename, None)
5124
5125 self.assertFalse(os.path.isfile(os_helper.TESTFN))
5126 try:
5127 ctx.keylog_filename = os_helper.TESTFN
5128 except RuntimeError:
5129 if Py_DEBUG_WIN32:
5130 self.skipTest("not supported on Win32 debug build")
5131 raise
5132 self.assertEqual(ctx.keylog_filename, os_helper.TESTFN)
5133 self.assertTrue(os.path.isfile(os_helper.TESTFN))
5134 self.assertEqual(self.keylog_lines(), 1)
5135
5136 ctx.keylog_filename = None
5137 self.assertEqual(ctx.keylog_filename, None)
5138
5139 with self.assertRaises((IsADirectoryError, PermissionError)):
5140 # Windows raises PermissionError
5141 ctx.keylog_filename = os.path.dirname(
5142 os.path.abspath(os_helper.TESTFN))
5143
5144 with self.assertRaises(TypeError):
5145 ctx.keylog_filename = 1
5146
5147 @requires_keylog
5148 def test_keylog_filename(self):
5149 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
5150 client_context, server_context, hostname = testing_context()
5151
5152 try:
5153 client_context.keylog_filename = os_helper.TESTFN
5154 except RuntimeError:
5155 if Py_DEBUG_WIN32:
5156 self.skipTest("not supported on Win32 debug build")
5157 raise
5158
5159 server = ThreadedEchoServer(context=server_context, chatty=False)
5160 with server:
5161 with client_context.wrap_socket(socket.socket(),
5162 server_hostname=hostname) as s:
5163 s.connect((HOST, server.port))
5164 # header, 5 lines for TLS 1.3
5165 self.assertEqual(self.keylog_lines(), 6)
5166
5167 client_context.keylog_filename = None
5168 server_context.keylog_filename = os_helper.TESTFN
5169 server = ThreadedEchoServer(context=server_context, chatty=False)
5170 with server:
5171 with client_context.wrap_socket(socket.socket(),
5172 server_hostname=hostname) as s:
5173 s.connect((HOST, server.port))
5174 self.assertGreaterEqual(self.keylog_lines(), 11)
5175
5176 client_context.keylog_filename = os_helper.TESTFN
5177 server_context.keylog_filename = os_helper.TESTFN
5178 server = ThreadedEchoServer(context=server_context, chatty=False)
5179 with server:
5180 with client_context.wrap_socket(socket.socket(),
5181 server_hostname=hostname) as s:
5182 s.connect((HOST, server.port))
5183 self.assertGreaterEqual(self.keylog_lines(), 21)
5184
5185 client_context.keylog_filename = None
5186 server_context.keylog_filename = None
5187
5188 @requires_keylog
5189 @unittest.skipIf(sys.flags.ignore_environment,
5190 "test is not compatible with ignore_environment")
5191 def test_keylog_env(self):
5192 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
5193 with unittest.mock.patch.dict(os.environ):
5194 os.environ['SSLKEYLOGFILE'] = os_helper.TESTFN
5195 self.assertEqual(os.environ['SSLKEYLOGFILE'], os_helper.TESTFN)
5196
5197 ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
5198 self.assertEqual(ctx.keylog_filename, None)
5199
5200 try:
5201 ctx = ssl.create_default_context()
5202 except RuntimeError:
5203 if Py_DEBUG_WIN32:
5204 self.skipTest("not supported on Win32 debug build")
5205 raise
5206 self.assertEqual(ctx.keylog_filename, os_helper.TESTFN)
5207
5208 ctx = ssl._create_stdlib_context()
5209 self.assertEqual(ctx.keylog_filename, os_helper.TESTFN)
5210
5211 def test_msg_callback(self):
5212 client_context, server_context, hostname = testing_context()
5213
5214 def msg_cb(conn, direction, version, content_type, msg_type, data):
5215 pass
5216
5217 self.assertIs(client_context._msg_callback, None)
5218 client_context._msg_callback = msg_cb
5219 self.assertIs(client_context._msg_callback, msg_cb)
5220 with self.assertRaises(TypeError):
5221 client_context._msg_callback = object()
5222
5223 def test_msg_callback_tls12(self):
5224 client_context, server_context, hostname = testing_context()
5225 client_context.maximum_version = ssl.TLSVersion.TLSv1_2
5226
5227 msg = []
5228
5229 def msg_cb(conn, direction, version, content_type, msg_type, data):
5230 self.assertIsInstance(conn, ssl.SSLSocket)
5231 self.assertIsInstance(data, bytes)
5232 self.assertIn(direction, {'read', 'write'})
5233 msg.append((direction, version, content_type, msg_type))
5234
5235 client_context._msg_callback = msg_cb
5236
5237 server = ThreadedEchoServer(context=server_context, chatty=False)
5238 with server:
5239 with client_context.wrap_socket(socket.socket(),
5240 server_hostname=hostname) as s:
5241 s.connect((HOST, server.port))
5242
5243 self.assertIn(
5244 ("read", TLSVersion.TLSv1_2, _TLSContentType.HANDSHAKE,
5245 _TLSMessageType.SERVER_KEY_EXCHANGE),
5246 msg
5247 )
5248 self.assertIn(
5249 ("write", TLSVersion.TLSv1_2, _TLSContentType.CHANGE_CIPHER_SPEC,
5250 _TLSMessageType.CHANGE_CIPHER_SPEC),
5251 msg
5252 )
5253
5254 def test_msg_callback_deadlock_bpo43577(self):
5255 client_context, server_context, hostname = testing_context()
5256 server_context2 = testing_context()[1]
5257
5258 def msg_cb(conn, direction, version, content_type, msg_type, data):
5259 pass
5260
5261 def sni_cb(sock, servername, ctx):
5262 sock.context = server_context2
5263
5264 server_context._msg_callback = msg_cb
5265 server_context.sni_callback = sni_cb
5266
5267 server = ThreadedEchoServer(context=server_context, chatty=False)
5268 with server:
5269 with client_context.wrap_socket(socket.socket(),
5270 server_hostname=hostname) as s:
5271 s.connect((HOST, server.port))
5272 with client_context.wrap_socket(socket.socket(),
5273 server_hostname=hostname) as s:
5274 s.connect((HOST, server.port))
5275
5276
5277 def set_socket_so_linger_on_with_zero_timeout(sock):
5278 sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))
5279
5280
5281 class TestPreHandshakeClose(unittest.TestCase):
5282 """Verify behavior of close sockets with received data before to the handshake.
5283 """
5284
5285 class SingleConnectionTestServerThread(threading.Thread):
5286
5287 def __init__(self, *, name, call_after_accept, timeout=None):
5288 self.call_after_accept = call_after_accept
5289 self.received_data = b'' # set by .run()
5290 self.wrap_error = None # set by .run()
5291 self.listener = None # set by .start()
5292 self.port = None # set by .start()
5293 if timeout is None:
5294 self.timeout = support.SHORT_TIMEOUT
5295 else:
5296 self.timeout = timeout
5297 super().__init__(name=name)
5298
5299 def __enter__(self):
5300 self.start()
5301 return self
5302
5303 def __exit__(self, *args):
5304 try:
5305 if self.listener:
5306 self.listener.close()
5307 except OSError:
5308 pass
5309 self.join()
5310 self.wrap_error = None # avoid dangling references
5311
5312 def start(self):
5313 self.ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
5314 self.ssl_ctx.verify_mode = ssl.CERT_REQUIRED
5315 self.ssl_ctx.load_verify_locations(cafile=ONLYCERT)
5316 self.ssl_ctx.load_cert_chain(certfile=ONLYCERT, keyfile=ONLYKEY)
5317 self.listener = socket.socket()
5318 self.port = socket_helper.bind_port(self.listener)
5319 self.listener.settimeout(self.timeout)
5320 self.listener.listen(1)
5321 super().start()
5322
5323 def run(self):
5324 try:
5325 conn, address = self.listener.accept()
5326 except TimeoutError:
5327 # on timeout, just close the listener
5328 return
5329 finally:
5330 self.listener.close()
5331
5332 with conn:
5333 if self.call_after_accept(conn):
5334 return
5335 try:
5336 tls_socket = self.ssl_ctx.wrap_socket(conn, server_side=True)
5337 except OSError as err: # ssl.SSLError inherits from OSError
5338 self.wrap_error = err
5339 else:
5340 try:
5341 self.received_data = tls_socket.recv(400)
5342 except OSError:
5343 pass # closed, protocol error, etc.
5344
5345 def non_linux_skip_if_other_okay_error(self, err):
5346 if sys.platform in ("linux", "android"):
5347 return # Expect the full test setup to always work on Linux.
5348 if (isinstance(err, ConnectionResetError) or
5349 (isinstance(err, OSError) and err.errno == errno.EINVAL) or
5350 re.search(
5351 # Matches the following error messages:
5352 # '[SSL: WRONG_VERSION_NUMBER] wrong version number (_ssl.c:1123)'
5353 # '[SSL: RECORD_LAYER_FAILURE] record layer failure (_ssl.c:1109)'
5354 # '[SSL: HTTP_REQUEST] http request (_ssl.c:1143)'
5355 r'wrong.version.number|record.layer.failure|http.request',
5356 str(getattr(err, "reason", "")),
5357 re.IGNORECASE,
5358 )
5359 ):
5360 # On Windows the TCP RST leads to a ConnectionResetError
5361 # (ECONNRESET) which Linux doesn't appear to surface to userspace.
5362 # If wrap_socket() winds up on the "if connected:" path and doing
5363 # the actual wrapping... we get an SSLError from OpenSSL. This is
5364 # typically WRONG_VERSION_NUMBER. The same happens on iOS, but
5365 # RECORD_LAYER_FAILURE or HTTP_REQUEST is the error.
5366 #
5367 # While appropriate, these scenarios aren't what we're specifically
5368 # trying to test. The way this test is written is known to work on
5369 # Linux. We'll skip it anywhere else that it does not present as
5370 # doing so.
5371 try:
5372 self.skipTest(f"Could not recreate conditions on {sys.platform}:"
5373 f" {err=}")
5374 finally:
5375 # gh-108342: Explicitly break the reference cycle
5376 err = None
5377
5378 # If maintaining this conditional winds up being a problem.
5379 # just turn this into an unconditional skip anything but Linux.
5380 # The important thing is that our CI has the logic covered.
5381
5382 def test_preauth_data_to_tls_server(self):
5383 server_accept_called = threading.Event()
5384 ready_for_server_wrap_socket = threading.Event()
5385
5386 def call_after_accept(unused):
5387 server_accept_called.set()
5388 if not ready_for_server_wrap_socket.wait(support.SHORT_TIMEOUT):
5389 raise RuntimeError("wrap_socket event never set, test may fail.")
5390 return False # Tell the server thread to continue.
5391
5392 server = self.SingleConnectionTestServerThread(
5393 call_after_accept=call_after_accept,
5394 name="preauth_data_to_tls_server")
5395 self.enterContext(server) # starts it & unittest.TestCase stops it.
5396
5397 with socket.socket() as client:
5398 client.connect(server.listener.getsockname())
5399 # This forces an immediate connection close via RST on .close().
5400 set_socket_so_linger_on_with_zero_timeout(client)
5401 client.setblocking(False)
5402
5403 server_accept_called.wait()
5404 client.send(b"DELETE /data HTTP/1.0\r\n\r\n")
5405 client.close() # RST
5406
5407 ready_for_server_wrap_socket.set()
5408 server.join()
5409
5410 wrap_error = server.wrap_error
5411 server.wrap_error = None
5412 try:
5413 self.assertEqual(b"", server.received_data)
5414 self.assertIsInstance(wrap_error, OSError) # All platforms.
5415 self.non_linux_skip_if_other_okay_error(wrap_error)
5416 self.assertIsInstance(wrap_error, ssl.SSLError)
5417 self.assertIn("before TLS handshake with data", wrap_error.args[1])
5418 self.assertIn("before TLS handshake with data", wrap_error.reason)
5419 self.assertNotEqual(0, wrap_error.args[0])
5420 self.assertIsNone(wrap_error.library, msg="attr must exist")
5421 finally:
5422 # gh-108342: Explicitly break the reference cycle
5423 wrap_error = None
5424 server = None
5425
5426 def test_preauth_data_to_tls_client(self):
5427 server_can_continue_with_wrap_socket = threading.Event()
5428 client_can_continue_with_wrap_socket = threading.Event()
5429
5430 def call_after_accept(conn_to_client):
5431 if not server_can_continue_with_wrap_socket.wait(support.SHORT_TIMEOUT):
5432 print("ERROR: test client took too long")
5433
5434 # This forces an immediate connection close via RST on .close().
5435 set_socket_so_linger_on_with_zero_timeout(conn_to_client)
5436 conn_to_client.send(
5437 b"HTTP/1.0 307 Temporary Redirect\r\n"
5438 b"Location: https://example.com/someone-elses-server\r\n"
5439 b"\r\n")
5440 conn_to_client.close() # RST
5441 client_can_continue_with_wrap_socket.set()
5442 return True # Tell the server to stop.
5443
5444 server = self.SingleConnectionTestServerThread(
5445 call_after_accept=call_after_accept,
5446 name="preauth_data_to_tls_client")
5447 self.enterContext(server) # starts it & unittest.TestCase stops it.
5448 # Redundant; call_after_accept sets SO_LINGER on the accepted conn.
5449 set_socket_so_linger_on_with_zero_timeout(server.listener)
5450
5451 with socket.socket() as client:
5452 client.connect(server.listener.getsockname())
5453 server_can_continue_with_wrap_socket.set()
5454
5455 if not client_can_continue_with_wrap_socket.wait(support.SHORT_TIMEOUT):
5456 self.fail("test server took too long")
5457 ssl_ctx = ssl.create_default_context()
5458 try:
5459 tls_client = ssl_ctx.wrap_socket(
5460 client, server_hostname="localhost")
5461 except OSError as err: # SSLError inherits from OSError
5462 wrap_error = err
5463 received_data = b""
5464 else:
5465 wrap_error = None
5466 received_data = tls_client.recv(400)
5467 tls_client.close()
5468
5469 server.join()
5470 try:
5471 self.assertEqual(b"", received_data)
5472 self.assertIsInstance(wrap_error, OSError) # All platforms.
5473 self.non_linux_skip_if_other_okay_error(wrap_error)
5474 self.assertIsInstance(wrap_error, ssl.SSLError)
5475 self.assertIn("before TLS handshake with data", wrap_error.args[1])
5476 self.assertIn("before TLS handshake with data", wrap_error.reason)
5477 self.assertNotEqual(0, wrap_error.args[0])
5478 self.assertIsNone(wrap_error.library, msg="attr must exist")
5479 finally:
5480 # gh-108342: Explicitly break the reference cycle
5481 with warnings_helper.check_no_resource_warning(self):
5482 wrap_error = None
5483 server = None
5484
5485 def test_https_client_non_tls_response_ignored(self):
5486 server_responding = threading.Event()
5487
5488 class SynchronizedHTTPSConnection(http.client.HTTPSConnection):
5489 def connect(self):
5490 # Call clear text HTTP connect(), not the encrypted HTTPS (TLS)
5491 # connect(): wrap_socket() is called manually below.
5492 http.client.HTTPConnection.connect(self)
5493
5494 # Wait for our fault injection server to have done its thing.
5495 if not server_responding.wait(support.SHORT_TIMEOUT) and support.verbose:
5496 sys.stdout.write("server_responding event never set.")
5497 self.sock = self._context.wrap_socket(
5498 self.sock, server_hostname=self.host)
5499
5500 def call_after_accept(conn_to_client):
5501 # This forces an immediate connection close via RST on .close().
5502 set_socket_so_linger_on_with_zero_timeout(conn_to_client)
5503 conn_to_client.send(
5504 b"HTTP/1.0 402 Payment Required\r\n"
5505 b"\r\n")
5506 conn_to_client.close() # RST
5507 server_responding.set()
5508 return True # Tell the server to stop.
5509
5510 timeout = 2.0
5511 server = self.SingleConnectionTestServerThread(
5512 call_after_accept=call_after_accept,
5513 name="non_tls_http_RST_responder",
5514 timeout=timeout)
5515 self.enterContext(server) # starts it & unittest.TestCase stops it.
5516 # Redundant; call_after_accept sets SO_LINGER on the accepted conn.
5517 set_socket_so_linger_on_with_zero_timeout(server.listener)
5518
5519 connection = SynchronizedHTTPSConnection(
5520 server.listener.getsockname()[0],
5521 port=server.port,
5522 context=ssl.create_default_context(),
5523 timeout=timeout,
5524 )
5525
5526 # There are lots of reasons this raises as desired, long before this
5527 # test was added. Sending the request requires a successful TLS wrapped
5528 # socket; that fails if the connection is broken. It may seem pointless
5529 # to test this. It serves as an illustration of something that we never
5530 # want to happen... properly not happening.
5531 with warnings_helper.check_no_resource_warning(self), \
5532 self.assertRaises(OSError):
5533 connection.request("HEAD", "/test", headers={"Host": "localhost"})
5534 response = connection.getresponse()
5535
5536 server.join()
5537
5538
5539 class TestEnumerations(unittest.TestCase):
5540
5541 def test_tlsversion(self):
5542 class CheckedTLSVersion(enum.IntEnum):
5543 MINIMUM_SUPPORTED = _ssl.PROTO_MINIMUM_SUPPORTED
5544 SSLv3 = _ssl.PROTO_SSLv3
5545 TLSv1 = _ssl.PROTO_TLSv1
5546 TLSv1_1 = _ssl.PROTO_TLSv1_1
5547 TLSv1_2 = _ssl.PROTO_TLSv1_2
5548 TLSv1_3 = _ssl.PROTO_TLSv1_3
5549 MAXIMUM_SUPPORTED = _ssl.PROTO_MAXIMUM_SUPPORTED
5550 enum._test_simple_enum(CheckedTLSVersion, TLSVersion)
5551
5552 def test_tlscontenttype(self):
5553 class Checked_TLSContentType(enum.IntEnum):
5554 """Content types (record layer)
5555
5556 See RFC 8446, section B.1
5557 """
5558 CHANGE_CIPHER_SPEC = 20
5559 ALERT = 21
5560 HANDSHAKE = 22
5561 APPLICATION_DATA = 23
5562 # pseudo content types
5563 HEADER = 0x100
5564 INNER_CONTENT_TYPE = 0x101
5565 enum._test_simple_enum(Checked_TLSContentType, _TLSContentType)
5566
5567 def test_tlsalerttype(self):
5568 class Checked_TLSAlertType(enum.IntEnum):
5569 """Alert types for TLSContentType.ALERT messages
5570
5571 See RFC 8446, section B.2
5572 """
5573 CLOSE_NOTIFY = 0
5574 UNEXPECTED_MESSAGE = 10
5575 BAD_RECORD_MAC = 20
5576 DECRYPTION_FAILED = 21
5577 RECORD_OVERFLOW = 22
5578 DECOMPRESSION_FAILURE = 30
5579 HANDSHAKE_FAILURE = 40
5580 NO_CERTIFICATE = 41
5581 BAD_CERTIFICATE = 42
5582 UNSUPPORTED_CERTIFICATE = 43
5583 CERTIFICATE_REVOKED = 44
5584 CERTIFICATE_EXPIRED = 45
5585 CERTIFICATE_UNKNOWN = 46
5586 ILLEGAL_PARAMETER = 47
5587 UNKNOWN_CA = 48
5588 ACCESS_DENIED = 49
5589 DECODE_ERROR = 50
5590 DECRYPT_ERROR = 51
5591 EXPORT_RESTRICTION = 60
5592 PROTOCOL_VERSION = 70
5593 INSUFFICIENT_SECURITY = 71
5594 INTERNAL_ERROR = 80
5595 INAPPROPRIATE_FALLBACK = 86
5596 USER_CANCELED = 90
5597 NO_RENEGOTIATION = 100
5598 MISSING_EXTENSION = 109
5599 UNSUPPORTED_EXTENSION = 110
5600 CERTIFICATE_UNOBTAINABLE = 111
5601 UNRECOGNIZED_NAME = 112
5602 BAD_CERTIFICATE_STATUS_RESPONSE = 113
5603 BAD_CERTIFICATE_HASH_VALUE = 114
5604 UNKNOWN_PSK_IDENTITY = 115
5605 CERTIFICATE_REQUIRED = 116
5606 NO_APPLICATION_PROTOCOL = 120
5607 enum._test_simple_enum(Checked_TLSAlertType, _TLSAlertType)
5608
5609 def test_tlsmessagetype(self):
5610 class Checked_TLSMessageType(enum.IntEnum):
5611 """Message types (handshake protocol)
5612
5613 See RFC 8446, section B.3
5614 """
5615 HELLO_REQUEST = 0
5616 CLIENT_HELLO = 1
5617 SERVER_HELLO = 2
5618 HELLO_VERIFY_REQUEST = 3
5619 NEWSESSION_TICKET = 4
5620 END_OF_EARLY_DATA = 5
5621 HELLO_RETRY_REQUEST = 6
5622 ENCRYPTED_EXTENSIONS = 8
5623 CERTIFICATE = 11
5624 SERVER_KEY_EXCHANGE = 12
5625 CERTIFICATE_REQUEST = 13
5626 SERVER_DONE = 14
5627 CERTIFICATE_VERIFY = 15
5628 CLIENT_KEY_EXCHANGE = 16
5629 FINISHED = 20
5630 CERTIFICATE_URL = 21
5631 CERTIFICATE_STATUS = 22
5632 SUPPLEMENTAL_DATA = 23
5633 KEY_UPDATE = 24
5634 NEXT_PROTO = 67
5635 MESSAGE_HASH = 254
5636 CHANGE_CIPHER_SPEC = 0x0101
5637 enum._test_simple_enum(Checked_TLSMessageType, _TLSMessageType)
5638
5639 def test_sslmethod(self):
5640 Checked_SSLMethod = enum._old_convert_(
5641 enum.IntEnum, '_SSLMethod', 'ssl',
5642 lambda name: name.startswith('PROTOCOL_') and name != 'PROTOCOL_SSLv23',
5643 source=ssl._ssl,
5644 )
5645 # This member is assigned dynamically in `ssl.py`:
5646 Checked_SSLMethod.PROTOCOL_SSLv23 = Checked_SSLMethod.PROTOCOL_TLS
5647 enum._test_simple_enum(Checked_SSLMethod, ssl._SSLMethod)
5648
5649 def test_options(self):
5650 CheckedOptions = enum._old_convert_(
5651 enum.IntFlag, 'Options', 'ssl',
5652 lambda name: name.startswith('OP_'),
5653 source=ssl._ssl,
5654 )
5655 enum._test_simple_enum(CheckedOptions, ssl.Options)
5656
5657 def test_alertdescription(self):
5658 CheckedAlertDescription = enum._old_convert_(
5659 enum.IntEnum, 'AlertDescription', 'ssl',
5660 lambda name: name.startswith('ALERT_DESCRIPTION_'),
5661 source=ssl._ssl,
5662 )
5663 enum._test_simple_enum(CheckedAlertDescription, ssl.AlertDescription)
5664
5665 def test_sslerrornumber(self):
5666 Checked_SSLErrorNumber = enum._old_convert_(
5667 enum.IntEnum, 'SSLErrorNumber', 'ssl',
5668 lambda name: name.startswith('SSL_ERROR_'),
5669 source=ssl._ssl,
5670 )
5671 enum._test_simple_enum(Checked_SSLErrorNumber, ssl.SSLErrorNumber)
5672
5673 def test_verifyflags(self):
5674 CheckedVerifyFlags = enum._old_convert_(
5675 enum.IntFlag, 'VerifyFlags', 'ssl',
5676 lambda name: name.startswith('VERIFY_'),
5677 source=ssl._ssl,
5678 )
5679 enum._test_simple_enum(CheckedVerifyFlags, ssl.VerifyFlags)
5680
5681 def test_verifymode(self):
5682 CheckedVerifyMode = enum._old_convert_(
5683 enum.IntEnum, 'VerifyMode', 'ssl',
5684 lambda name: name.startswith('CERT_'),
5685 source=ssl._ssl,
5686 )
5687 enum._test_simple_enum(CheckedVerifyMode, ssl.VerifyMode)
5688
5689
5690 def setUpModule():
5691 if support.verbose:
5692 plats = {
5693 'Mac': platform.mac_ver,
5694 'Windows': platform.win32_ver,
5695 }
5696 for name, func in plats.items():
5697 plat = func()
5698 if plat and plat[0]:
5699 plat = '%s %r' % (name, plat)
5700 break
5701 else:
5702 plat = repr(platform.platform())
5703 print("test_ssl: testing with %r %r" %
5704 (ssl.OPENSSL_VERSION, ssl.OPENSSL_VERSION_INFO))
5705 print(" under %s" % plat)
5706 print(" HAS_SNI = %r" % ssl.HAS_SNI)
5707 print(" OP_ALL = 0x%8x" % ssl.OP_ALL)
5708 try:
5709 print(" OP_NO_TLSv1_1 = 0x%8x" % ssl.OP_NO_TLSv1_1)
5710 except AttributeError:
5711 pass
5712
5713 for filename in [
5714 CERTFILE, BYTES_CERTFILE,
5715 ONLYCERT, ONLYKEY, BYTES_ONLYCERT, BYTES_ONLYKEY,
5716 SIGNED_CERTFILE, SIGNED_CERTFILE2, SIGNING_CA,
5717 BADCERT, BADKEY, EMPTYCERT]:
5718 if not os.path.exists(filename):
5719 raise support.TestFailed("Can't read certificate file %r" % filename)
5720
5721 thread_info = threading_helper.threading_setup()
5722 unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
5723
5724
5725 if __name__ == "__main__":
5726 unittest.main()