PageRenderTime 31ms CodeModel.GetById 29ms RepoModel.GetById 0ms app.codeStats 1ms

/Lib/test/test_ssl.py

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

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