PageRenderTime 57ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/Lib/test/test_ssl.py

https://bitbucket.org/python_mirrors/sandbox-guido
Python | 1611 lines | 1476 code | 73 blank | 62 comment | 163 complexity | e507747cde5bd2464407928ac0ab04e0 MD5 | raw file
Possible License(s): BSD-3-Clause, 0BSD

Large files files are truncated, but you can click here to view the full file

  1. # Test the support for SSL and sockets
  2. import sys
  3. import unittest
  4. from test import support
  5. import socket
  6. import select
  7. import time
  8. import gc
  9. import os
  10. import errno
  11. import pprint
  12. import tempfile
  13. import urllib.request
  14. import traceback
  15. import asyncore
  16. import weakref
  17. import platform
  18. import functools
  19. ssl = support.import_module("ssl")
  20. PROTOCOLS = [
  21. ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv3,
  22. ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_TLSv1
  23. ]
  24. HOST = support.HOST
  25. data_file = lambda name: os.path.join(os.path.dirname(__file__), name)
  26. # The custom key and certificate files used in test_ssl are generated
  27. # using Lib/test/make_ssl_certs.py.
  28. # Other certificates are simply fetched from the Internet servers they
  29. # are meant to authenticate.
  30. CERTFILE = data_file("keycert.pem")
  31. BYTES_CERTFILE = os.fsencode(CERTFILE)
  32. ONLYCERT = data_file("ssl_cert.pem")
  33. ONLYKEY = data_file("ssl_key.pem")
  34. BYTES_ONLYCERT = os.fsencode(ONLYCERT)
  35. BYTES_ONLYKEY = os.fsencode(ONLYKEY)
  36. CAPATH = data_file("capath")
  37. BYTES_CAPATH = os.fsencode(CAPATH)
  38. SVN_PYTHON_ORG_ROOT_CERT = data_file("https_svn_python_org_root.pem")
  39. EMPTYCERT = data_file("nullcert.pem")
  40. BADCERT = data_file("badcert.pem")
  41. WRONGCERT = data_file("XXXnonexisting.pem")
  42. BADKEY = data_file("badkey.pem")
  43. def handle_error(prefix):
  44. exc_format = ' '.join(traceback.format_exception(*sys.exc_info()))
  45. if support.verbose:
  46. sys.stdout.write(prefix + exc_format)
  47. def can_clear_options():
  48. # 0.9.8m or higher
  49. return ssl.OPENSSL_VERSION_INFO >= (0, 9, 8, 13, 15)
  50. def no_sslv2_implies_sslv3_hello():
  51. # 0.9.7h or higher
  52. return ssl.OPENSSL_VERSION_INFO >= (0, 9, 7, 8, 15)
  53. # Issue #9415: Ubuntu hijacks their OpenSSL and forcefully disables SSLv2
  54. def skip_if_broken_ubuntu_ssl(func):
  55. @functools.wraps(func)
  56. def f(*args, **kwargs):
  57. try:
  58. ssl.SSLContext(ssl.PROTOCOL_SSLv2)
  59. except ssl.SSLError:
  60. if (ssl.OPENSSL_VERSION_INFO == (0, 9, 8, 15, 15) and
  61. platform.linux_distribution() == ('debian', 'squeeze/sid', '')):
  62. raise unittest.SkipTest("Patched Ubuntu OpenSSL breaks behaviour")
  63. return func(*args, **kwargs)
  64. return f
  65. class BasicSocketTests(unittest.TestCase):
  66. def test_constants(self):
  67. ssl.PROTOCOL_SSLv2
  68. ssl.PROTOCOL_SSLv23
  69. ssl.PROTOCOL_SSLv3
  70. ssl.PROTOCOL_TLSv1
  71. ssl.CERT_NONE
  72. ssl.CERT_OPTIONAL
  73. ssl.CERT_REQUIRED
  74. self.assertIn(ssl.HAS_SNI, {True, False})
  75. def test_random(self):
  76. v = ssl.RAND_status()
  77. if support.verbose:
  78. sys.stdout.write("\n RAND_status is %d (%s)\n"
  79. % (v, (v and "sufficient randomness") or
  80. "insufficient randomness"))
  81. try:
  82. ssl.RAND_egd(1)
  83. except TypeError:
  84. pass
  85. else:
  86. print("didn't raise TypeError")
  87. ssl.RAND_add("this is a random string", 75.0)
  88. def test_parse_cert(self):
  89. # note that this uses an 'unofficial' function in _ssl.c,
  90. # provided solely for this test, to exercise the certificate
  91. # parsing code
  92. p = ssl._ssl._test_decode_cert(CERTFILE)
  93. if support.verbose:
  94. sys.stdout.write("\n" + pprint.pformat(p) + "\n")
  95. def test_DER_to_PEM(self):
  96. with open(SVN_PYTHON_ORG_ROOT_CERT, 'r') as f:
  97. pem = f.read()
  98. d1 = ssl.PEM_cert_to_DER_cert(pem)
  99. p2 = ssl.DER_cert_to_PEM_cert(d1)
  100. d2 = ssl.PEM_cert_to_DER_cert(p2)
  101. self.assertEqual(d1, d2)
  102. if not p2.startswith(ssl.PEM_HEADER + '\n'):
  103. self.fail("DER-to-PEM didn't include correct header:\n%r\n" % p2)
  104. if not p2.endswith('\n' + ssl.PEM_FOOTER + '\n'):
  105. self.fail("DER-to-PEM didn't include correct footer:\n%r\n" % p2)
  106. def test_openssl_version(self):
  107. n = ssl.OPENSSL_VERSION_NUMBER
  108. t = ssl.OPENSSL_VERSION_INFO
  109. s = ssl.OPENSSL_VERSION
  110. self.assertIsInstance(n, int)
  111. self.assertIsInstance(t, tuple)
  112. self.assertIsInstance(s, str)
  113. # Some sanity checks follow
  114. # >= 0.9
  115. self.assertGreaterEqual(n, 0x900000)
  116. # < 2.0
  117. self.assertLess(n, 0x20000000)
  118. major, minor, fix, patch, status = t
  119. self.assertGreaterEqual(major, 0)
  120. self.assertLess(major, 2)
  121. self.assertGreaterEqual(minor, 0)
  122. self.assertLess(minor, 256)
  123. self.assertGreaterEqual(fix, 0)
  124. self.assertLess(fix, 256)
  125. self.assertGreaterEqual(patch, 0)
  126. self.assertLessEqual(patch, 26)
  127. self.assertGreaterEqual(status, 0)
  128. self.assertLessEqual(status, 15)
  129. # Version string as returned by OpenSSL, the format might change
  130. self.assertTrue(s.startswith("OpenSSL {:d}.{:d}.{:d}".format(major, minor, fix)),
  131. (s, t))
  132. @support.cpython_only
  133. def test_refcycle(self):
  134. # Issue #7943: an SSL object doesn't create reference cycles with
  135. # itself.
  136. s = socket.socket(socket.AF_INET)
  137. ss = ssl.wrap_socket(s)
  138. wr = weakref.ref(ss)
  139. del ss
  140. self.assertEqual(wr(), None)
  141. def test_wrapped_unconnected(self):
  142. # Methods on an unconnected SSLSocket propagate the original
  143. # socket.error raise by the underlying socket object.
  144. s = socket.socket(socket.AF_INET)
  145. ss = ssl.wrap_socket(s)
  146. self.assertRaises(socket.error, ss.recv, 1)
  147. self.assertRaises(socket.error, ss.recv_into, bytearray(b'x'))
  148. self.assertRaises(socket.error, ss.recvfrom, 1)
  149. self.assertRaises(socket.error, ss.recvfrom_into, bytearray(b'x'), 1)
  150. self.assertRaises(socket.error, ss.send, b'x')
  151. self.assertRaises(socket.error, ss.sendto, b'x', ('0.0.0.0', 0))
  152. def test_timeout(self):
  153. # Issue #8524: when creating an SSL socket, the timeout of the
  154. # original socket should be retained.
  155. for timeout in (None, 0.0, 5.0):
  156. s = socket.socket(socket.AF_INET)
  157. s.settimeout(timeout)
  158. ss = ssl.wrap_socket(s)
  159. self.assertEqual(timeout, ss.gettimeout())
  160. def test_errors(self):
  161. sock = socket.socket()
  162. self.assertRaisesRegex(ValueError,
  163. "certfile must be specified",
  164. ssl.wrap_socket, sock, keyfile=CERTFILE)
  165. self.assertRaisesRegex(ValueError,
  166. "certfile must be specified for server-side operations",
  167. ssl.wrap_socket, sock, server_side=True)
  168. self.assertRaisesRegex(ValueError,
  169. "certfile must be specified for server-side operations",
  170. ssl.wrap_socket, sock, server_side=True, certfile="")
  171. s = ssl.wrap_socket(sock, server_side=True, certfile=CERTFILE)
  172. self.assertRaisesRegex(ValueError, "can't connect in server-side mode",
  173. s.connect, (HOST, 8080))
  174. with self.assertRaises(IOError) as cm:
  175. with socket.socket() as sock:
  176. ssl.wrap_socket(sock, certfile=WRONGCERT)
  177. self.assertEqual(cm.exception.errno, errno.ENOENT)
  178. with self.assertRaises(IOError) as cm:
  179. with socket.socket() as sock:
  180. ssl.wrap_socket(sock, certfile=CERTFILE, keyfile=WRONGCERT)
  181. self.assertEqual(cm.exception.errno, errno.ENOENT)
  182. with self.assertRaises(IOError) as cm:
  183. with socket.socket() as sock:
  184. ssl.wrap_socket(sock, certfile=WRONGCERT, keyfile=WRONGCERT)
  185. self.assertEqual(cm.exception.errno, errno.ENOENT)
  186. def test_match_hostname(self):
  187. def ok(cert, hostname):
  188. ssl.match_hostname(cert, hostname)
  189. def fail(cert, hostname):
  190. self.assertRaises(ssl.CertificateError,
  191. ssl.match_hostname, cert, hostname)
  192. cert = {'subject': ((('commonName', 'example.com'),),)}
  193. ok(cert, 'example.com')
  194. ok(cert, 'ExAmple.cOm')
  195. fail(cert, 'www.example.com')
  196. fail(cert, '.example.com')
  197. fail(cert, 'example.org')
  198. fail(cert, 'exampleXcom')
  199. cert = {'subject': ((('commonName', '*.a.com'),),)}
  200. ok(cert, 'foo.a.com')
  201. fail(cert, 'bar.foo.a.com')
  202. fail(cert, 'a.com')
  203. fail(cert, 'Xa.com')
  204. fail(cert, '.a.com')
  205. cert = {'subject': ((('commonName', 'a.*.com'),),)}
  206. ok(cert, 'a.foo.com')
  207. fail(cert, 'a..com')
  208. fail(cert, 'a.com')
  209. cert = {'subject': ((('commonName', 'f*.com'),),)}
  210. ok(cert, 'foo.com')
  211. ok(cert, 'f.com')
  212. fail(cert, 'bar.com')
  213. fail(cert, 'foo.a.com')
  214. fail(cert, 'bar.foo.com')
  215. # Slightly fake real-world example
  216. cert = {'notAfter': 'Jun 26 21:41:46 2011 GMT',
  217. 'subject': ((('commonName', 'linuxfrz.org'),),),
  218. 'subjectAltName': (('DNS', 'linuxfr.org'),
  219. ('DNS', 'linuxfr.com'),
  220. ('othername', '<unsupported>'))}
  221. ok(cert, 'linuxfr.org')
  222. ok(cert, 'linuxfr.com')
  223. # Not a "DNS" entry
  224. fail(cert, '<unsupported>')
  225. # When there is a subjectAltName, commonName isn't used
  226. fail(cert, 'linuxfrz.org')
  227. # A pristine real-world example
  228. cert = {'notAfter': 'Dec 18 23:59:59 2011 GMT',
  229. 'subject': ((('countryName', 'US'),),
  230. (('stateOrProvinceName', 'California'),),
  231. (('localityName', 'Mountain View'),),
  232. (('organizationName', 'Google Inc'),),
  233. (('commonName', 'mail.google.com'),))}
  234. ok(cert, 'mail.google.com')
  235. fail(cert, 'gmail.com')
  236. # Only commonName is considered
  237. fail(cert, 'California')
  238. # Neither commonName nor subjectAltName
  239. cert = {'notAfter': 'Dec 18 23:59:59 2011 GMT',
  240. 'subject': ((('countryName', 'US'),),
  241. (('stateOrProvinceName', 'California'),),
  242. (('localityName', 'Mountain View'),),
  243. (('organizationName', 'Google Inc'),))}
  244. fail(cert, 'mail.google.com')
  245. # Empty cert / no cert
  246. self.assertRaises(ValueError, ssl.match_hostname, None, 'example.com')
  247. self.assertRaises(ValueError, ssl.match_hostname, {}, 'example.com')
  248. def test_server_side(self):
  249. # server_hostname doesn't work for server sockets
  250. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  251. with socket.socket() as sock:
  252. self.assertRaises(ValueError, ctx.wrap_socket, sock, True,
  253. server_hostname="some.hostname")
  254. class ContextTests(unittest.TestCase):
  255. @skip_if_broken_ubuntu_ssl
  256. def test_constructor(self):
  257. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv2)
  258. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  259. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv3)
  260. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  261. self.assertRaises(TypeError, ssl.SSLContext)
  262. self.assertRaises(ValueError, ssl.SSLContext, -1)
  263. self.assertRaises(ValueError, ssl.SSLContext, 42)
  264. @skip_if_broken_ubuntu_ssl
  265. def test_protocol(self):
  266. for proto in PROTOCOLS:
  267. ctx = ssl.SSLContext(proto)
  268. self.assertEqual(ctx.protocol, proto)
  269. def test_ciphers(self):
  270. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  271. ctx.set_ciphers("ALL")
  272. ctx.set_ciphers("DEFAULT")
  273. with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
  274. ctx.set_ciphers("^$:,;?*'dorothyx")
  275. @skip_if_broken_ubuntu_ssl
  276. def test_options(self):
  277. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  278. # OP_ALL is the default value
  279. self.assertEqual(ssl.OP_ALL, ctx.options)
  280. ctx.options |= ssl.OP_NO_SSLv2
  281. self.assertEqual(ssl.OP_ALL | ssl.OP_NO_SSLv2,
  282. ctx.options)
  283. ctx.options |= ssl.OP_NO_SSLv3
  284. self.assertEqual(ssl.OP_ALL | ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3,
  285. ctx.options)
  286. if can_clear_options():
  287. ctx.options = (ctx.options & ~ssl.OP_NO_SSLv2) | ssl.OP_NO_TLSv1
  288. self.assertEqual(ssl.OP_ALL | ssl.OP_NO_TLSv1 | ssl.OP_NO_SSLv3,
  289. ctx.options)
  290. ctx.options = 0
  291. self.assertEqual(0, ctx.options)
  292. else:
  293. with self.assertRaises(ValueError):
  294. ctx.options = 0
  295. def test_verify(self):
  296. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  297. # Default value
  298. self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
  299. ctx.verify_mode = ssl.CERT_OPTIONAL
  300. self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
  301. ctx.verify_mode = ssl.CERT_REQUIRED
  302. self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
  303. ctx.verify_mode = ssl.CERT_NONE
  304. self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
  305. with self.assertRaises(TypeError):
  306. ctx.verify_mode = None
  307. with self.assertRaises(ValueError):
  308. ctx.verify_mode = 42
  309. def test_load_cert_chain(self):
  310. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  311. # Combined key and cert in a single file
  312. ctx.load_cert_chain(CERTFILE)
  313. ctx.load_cert_chain(CERTFILE, keyfile=CERTFILE)
  314. self.assertRaises(TypeError, ctx.load_cert_chain, keyfile=CERTFILE)
  315. with self.assertRaises(IOError) as cm:
  316. ctx.load_cert_chain(WRONGCERT)
  317. self.assertEqual(cm.exception.errno, errno.ENOENT)
  318. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  319. ctx.load_cert_chain(BADCERT)
  320. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  321. ctx.load_cert_chain(EMPTYCERT)
  322. # Separate key and cert
  323. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  324. ctx.load_cert_chain(ONLYCERT, ONLYKEY)
  325. ctx.load_cert_chain(certfile=ONLYCERT, keyfile=ONLYKEY)
  326. ctx.load_cert_chain(certfile=BYTES_ONLYCERT, keyfile=BYTES_ONLYKEY)
  327. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  328. ctx.load_cert_chain(ONLYCERT)
  329. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  330. ctx.load_cert_chain(ONLYKEY)
  331. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  332. ctx.load_cert_chain(certfile=ONLYKEY, keyfile=ONLYCERT)
  333. # Mismatching key and cert
  334. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  335. with self.assertRaisesRegex(ssl.SSLError, "key values mismatch"):
  336. ctx.load_cert_chain(SVN_PYTHON_ORG_ROOT_CERT, ONLYKEY)
  337. def test_load_verify_locations(self):
  338. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  339. ctx.load_verify_locations(CERTFILE)
  340. ctx.load_verify_locations(cafile=CERTFILE, capath=None)
  341. ctx.load_verify_locations(BYTES_CERTFILE)
  342. ctx.load_verify_locations(cafile=BYTES_CERTFILE, capath=None)
  343. self.assertRaises(TypeError, ctx.load_verify_locations)
  344. self.assertRaises(TypeError, ctx.load_verify_locations, None, None)
  345. with self.assertRaises(IOError) as cm:
  346. ctx.load_verify_locations(WRONGCERT)
  347. self.assertEqual(cm.exception.errno, errno.ENOENT)
  348. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  349. ctx.load_verify_locations(BADCERT)
  350. ctx.load_verify_locations(CERTFILE, CAPATH)
  351. ctx.load_verify_locations(CERTFILE, capath=BYTES_CAPATH)
  352. # Issue #10989: crash if the second argument type is invalid
  353. self.assertRaises(TypeError, ctx.load_verify_locations, None, True)
  354. @skip_if_broken_ubuntu_ssl
  355. def test_session_stats(self):
  356. for proto in PROTOCOLS:
  357. ctx = ssl.SSLContext(proto)
  358. self.assertEqual(ctx.session_stats(), {
  359. 'number': 0,
  360. 'connect': 0,
  361. 'connect_good': 0,
  362. 'connect_renegotiate': 0,
  363. 'accept': 0,
  364. 'accept_good': 0,
  365. 'accept_renegotiate': 0,
  366. 'hits': 0,
  367. 'misses': 0,
  368. 'timeouts': 0,
  369. 'cache_full': 0,
  370. })
  371. def test_set_default_verify_paths(self):
  372. # There's not much we can do to test that it acts as expected,
  373. # so just check it doesn't crash or raise an exception.
  374. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  375. ctx.set_default_verify_paths()
  376. class NetworkedTests(unittest.TestCase):
  377. def test_connect(self):
  378. with support.transient_internet("svn.python.org"):
  379. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  380. cert_reqs=ssl.CERT_NONE)
  381. try:
  382. s.connect(("svn.python.org", 443))
  383. self.assertEqual({}, s.getpeercert())
  384. finally:
  385. s.close()
  386. # this should fail because we have no verification certs
  387. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  388. cert_reqs=ssl.CERT_REQUIRED)
  389. self.assertRaisesRegex(ssl.SSLError, "certificate verify failed",
  390. s.connect, ("svn.python.org", 443))
  391. s.close()
  392. # this should succeed because we specify the root cert
  393. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  394. cert_reqs=ssl.CERT_REQUIRED,
  395. ca_certs=SVN_PYTHON_ORG_ROOT_CERT)
  396. try:
  397. s.connect(("svn.python.org", 443))
  398. self.assertTrue(s.getpeercert())
  399. finally:
  400. s.close()
  401. def test_connect_ex(self):
  402. # Issue #11326: check connect_ex() implementation
  403. with support.transient_internet("svn.python.org"):
  404. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  405. cert_reqs=ssl.CERT_REQUIRED,
  406. ca_certs=SVN_PYTHON_ORG_ROOT_CERT)
  407. try:
  408. self.assertEqual(0, s.connect_ex(("svn.python.org", 443)))
  409. self.assertTrue(s.getpeercert())
  410. finally:
  411. s.close()
  412. def test_non_blocking_connect_ex(self):
  413. # Issue #11326: non-blocking connect_ex() should allow handshake
  414. # to proceed after the socket gets ready.
  415. with support.transient_internet("svn.python.org"):
  416. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  417. cert_reqs=ssl.CERT_REQUIRED,
  418. ca_certs=SVN_PYTHON_ORG_ROOT_CERT,
  419. do_handshake_on_connect=False)
  420. try:
  421. s.setblocking(False)
  422. rc = s.connect_ex(('svn.python.org', 443))
  423. # EWOULDBLOCK under Windows, EINPROGRESS elsewhere
  424. self.assertIn(rc, (0, errno.EINPROGRESS, errno.EWOULDBLOCK))
  425. # Wait for connect to finish
  426. select.select([], [s], [], 5.0)
  427. # Non-blocking handshake
  428. while True:
  429. try:
  430. s.do_handshake()
  431. break
  432. except ssl.SSLError as err:
  433. if err.args[0] == ssl.SSL_ERROR_WANT_READ:
  434. select.select([s], [], [], 5.0)
  435. elif err.args[0] == ssl.SSL_ERROR_WANT_WRITE:
  436. select.select([], [s], [], 5.0)
  437. else:
  438. raise
  439. # SSL established
  440. self.assertTrue(s.getpeercert())
  441. finally:
  442. s.close()
  443. def test_connect_with_context(self):
  444. with support.transient_internet("svn.python.org"):
  445. # Same as test_connect, but with a separately created context
  446. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  447. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  448. s.connect(("svn.python.org", 443))
  449. try:
  450. self.assertEqual({}, s.getpeercert())
  451. finally:
  452. s.close()
  453. # Same with a server hostname
  454. s = ctx.wrap_socket(socket.socket(socket.AF_INET),
  455. server_hostname="svn.python.org")
  456. if ssl.HAS_SNI:
  457. s.connect(("svn.python.org", 443))
  458. s.close()
  459. else:
  460. self.assertRaises(ValueError, s.connect, ("svn.python.org", 443))
  461. # This should fail because we have no verification certs
  462. ctx.verify_mode = ssl.CERT_REQUIRED
  463. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  464. self.assertRaisesRegex(ssl.SSLError, "certificate verify failed",
  465. s.connect, ("svn.python.org", 443))
  466. s.close()
  467. # This should succeed because we specify the root cert
  468. ctx.load_verify_locations(SVN_PYTHON_ORG_ROOT_CERT)
  469. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  470. s.connect(("svn.python.org", 443))
  471. try:
  472. cert = s.getpeercert()
  473. self.assertTrue(cert)
  474. finally:
  475. s.close()
  476. def test_connect_capath(self):
  477. # Verify server certificates using the `capath` argument
  478. # NOTE: the subject hashing algorithm has been changed between
  479. # OpenSSL 0.9.8n and 1.0.0, as a result the capath directory must
  480. # contain both versions of each certificate (same content, different
  481. # filename) for this test to be portable across OpenSSL releases.
  482. with support.transient_internet("svn.python.org"):
  483. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  484. ctx.verify_mode = ssl.CERT_REQUIRED
  485. ctx.load_verify_locations(capath=CAPATH)
  486. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  487. s.connect(("svn.python.org", 443))
  488. try:
  489. cert = s.getpeercert()
  490. self.assertTrue(cert)
  491. finally:
  492. s.close()
  493. # Same with a bytes `capath` argument
  494. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  495. ctx.verify_mode = ssl.CERT_REQUIRED
  496. ctx.load_verify_locations(capath=BYTES_CAPATH)
  497. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  498. s.connect(("svn.python.org", 443))
  499. try:
  500. cert = s.getpeercert()
  501. self.assertTrue(cert)
  502. finally:
  503. s.close()
  504. @unittest.skipIf(os.name == "nt", "Can't use a socket as a file under Windows")
  505. def test_makefile_close(self):
  506. # Issue #5238: creating a file-like object with makefile() shouldn't
  507. # delay closing the underlying "real socket" (here tested with its
  508. # file descriptor, hence skipping the test under Windows).
  509. with support.transient_internet("svn.python.org"):
  510. ss = ssl.wrap_socket(socket.socket(socket.AF_INET))
  511. ss.connect(("svn.python.org", 443))
  512. fd = ss.fileno()
  513. f = ss.makefile()
  514. f.close()
  515. # The fd is still open
  516. os.read(fd, 0)
  517. # Closing the SSL socket should close the fd too
  518. ss.close()
  519. gc.collect()
  520. with self.assertRaises(OSError) as e:
  521. os.read(fd, 0)
  522. self.assertEqual(e.exception.errno, errno.EBADF)
  523. def test_non_blocking_handshake(self):
  524. with support.transient_internet("svn.python.org"):
  525. s = socket.socket(socket.AF_INET)
  526. s.connect(("svn.python.org", 443))
  527. s.setblocking(False)
  528. s = ssl.wrap_socket(s,
  529. cert_reqs=ssl.CERT_NONE,
  530. do_handshake_on_connect=False)
  531. count = 0
  532. while True:
  533. try:
  534. count += 1
  535. s.do_handshake()
  536. break
  537. except ssl.SSLError as err:
  538. if err.args[0] == ssl.SSL_ERROR_WANT_READ:
  539. select.select([s], [], [])
  540. elif err.args[0] == ssl.SSL_ERROR_WANT_WRITE:
  541. select.select([], [s], [])
  542. else:
  543. raise
  544. s.close()
  545. if support.verbose:
  546. sys.stdout.write("\nNeeded %d calls to do_handshake() to establish session.\n" % count)
  547. def test_get_server_certificate(self):
  548. with support.transient_internet("svn.python.org"):
  549. pem = ssl.get_server_certificate(("svn.python.org", 443))
  550. if not pem:
  551. self.fail("No server certificate on svn.python.org:443!")
  552. try:
  553. pem = ssl.get_server_certificate(("svn.python.org", 443), ca_certs=CERTFILE)
  554. except ssl.SSLError as x:
  555. #should fail
  556. if support.verbose:
  557. sys.stdout.write("%s\n" % x)
  558. else:
  559. self.fail("Got server certificate %s for svn.python.org!" % pem)
  560. pem = ssl.get_server_certificate(("svn.python.org", 443), ca_certs=SVN_PYTHON_ORG_ROOT_CERT)
  561. if not pem:
  562. self.fail("No server certificate on svn.python.org:443!")
  563. if support.verbose:
  564. sys.stdout.write("\nVerified certificate for svn.python.org:443 is\n%s\n" % pem)
  565. def test_ciphers(self):
  566. remote = ("svn.python.org", 443)
  567. with support.transient_internet(remote[0]):
  568. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  569. cert_reqs=ssl.CERT_NONE, ciphers="ALL")
  570. s.connect(remote)
  571. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  572. cert_reqs=ssl.CERT_NONE, ciphers="DEFAULT")
  573. s.connect(remote)
  574. # Error checking can happen at instantiation or when connecting
  575. with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
  576. with socket.socket(socket.AF_INET) as sock:
  577. s = ssl.wrap_socket(sock,
  578. cert_reqs=ssl.CERT_NONE, ciphers="^$:,;?*'dorothyx")
  579. s.connect(remote)
  580. def test_algorithms(self):
  581. # Issue #8484: all algorithms should be available when verifying a
  582. # certificate.
  583. # SHA256 was added in OpenSSL 0.9.8
  584. if ssl.OPENSSL_VERSION_INFO < (0, 9, 8, 0, 15):
  585. self.skipTest("SHA256 not available on %r" % ssl.OPENSSL_VERSION)
  586. # https://sha2.hboeck.de/ was used until 2011-01-08 (no route to host)
  587. remote = ("sha256.tbs-internet.com", 443)
  588. sha256_cert = os.path.join(os.path.dirname(__file__), "sha256.pem")
  589. with support.transient_internet("sha256.tbs-internet.com"):
  590. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  591. cert_reqs=ssl.CERT_REQUIRED,
  592. ca_certs=sha256_cert,)
  593. try:
  594. s.connect(remote)
  595. if support.verbose:
  596. sys.stdout.write("\nCipher with %r is %r\n" %
  597. (remote, s.cipher()))
  598. sys.stdout.write("Certificate is:\n%s\n" %
  599. pprint.pformat(s.getpeercert()))
  600. finally:
  601. s.close()
  602. try:
  603. import threading
  604. except ImportError:
  605. _have_threads = False
  606. else:
  607. _have_threads = True
  608. from test.ssl_servers import make_https_server
  609. class ThreadedEchoServer(threading.Thread):
  610. class ConnectionHandler(threading.Thread):
  611. """A mildly complicated class, because we want it to work both
  612. with and without the SSL wrapper around the socket connection, so
  613. that we can test the STARTTLS functionality."""
  614. def __init__(self, server, connsock, addr):
  615. self.server = server
  616. self.running = False
  617. self.sock = connsock
  618. self.addr = addr
  619. self.sock.setblocking(1)
  620. self.sslconn = None
  621. threading.Thread.__init__(self)
  622. self.daemon = True
  623. def wrap_conn(self):
  624. try:
  625. self.sslconn = self.server.context.wrap_socket(
  626. self.sock, server_side=True)
  627. except ssl.SSLError:
  628. # XXX Various errors can have happened here, for example
  629. # a mismatching protocol version, an invalid certificate,
  630. # or a low-level bug. This should be made more discriminating.
  631. if self.server.chatty:
  632. handle_error("\n server: bad connection attempt from " + repr(self.addr) + ":\n")
  633. self.running = False
  634. self.server.stop()
  635. self.close()
  636. return False
  637. else:
  638. if self.server.context.verify_mode == ssl.CERT_REQUIRED:
  639. cert = self.sslconn.getpeercert()
  640. if support.verbose and self.server.chatty:
  641. sys.stdout.write(" client cert is " + pprint.pformat(cert) + "\n")
  642. cert_binary = self.sslconn.getpeercert(True)
  643. if support.verbose and self.server.chatty:
  644. sys.stdout.write(" cert binary is " + str(len(cert_binary)) + " bytes\n")
  645. cipher = self.sslconn.cipher()
  646. if support.verbose and self.server.chatty:
  647. sys.stdout.write(" server: connection cipher is now " + str(cipher) + "\n")
  648. return True
  649. def read(self):
  650. if self.sslconn:
  651. return self.sslconn.read()
  652. else:
  653. return self.sock.recv(1024)
  654. def write(self, bytes):
  655. if self.sslconn:
  656. return self.sslconn.write(bytes)
  657. else:
  658. return self.sock.send(bytes)
  659. def close(self):
  660. if self.sslconn:
  661. self.sslconn.close()
  662. else:
  663. self.sock.close()
  664. def run(self):
  665. self.running = True
  666. if not self.server.starttls_server:
  667. if not self.wrap_conn():
  668. return
  669. while self.running:
  670. try:
  671. msg = self.read()
  672. stripped = msg.strip()
  673. if not stripped:
  674. # eof, so quit this handler
  675. self.running = False
  676. self.close()
  677. elif stripped == b'over':
  678. if support.verbose and self.server.connectionchatty:
  679. sys.stdout.write(" server: client closed connection\n")
  680. self.close()
  681. return
  682. elif (self.server.starttls_server and
  683. stripped == b'STARTTLS'):
  684. if support.verbose and self.server.connectionchatty:
  685. sys.stdout.write(" server: read STARTTLS from client, sending OK...\n")
  686. self.write(b"OK\n")
  687. if not self.wrap_conn():
  688. return
  689. elif (self.server.starttls_server and self.sslconn
  690. and stripped == b'ENDTLS'):
  691. if support.verbose and self.server.connectionchatty:
  692. sys.stdout.write(" server: read ENDTLS from client, sending OK...\n")
  693. self.write(b"OK\n")
  694. self.sock = self.sslconn.unwrap()
  695. self.sslconn = None
  696. if support.verbose and self.server.connectionchatty:
  697. sys.stdout.write(" server: connection is now unencrypted...\n")
  698. else:
  699. if (support.verbose and
  700. self.server.connectionchatty):
  701. ctype = (self.sslconn and "encrypted") or "unencrypted"
  702. sys.stdout.write(" server: read %r (%s), sending back %r (%s)...\n"
  703. % (msg, ctype, msg.lower(), ctype))
  704. self.write(msg.lower())
  705. except socket.error:
  706. if self.server.chatty:
  707. handle_error("Test server failure:\n")
  708. self.close()
  709. self.running = False
  710. # normally, we'd just stop here, but for the test
  711. # harness, we want to stop the server
  712. self.server.stop()
  713. def __init__(self, certificate=None, ssl_version=None,
  714. certreqs=None, cacerts=None,
  715. chatty=True, connectionchatty=False, starttls_server=False,
  716. ciphers=None, context=None):
  717. if context:
  718. self.context = context
  719. else:
  720. self.context = ssl.SSLContext(ssl_version
  721. if ssl_version is not None
  722. else ssl.PROTOCOL_TLSv1)
  723. self.context.verify_mode = (certreqs if certreqs is not None
  724. else ssl.CERT_NONE)
  725. if cacerts:
  726. self.context.load_verify_locations(cacerts)
  727. if certificate:
  728. self.context.load_cert_chain(certificate)
  729. if ciphers:
  730. self.context.set_ciphers(ciphers)
  731. self.chatty = chatty
  732. self.connectionchatty = connectionchatty
  733. self.starttls_server = starttls_server
  734. self.sock = socket.socket()
  735. self.port = support.bind_port(self.sock)
  736. self.flag = None
  737. self.active = False
  738. threading.Thread.__init__(self)
  739. self.daemon = True
  740. def start(self, flag=None):
  741. self.flag = flag
  742. threading.Thread.start(self)
  743. def run(self):
  744. self.sock.settimeout(0.05)
  745. self.sock.listen(5)
  746. self.active = True
  747. if self.flag:
  748. # signal an event
  749. self.flag.set()
  750. while self.active:
  751. try:
  752. newconn, connaddr = self.sock.accept()
  753. if support.verbose and self.chatty:
  754. sys.stdout.write(' server: new connection from '
  755. + repr(connaddr) + '\n')
  756. handler = self.ConnectionHandler(self, newconn, connaddr)
  757. handler.start()
  758. except socket.timeout:
  759. pass
  760. except KeyboardInterrupt:
  761. self.stop()
  762. self.sock.close()
  763. def stop(self):
  764. self.active = False
  765. class AsyncoreEchoServer(threading.Thread):
  766. # this one's based on asyncore.dispatcher
  767. class EchoServer (asyncore.dispatcher):
  768. class ConnectionHandler (asyncore.dispatcher_with_send):
  769. def __init__(self, conn, certfile):
  770. self.socket = ssl.wrap_socket(conn, server_side=True,
  771. certfile=certfile,
  772. do_handshake_on_connect=False)
  773. asyncore.dispatcher_with_send.__init__(self, self.socket)
  774. self._ssl_accepting = True
  775. self._do_ssl_handshake()
  776. def readable(self):
  777. if isinstance(self.socket, ssl.SSLSocket):
  778. while self.socket.pending() > 0:
  779. self.handle_read_event()
  780. return True
  781. def _do_ssl_handshake(self):
  782. try:
  783. self.socket.do_handshake()
  784. except ssl.SSLError as err:
  785. if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
  786. ssl.SSL_ERROR_WANT_WRITE):
  787. return
  788. elif err.args[0] == ssl.SSL_ERROR_EOF:
  789. return self.handle_close()
  790. raise
  791. except socket.error as err:
  792. if err.args[0] == errno.ECONNABORTED:
  793. return self.handle_close()
  794. else:
  795. self._ssl_accepting = False
  796. def handle_read(self):
  797. if self._ssl_accepting:
  798. self._do_ssl_handshake()
  799. else:
  800. data = self.recv(1024)
  801. if support.verbose:
  802. sys.stdout.write(" server: read %s from client\n" % repr(data))
  803. if not data:
  804. self.close()
  805. else:
  806. self.send(data.lower())
  807. def handle_close(self):
  808. self.close()
  809. if support.verbose:
  810. sys.stdout.write(" server: closed connection %s\n" % self.socket)
  811. def handle_error(self):
  812. raise
  813. def __init__(self, certfile):
  814. self.certfile = certfile
  815. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  816. self.port = support.bind_port(sock, '')
  817. asyncore.dispatcher.__init__(self, sock)
  818. self.listen(5)
  819. def handle_accepted(self, sock_obj, addr):
  820. if support.verbose:
  821. sys.stdout.write(" server: new connection from %s:%s\n" %addr)
  822. self.ConnectionHandler(sock_obj, self.certfile)
  823. def handle_error(self):
  824. raise
  825. def __init__(self, certfile):
  826. self.flag = None
  827. self.active = False
  828. self.server = self.EchoServer(certfile)
  829. self.port = self.server.port
  830. threading.Thread.__init__(self)
  831. self.daemon = True
  832. def __str__(self):
  833. return "<%s %s>" % (self.__class__.__name__, self.server)
  834. def start (self, flag=None):
  835. self.flag = flag
  836. threading.Thread.start(self)
  837. def run(self):
  838. self.active = True
  839. if self.flag:
  840. self.flag.set()
  841. while self.active:
  842. try:
  843. asyncore.loop(1)
  844. except:
  845. pass
  846. def stop(self):
  847. self.active = False
  848. self.server.close()
  849. def bad_cert_test(certfile):
  850. """
  851. Launch a server with CERT_REQUIRED, and check that trying to
  852. connect to it with the given client certificate fails.
  853. """
  854. server = ThreadedEchoServer(CERTFILE,
  855. certreqs=ssl.CERT_REQUIRED,
  856. cacerts=CERTFILE, chatty=False,
  857. connectionchatty=False)
  858. flag = threading.Event()
  859. server.start(flag)
  860. # wait for it to start
  861. flag.wait()
  862. # try to connect
  863. try:
  864. try:
  865. with socket.socket() as sock:
  866. s = ssl.wrap_socket(sock,
  867. certfile=certfile,
  868. ssl_version=ssl.PROTOCOL_TLSv1)
  869. s.connect((HOST, server.port))
  870. except ssl.SSLError as x:
  871. if support.verbose:
  872. sys.stdout.write("\nSSLError is %s\n" % x.args[1])
  873. except socket.error as x:
  874. if support.verbose:
  875. sys.stdout.write("\nsocket.error is %s\n" % x.args[1])
  876. except IOError as x:
  877. if x.errno != errno.ENOENT:
  878. raise
  879. if support.verbose:
  880. sys.stdout.write("\IOError is %s\n" % str(x))
  881. else:
  882. raise AssertionError("Use of invalid cert should have failed!")
  883. finally:
  884. server.stop()
  885. server.join()
  886. def server_params_test(client_context, server_context, indata=b"FOO\n",
  887. chatty=True, connectionchatty=False):
  888. """
  889. Launch a server, connect a client to it and try various reads
  890. and writes.
  891. """
  892. server = ThreadedEchoServer(context=server_context,
  893. chatty=chatty,
  894. connectionchatty=False)
  895. flag = threading.Event()
  896. server.start(flag)
  897. # wait for it to start
  898. flag.wait()
  899. # try to connect
  900. try:
  901. s = client_context.wrap_socket(socket.socket())
  902. s.connect((HOST, server.port))
  903. for arg in [indata, bytearray(indata), memoryview(indata)]:
  904. if connectionchatty:
  905. if support.verbose:
  906. sys.stdout.write(
  907. " client: sending %r...\n" % indata)
  908. s.write(arg)
  909. outdata = s.read()
  910. if connectionchatty:
  911. if support.verbose:
  912. sys.stdout.write(" client: read %r\n" % outdata)
  913. if outdata != indata.lower():
  914. raise AssertionError(
  915. "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
  916. % (outdata[:20], len(outdata),
  917. indata[:20].lower(), len(indata)))
  918. s.write(b"over\n")
  919. if connectionchatty:
  920. if support.verbose:
  921. sys.stdout.write(" client: closing connection.\n")
  922. s.close()
  923. finally:
  924. server.stop()
  925. server.join()
  926. def try_protocol_combo(server_protocol, client_protocol, expect_success,
  927. certsreqs=None, server_options=0, client_options=0):
  928. if certsreqs is None:
  929. certsreqs = ssl.CERT_NONE
  930. certtype = {
  931. ssl.CERT_NONE: "CERT_NONE",
  932. ssl.CERT_OPTIONAL: "CERT_OPTIONAL",
  933. ssl.CERT_REQUIRED: "CERT_REQUIRED",
  934. }[certsreqs]
  935. if support.verbose:
  936. formatstr = (expect_success and " %s->%s %s\n") or " {%s->%s} %s\n"
  937. sys.stdout.write(formatstr %
  938. (ssl.get_protocol_name(client_protocol),
  939. ssl.get_protocol_name(server_protocol),
  940. certtype))
  941. client_context = ssl.SSLContext(client_protocol)
  942. client_context.options = ssl.OP_ALL | client_options
  943. server_context = ssl.SSLContext(server_protocol)
  944. server_context.options = ssl.OP_ALL | server_options
  945. for ctx in (client_context, server_context):
  946. ctx.verify_mode = certsreqs
  947. # NOTE: we must enable "ALL" ciphers, otherwise an SSLv23 client
  948. # will send an SSLv3 hello (rather than SSLv2) starting from
  949. # OpenSSL 1.0.0 (see issue #8322).
  950. ctx.set_ciphers("ALL")
  951. ctx.load_cert_chain(CERTFILE)
  952. ctx.load_verify_locations(CERTFILE)
  953. try:
  954. server_params_test(client_context, server_context,
  955. chatty=False, connectionchatty=False)
  956. # Protocol mismatch can result in either an SSLError, or a
  957. # "Connection reset by peer" error.
  958. except ssl.SSLError:
  959. if expect_success:
  960. raise
  961. except socket.error as e:
  962. if expect_success or e.errno != errno.ECONNRESET:
  963. raise
  964. else:
  965. if not expect_success:
  966. raise AssertionError(
  967. "Client protocol %s succeeded with server protocol %s!"
  968. % (ssl.get_protocol_name(client_protocol),
  969. ssl.get_protocol_name(server_protocol)))
  970. class ThreadedTests(unittest.TestCase):
  971. @skip_if_broken_ubuntu_ssl
  972. def test_echo(self):
  973. """Basic test of an SSL client connecting to a server"""
  974. if support.verbose:
  975. sys.stdout.write("\n")
  976. for protocol in PROTOCOLS:
  977. context = ssl.SSLContext(protocol)
  978. context.load_cert_chain(CERTFILE)
  979. server_params_test(context, context,
  980. chatty=True, connectionchatty=True)
  981. def test_getpeercert(self):
  982. if support.verbose:
  983. sys.stdout.write("\n")
  984. context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  985. context.verify_mode = ssl.CERT_REQUIRED
  986. context.load_verify_locations(CERTFILE)
  987. context.load_cert_chain(CERTFILE)
  988. server = ThreadedEchoServer(context=context, chatty=False)
  989. flag = threading.Event()
  990. server.start(flag)
  991. # wait for it to start
  992. flag.wait()
  993. # try to connect
  994. try:
  995. s = context.wrap_socket(socket.socket())
  996. s.connect((HOST, server.port))
  997. cert = s.getpeercert()
  998. self.assertTrue(cert, "Can't get peer certificate.")
  999. cipher = s.cipher()
  1000. if support.verbose:
  1001. sys.stdout.write(pprint.pformat(cert) + '\n')
  1002. sys.stdout.write("Connection cipher is " + str(cipher) + '.\n')
  1003. if 'subject' not in cert:
  1004. self.fail("No subject field in certificate: %s." %
  1005. pprint.pformat(cert))
  1006. if ((('organizationName', 'Python Software Foundation'),)
  1007. not in cert['subject']):
  1008. self.fail(
  1009. "Missing or invalid 'organizationName' field in certificate subject; "
  1010. "should be 'Python Software Foundation'.")
  1011. self.assertIn('notBefore', cert)
  1012. self.assertIn('notAfter', cert)
  1013. before = ssl.cert_time_to_seconds(cert['notBefore'])
  1014. after = ssl.cert_time_to_seconds(cert['notAfter'])
  1015. self.assertLess(before, after)
  1016. s.close()
  1017. finally:
  1018. server.stop()
  1019. server.join()
  1020. def test_empty_cert(self):
  1021. """Connecting with an empty cert file"""
  1022. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1023. "nullcert.pem"))
  1024. def test_malformed_cert(self):
  1025. """Connecting with a badly formatted certificate (syntax error)"""
  1026. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1027. "badcert.pem"))
  1028. def test_nonexisting_cert(self):
  1029. """Connecting with a non-existing cert file"""
  1030. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1031. "wrongcert.pem"))
  1032. def test_malformed_key(self):
  1033. """Connecting with a badly formatted key (syntax error)"""
  1034. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1035. "badkey.pem"))
  1036. def test_rude_shutdown(self):
  1037. """A brutal shutdown of an SSL server should raise an IOError
  1038. in the client when attempting handshake.
  1039. """
  1040. listener_ready = threading.Event()
  1041. listener_gone = threading.Event()
  1042. s = socket.socket()
  1043. port = support.bind_port(s, HOST)
  1044. # `listener` runs in a thread. It sits in an accept() until
  1045. # the main thread connects. Then it rudely closes the socket,
  1046. # and sets Event `listener_gone` to let the main thread know
  1047. # the socket is gone.
  1048. def listener():
  1049. s.listen(5)
  1050. listener_ready.set()
  1051. newsock, addr = s.accept()
  1052. newsock.close()
  1053. s.close()
  1054. listener_gone.set()
  1055. def connector():
  1056. listener_ready.wait()
  1057. with socket.socket() as c:
  1058. c.connect((HOST, port))
  1059. listener_gone.wait()
  1060. try:
  1061. ssl_sock = ssl.wrap_socket(c)
  1062. except IOError:
  1063. pass
  1064. else:
  1065. self.fail('connecting to closed SSL socket should have failed')
  1066. t = threading.Thread(target=listener)
  1067. t.start()
  1068. try:
  1069. connector()
  1070. finally:
  1071. t.join()
  1072. @skip_if_broken_ubuntu_ssl
  1073. def test_protocol_sslv2(self):
  1074. """Connecting to an SSLv2 server with various client options"""
  1075. if support.verbose:
  1076. sys.stdout.write("\n")
  1077. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv2, True)
  1078. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv2, True, ssl.CERT_OPTIONAL)
  1079. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv2, Tr

Large files files are truncated, but you can click here to view the full file