PageRenderTime 58ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 0ms

/Lib/test/test_ssl.py

https://bitbucket.org/ndelrosario/cpython
Python | 2024 lines | 1838 code | 94 blank | 92 comment | 193 complexity | a7892e9171856055314ab68d6eaaa436 MD5 | raw file
Possible License(s): BSD-3-Clause, 0BSD
  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. SVN_PYTHON_ORG_ROOT_CERT = data_file("https_svn_python_org_root.pem")
  44. EMPTYCERT = data_file("nullcert.pem")
  45. BADCERT = data_file("badcert.pem")
  46. WRONGCERT = data_file("XXXnonexisting.pem")
  47. BADKEY = data_file("badkey.pem")
  48. NOKIACERT = data_file("nokia.pem")
  49. DHFILE = data_file("dh512.pem")
  50. BYTES_DHFILE = os.fsencode(DHFILE)
  51. def handle_error(prefix):
  52. exc_format = ' '.join(traceback.format_exception(*sys.exc_info()))
  53. if support.verbose:
  54. sys.stdout.write(prefix + exc_format)
  55. def can_clear_options():
  56. # 0.9.8m or higher
  57. return ssl._OPENSSL_API_VERSION >= (0, 9, 8, 13, 15)
  58. def no_sslv2_implies_sslv3_hello():
  59. # 0.9.7h or higher
  60. return ssl.OPENSSL_VERSION_INFO >= (0, 9, 7, 8, 15)
  61. # Issue #9415: Ubuntu hijacks their OpenSSL and forcefully disables SSLv2
  62. def skip_if_broken_ubuntu_ssl(func):
  63. if hasattr(ssl, 'PROTOCOL_SSLv2'):
  64. @functools.wraps(func)
  65. def f(*args, **kwargs):
  66. try:
  67. ssl.SSLContext(ssl.PROTOCOL_SSLv2)
  68. except ssl.SSLError:
  69. if (ssl.OPENSSL_VERSION_INFO == (0, 9, 8, 15, 15) and
  70. platform.linux_distribution() == ('debian', 'squeeze/sid', '')):
  71. raise unittest.SkipTest("Patched Ubuntu OpenSSL breaks behaviour")
  72. return func(*args, **kwargs)
  73. return f
  74. else:
  75. return func
  76. class BasicSocketTests(unittest.TestCase):
  77. def test_constants(self):
  78. #ssl.PROTOCOL_SSLv2
  79. ssl.PROTOCOL_SSLv23
  80. ssl.PROTOCOL_SSLv3
  81. ssl.PROTOCOL_TLSv1
  82. ssl.CERT_NONE
  83. ssl.CERT_OPTIONAL
  84. ssl.CERT_REQUIRED
  85. ssl.OP_CIPHER_SERVER_PREFERENCE
  86. ssl.OP_SINGLE_DH_USE
  87. if ssl.HAS_ECDH:
  88. ssl.OP_SINGLE_ECDH_USE
  89. if ssl.OPENSSL_VERSION_INFO >= (1, 0):
  90. ssl.OP_NO_COMPRESSION
  91. self.assertIn(ssl.HAS_SNI, {True, False})
  92. self.assertIn(ssl.HAS_ECDH, {True, False})
  93. def test_random(self):
  94. v = ssl.RAND_status()
  95. if support.verbose:
  96. sys.stdout.write("\n RAND_status is %d (%s)\n"
  97. % (v, (v and "sufficient randomness") or
  98. "insufficient randomness"))
  99. data, is_cryptographic = ssl.RAND_pseudo_bytes(16)
  100. self.assertEqual(len(data), 16)
  101. self.assertEqual(is_cryptographic, v == 1)
  102. if v:
  103. data = ssl.RAND_bytes(16)
  104. self.assertEqual(len(data), 16)
  105. else:
  106. self.assertRaises(ssl.SSLError, ssl.RAND_bytes, 16)
  107. self.assertRaises(TypeError, ssl.RAND_egd, 1)
  108. self.assertRaises(TypeError, ssl.RAND_egd, 'foo', 1)
  109. ssl.RAND_add("this is a random string", 75.0)
  110. def test_parse_cert(self):
  111. # note that this uses an 'unofficial' function in _ssl.c,
  112. # provided solely for this test, to exercise the certificate
  113. # parsing code
  114. p = ssl._ssl._test_decode_cert(CERTFILE)
  115. if support.verbose:
  116. sys.stdout.write("\n" + pprint.pformat(p) + "\n")
  117. self.assertEqual(p['issuer'],
  118. ((('countryName', 'XY'),),
  119. (('localityName', 'Castle Anthrax'),),
  120. (('organizationName', 'Python Software Foundation'),),
  121. (('commonName', 'localhost'),))
  122. )
  123. self.assertEqual(p['notAfter'], 'Oct 5 23:01:56 2020 GMT')
  124. self.assertEqual(p['notBefore'], 'Oct 8 23:01:56 2010 GMT')
  125. self.assertEqual(p['serialNumber'], 'D7C7381919AFC24E')
  126. self.assertEqual(p['subject'],
  127. ((('countryName', 'XY'),),
  128. (('localityName', 'Castle Anthrax'),),
  129. (('organizationName', 'Python Software Foundation'),),
  130. (('commonName', 'localhost'),))
  131. )
  132. self.assertEqual(p['subjectAltName'], (('DNS', 'localhost'),))
  133. # Issue #13034: the subjectAltName in some certificates
  134. # (notably projects.developer.nokia.com:443) wasn't parsed
  135. p = ssl._ssl._test_decode_cert(NOKIACERT)
  136. if support.verbose:
  137. sys.stdout.write("\n" + pprint.pformat(p) + "\n")
  138. self.assertEqual(p['subjectAltName'],
  139. (('DNS', 'projects.developer.nokia.com'),
  140. ('DNS', 'projects.forum.nokia.com'))
  141. )
  142. def test_DER_to_PEM(self):
  143. with open(SVN_PYTHON_ORG_ROOT_CERT, 'r') as f:
  144. pem = f.read()
  145. d1 = ssl.PEM_cert_to_DER_cert(pem)
  146. p2 = ssl.DER_cert_to_PEM_cert(d1)
  147. d2 = ssl.PEM_cert_to_DER_cert(p2)
  148. self.assertEqual(d1, d2)
  149. if not p2.startswith(ssl.PEM_HEADER + '\n'):
  150. self.fail("DER-to-PEM didn't include correct header:\n%r\n" % p2)
  151. if not p2.endswith('\n' + ssl.PEM_FOOTER + '\n'):
  152. self.fail("DER-to-PEM didn't include correct footer:\n%r\n" % p2)
  153. def test_openssl_version(self):
  154. n = ssl.OPENSSL_VERSION_NUMBER
  155. t = ssl.OPENSSL_VERSION_INFO
  156. s = ssl.OPENSSL_VERSION
  157. self.assertIsInstance(n, int)
  158. self.assertIsInstance(t, tuple)
  159. self.assertIsInstance(s, str)
  160. # Some sanity checks follow
  161. # >= 0.9
  162. self.assertGreaterEqual(n, 0x900000)
  163. # < 2.0
  164. self.assertLess(n, 0x20000000)
  165. major, minor, fix, patch, status = t
  166. self.assertGreaterEqual(major, 0)
  167. self.assertLess(major, 2)
  168. self.assertGreaterEqual(minor, 0)
  169. self.assertLess(minor, 256)
  170. self.assertGreaterEqual(fix, 0)
  171. self.assertLess(fix, 256)
  172. self.assertGreaterEqual(patch, 0)
  173. self.assertLessEqual(patch, 26)
  174. self.assertGreaterEqual(status, 0)
  175. self.assertLessEqual(status, 15)
  176. # Version string as returned by OpenSSL, the format might change
  177. self.assertTrue(s.startswith("OpenSSL {:d}.{:d}.{:d}".format(major, minor, fix)),
  178. (s, t))
  179. @support.cpython_only
  180. def test_refcycle(self):
  181. # Issue #7943: an SSL object doesn't create reference cycles with
  182. # itself.
  183. s = socket.socket(socket.AF_INET)
  184. ss = ssl.wrap_socket(s)
  185. wr = weakref.ref(ss)
  186. del ss
  187. self.assertEqual(wr(), None)
  188. def test_wrapped_unconnected(self):
  189. # Methods on an unconnected SSLSocket propagate the original
  190. # socket.error raise by the underlying socket object.
  191. s = socket.socket(socket.AF_INET)
  192. ss = ssl.wrap_socket(s)
  193. self.assertRaises(socket.error, ss.recv, 1)
  194. self.assertRaises(socket.error, ss.recv_into, bytearray(b'x'))
  195. self.assertRaises(socket.error, ss.recvfrom, 1)
  196. self.assertRaises(socket.error, ss.recvfrom_into, bytearray(b'x'), 1)
  197. self.assertRaises(socket.error, ss.send, b'x')
  198. self.assertRaises(socket.error, ss.sendto, b'x', ('0.0.0.0', 0))
  199. def test_timeout(self):
  200. # Issue #8524: when creating an SSL socket, the timeout of the
  201. # original socket should be retained.
  202. for timeout in (None, 0.0, 5.0):
  203. s = socket.socket(socket.AF_INET)
  204. s.settimeout(timeout)
  205. ss = ssl.wrap_socket(s)
  206. self.assertEqual(timeout, ss.gettimeout())
  207. def test_errors(self):
  208. sock = socket.socket()
  209. self.assertRaisesRegex(ValueError,
  210. "certfile must be specified",
  211. ssl.wrap_socket, sock, keyfile=CERTFILE)
  212. self.assertRaisesRegex(ValueError,
  213. "certfile must be specified for server-side operations",
  214. ssl.wrap_socket, sock, server_side=True)
  215. self.assertRaisesRegex(ValueError,
  216. "certfile must be specified for server-side operations",
  217. ssl.wrap_socket, sock, server_side=True, certfile="")
  218. s = ssl.wrap_socket(sock, server_side=True, certfile=CERTFILE)
  219. self.assertRaisesRegex(ValueError, "can't connect in server-side mode",
  220. s.connect, (HOST, 8080))
  221. with self.assertRaises(IOError) as cm:
  222. with socket.socket() as sock:
  223. ssl.wrap_socket(sock, certfile=WRONGCERT)
  224. self.assertEqual(cm.exception.errno, errno.ENOENT)
  225. with self.assertRaises(IOError) as cm:
  226. with socket.socket() as sock:
  227. ssl.wrap_socket(sock, certfile=CERTFILE, keyfile=WRONGCERT)
  228. self.assertEqual(cm.exception.errno, errno.ENOENT)
  229. with self.assertRaises(IOError) as cm:
  230. with socket.socket() as sock:
  231. ssl.wrap_socket(sock, certfile=WRONGCERT, keyfile=WRONGCERT)
  232. self.assertEqual(cm.exception.errno, errno.ENOENT)
  233. def test_match_hostname(self):
  234. def ok(cert, hostname):
  235. ssl.match_hostname(cert, hostname)
  236. def fail(cert, hostname):
  237. self.assertRaises(ssl.CertificateError,
  238. ssl.match_hostname, cert, hostname)
  239. cert = {'subject': ((('commonName', 'example.com'),),)}
  240. ok(cert, 'example.com')
  241. ok(cert, 'ExAmple.cOm')
  242. fail(cert, 'www.example.com')
  243. fail(cert, '.example.com')
  244. fail(cert, 'example.org')
  245. fail(cert, 'exampleXcom')
  246. cert = {'subject': ((('commonName', '*.a.com'),),)}
  247. ok(cert, 'foo.a.com')
  248. fail(cert, 'bar.foo.a.com')
  249. fail(cert, 'a.com')
  250. fail(cert, 'Xa.com')
  251. fail(cert, '.a.com')
  252. cert = {'subject': ((('commonName', 'a.*.com'),),)}
  253. ok(cert, 'a.foo.com')
  254. fail(cert, 'a..com')
  255. fail(cert, 'a.com')
  256. cert = {'subject': ((('commonName', 'f*.com'),),)}
  257. ok(cert, 'foo.com')
  258. ok(cert, 'f.com')
  259. fail(cert, 'bar.com')
  260. fail(cert, 'foo.a.com')
  261. fail(cert, 'bar.foo.com')
  262. # Slightly fake real-world example
  263. cert = {'notAfter': 'Jun 26 21:41:46 2011 GMT',
  264. 'subject': ((('commonName', 'linuxfrz.org'),),),
  265. 'subjectAltName': (('DNS', 'linuxfr.org'),
  266. ('DNS', 'linuxfr.com'),
  267. ('othername', '<unsupported>'))}
  268. ok(cert, 'linuxfr.org')
  269. ok(cert, 'linuxfr.com')
  270. # Not a "DNS" entry
  271. fail(cert, '<unsupported>')
  272. # When there is a subjectAltName, commonName isn't used
  273. fail(cert, 'linuxfrz.org')
  274. # A pristine real-world example
  275. cert = {'notAfter': 'Dec 18 23:59:59 2011 GMT',
  276. 'subject': ((('countryName', 'US'),),
  277. (('stateOrProvinceName', 'California'),),
  278. (('localityName', 'Mountain View'),),
  279. (('organizationName', 'Google Inc'),),
  280. (('commonName', 'mail.google.com'),))}
  281. ok(cert, 'mail.google.com')
  282. fail(cert, 'gmail.com')
  283. # Only commonName is considered
  284. fail(cert, 'California')
  285. # Neither commonName nor subjectAltName
  286. cert = {'notAfter': 'Dec 18 23:59:59 2011 GMT',
  287. 'subject': ((('countryName', 'US'),),
  288. (('stateOrProvinceName', 'California'),),
  289. (('localityName', 'Mountain View'),),
  290. (('organizationName', 'Google Inc'),))}
  291. fail(cert, 'mail.google.com')
  292. # No DNS entry in subjectAltName but a commonName
  293. cert = {'notAfter': 'Dec 18 23:59:59 2099 GMT',
  294. 'subject': ((('countryName', 'US'),),
  295. (('stateOrProvinceName', 'California'),),
  296. (('localityName', 'Mountain View'),),
  297. (('commonName', 'mail.google.com'),)),
  298. 'subjectAltName': (('othername', 'blabla'), )}
  299. ok(cert, 'mail.google.com')
  300. # No DNS entry subjectAltName and no commonName
  301. cert = {'notAfter': 'Dec 18 23:59:59 2099 GMT',
  302. 'subject': ((('countryName', 'US'),),
  303. (('stateOrProvinceName', 'California'),),
  304. (('localityName', 'Mountain View'),),
  305. (('organizationName', 'Google Inc'),)),
  306. 'subjectAltName': (('othername', 'blabla'),)}
  307. fail(cert, 'google.com')
  308. # Empty cert / no cert
  309. self.assertRaises(ValueError, ssl.match_hostname, None, 'example.com')
  310. self.assertRaises(ValueError, ssl.match_hostname, {}, 'example.com')
  311. def test_server_side(self):
  312. # server_hostname doesn't work for server sockets
  313. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  314. with socket.socket() as sock:
  315. self.assertRaises(ValueError, ctx.wrap_socket, sock, True,
  316. server_hostname="some.hostname")
  317. def test_unknown_channel_binding(self):
  318. # should raise ValueError for unknown type
  319. s = socket.socket(socket.AF_INET)
  320. ss = ssl.wrap_socket(s)
  321. with self.assertRaises(ValueError):
  322. ss.get_channel_binding("unknown-type")
  323. @unittest.skipUnless("tls-unique" in ssl.CHANNEL_BINDING_TYPES,
  324. "'tls-unique' channel binding not available")
  325. def test_tls_unique_channel_binding(self):
  326. # unconnected should return None for known type
  327. s = socket.socket(socket.AF_INET)
  328. ss = ssl.wrap_socket(s)
  329. self.assertIsNone(ss.get_channel_binding("tls-unique"))
  330. # the same for server-side
  331. s = socket.socket(socket.AF_INET)
  332. ss = ssl.wrap_socket(s, server_side=True, certfile=CERTFILE)
  333. self.assertIsNone(ss.get_channel_binding("tls-unique"))
  334. class ContextTests(unittest.TestCase):
  335. @skip_if_broken_ubuntu_ssl
  336. def test_constructor(self):
  337. if hasattr(ssl, 'PROTOCOL_SSLv2'):
  338. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv2)
  339. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  340. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv3)
  341. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  342. self.assertRaises(TypeError, ssl.SSLContext)
  343. self.assertRaises(ValueError, ssl.SSLContext, -1)
  344. self.assertRaises(ValueError, ssl.SSLContext, 42)
  345. @skip_if_broken_ubuntu_ssl
  346. def test_protocol(self):
  347. for proto in PROTOCOLS:
  348. ctx = ssl.SSLContext(proto)
  349. self.assertEqual(ctx.protocol, proto)
  350. def test_ciphers(self):
  351. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  352. ctx.set_ciphers("ALL")
  353. ctx.set_ciphers("DEFAULT")
  354. with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
  355. ctx.set_ciphers("^$:,;?*'dorothyx")
  356. @skip_if_broken_ubuntu_ssl
  357. def test_options(self):
  358. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  359. # OP_ALL is the default value
  360. self.assertEqual(ssl.OP_ALL, ctx.options)
  361. ctx.options |= ssl.OP_NO_SSLv2
  362. self.assertEqual(ssl.OP_ALL | ssl.OP_NO_SSLv2,
  363. ctx.options)
  364. ctx.options |= ssl.OP_NO_SSLv3
  365. self.assertEqual(ssl.OP_ALL | ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3,
  366. ctx.options)
  367. if can_clear_options():
  368. ctx.options = (ctx.options & ~ssl.OP_NO_SSLv2) | ssl.OP_NO_TLSv1
  369. self.assertEqual(ssl.OP_ALL | ssl.OP_NO_TLSv1 | ssl.OP_NO_SSLv3,
  370. ctx.options)
  371. ctx.options = 0
  372. self.assertEqual(0, ctx.options)
  373. else:
  374. with self.assertRaises(ValueError):
  375. ctx.options = 0
  376. def test_verify(self):
  377. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  378. # Default value
  379. self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
  380. ctx.verify_mode = ssl.CERT_OPTIONAL
  381. self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
  382. ctx.verify_mode = ssl.CERT_REQUIRED
  383. self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
  384. ctx.verify_mode = ssl.CERT_NONE
  385. self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
  386. with self.assertRaises(TypeError):
  387. ctx.verify_mode = None
  388. with self.assertRaises(ValueError):
  389. ctx.verify_mode = 42
  390. def test_load_cert_chain(self):
  391. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  392. # Combined key and cert in a single file
  393. ctx.load_cert_chain(CERTFILE)
  394. ctx.load_cert_chain(CERTFILE, keyfile=CERTFILE)
  395. self.assertRaises(TypeError, ctx.load_cert_chain, keyfile=CERTFILE)
  396. with self.assertRaises(IOError) as cm:
  397. ctx.load_cert_chain(WRONGCERT)
  398. self.assertEqual(cm.exception.errno, errno.ENOENT)
  399. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  400. ctx.load_cert_chain(BADCERT)
  401. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  402. ctx.load_cert_chain(EMPTYCERT)
  403. # Separate key and cert
  404. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  405. ctx.load_cert_chain(ONLYCERT, ONLYKEY)
  406. ctx.load_cert_chain(certfile=ONLYCERT, keyfile=ONLYKEY)
  407. ctx.load_cert_chain(certfile=BYTES_ONLYCERT, keyfile=BYTES_ONLYKEY)
  408. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  409. ctx.load_cert_chain(ONLYCERT)
  410. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  411. ctx.load_cert_chain(ONLYKEY)
  412. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  413. ctx.load_cert_chain(certfile=ONLYKEY, keyfile=ONLYCERT)
  414. # Mismatching key and cert
  415. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  416. with self.assertRaisesRegex(ssl.SSLError, "key values mismatch"):
  417. ctx.load_cert_chain(SVN_PYTHON_ORG_ROOT_CERT, ONLYKEY)
  418. # Password protected key and cert
  419. ctx.load_cert_chain(CERTFILE_PROTECTED, password=KEY_PASSWORD)
  420. ctx.load_cert_chain(CERTFILE_PROTECTED, password=KEY_PASSWORD.encode())
  421. ctx.load_cert_chain(CERTFILE_PROTECTED,
  422. password=bytearray(KEY_PASSWORD.encode()))
  423. ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED, KEY_PASSWORD)
  424. ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED, KEY_PASSWORD.encode())
  425. ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED,
  426. bytearray(KEY_PASSWORD.encode()))
  427. with self.assertRaisesRegex(TypeError, "should be a string"):
  428. ctx.load_cert_chain(CERTFILE_PROTECTED, password=True)
  429. with self.assertRaises(ssl.SSLError):
  430. ctx.load_cert_chain(CERTFILE_PROTECTED, password="badpass")
  431. with self.assertRaisesRegex(ValueError, "cannot be longer"):
  432. # openssl has a fixed limit on the password buffer.
  433. # PEM_BUFSIZE is generally set to 1kb.
  434. # Return a string larger than this.
  435. ctx.load_cert_chain(CERTFILE_PROTECTED, password=b'a' * 102400)
  436. # Password callback
  437. def getpass_unicode():
  438. return KEY_PASSWORD
  439. def getpass_bytes():
  440. return KEY_PASSWORD.encode()
  441. def getpass_bytearray():
  442. return bytearray(KEY_PASSWORD.encode())
  443. def getpass_badpass():
  444. return "badpass"
  445. def getpass_huge():
  446. return b'a' * (1024 * 1024)
  447. def getpass_bad_type():
  448. return 9
  449. def getpass_exception():
  450. raise Exception('getpass error')
  451. class GetPassCallable:
  452. def __call__(self):
  453. return KEY_PASSWORD
  454. def getpass(self):
  455. return KEY_PASSWORD
  456. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_unicode)
  457. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bytes)
  458. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bytearray)
  459. ctx.load_cert_chain(CERTFILE_PROTECTED, password=GetPassCallable())
  460. ctx.load_cert_chain(CERTFILE_PROTECTED,
  461. password=GetPassCallable().getpass)
  462. with self.assertRaises(ssl.SSLError):
  463. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_badpass)
  464. with self.assertRaisesRegex(ValueError, "cannot be longer"):
  465. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_huge)
  466. with self.assertRaisesRegex(TypeError, "must return a string"):
  467. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bad_type)
  468. with self.assertRaisesRegex(Exception, "getpass error"):
  469. ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_exception)
  470. # Make sure the password function isn't called if it isn't needed
  471. ctx.load_cert_chain(CERTFILE, password=getpass_exception)
  472. def test_load_verify_locations(self):
  473. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  474. ctx.load_verify_locations(CERTFILE)
  475. ctx.load_verify_locations(cafile=CERTFILE, capath=None)
  476. ctx.load_verify_locations(BYTES_CERTFILE)
  477. ctx.load_verify_locations(cafile=BYTES_CERTFILE, capath=None)
  478. self.assertRaises(TypeError, ctx.load_verify_locations)
  479. self.assertRaises(TypeError, ctx.load_verify_locations, None, None)
  480. with self.assertRaises(IOError) as cm:
  481. ctx.load_verify_locations(WRONGCERT)
  482. self.assertEqual(cm.exception.errno, errno.ENOENT)
  483. with self.assertRaisesRegex(ssl.SSLError, "PEM lib"):
  484. ctx.load_verify_locations(BADCERT)
  485. ctx.load_verify_locations(CERTFILE, CAPATH)
  486. ctx.load_verify_locations(CERTFILE, capath=BYTES_CAPATH)
  487. # Issue #10989: crash if the second argument type is invalid
  488. self.assertRaises(TypeError, ctx.load_verify_locations, None, True)
  489. def test_load_dh_params(self):
  490. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  491. ctx.load_dh_params(DHFILE)
  492. if os.name != 'nt':
  493. ctx.load_dh_params(BYTES_DHFILE)
  494. self.assertRaises(TypeError, ctx.load_dh_params)
  495. self.assertRaises(TypeError, ctx.load_dh_params, None)
  496. with self.assertRaises(FileNotFoundError) as cm:
  497. ctx.load_dh_params(WRONGCERT)
  498. self.assertEqual(cm.exception.errno, errno.ENOENT)
  499. with self.assertRaises(ssl.SSLError) as cm:
  500. ctx.load_dh_params(CERTFILE)
  501. @skip_if_broken_ubuntu_ssl
  502. def test_session_stats(self):
  503. for proto in PROTOCOLS:
  504. ctx = ssl.SSLContext(proto)
  505. self.assertEqual(ctx.session_stats(), {
  506. 'number': 0,
  507. 'connect': 0,
  508. 'connect_good': 0,
  509. 'connect_renegotiate': 0,
  510. 'accept': 0,
  511. 'accept_good': 0,
  512. 'accept_renegotiate': 0,
  513. 'hits': 0,
  514. 'misses': 0,
  515. 'timeouts': 0,
  516. 'cache_full': 0,
  517. })
  518. def test_set_default_verify_paths(self):
  519. # There's not much we can do to test that it acts as expected,
  520. # so just check it doesn't crash or raise an exception.
  521. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  522. ctx.set_default_verify_paths()
  523. @unittest.skipUnless(ssl.HAS_ECDH, "ECDH disabled on this OpenSSL build")
  524. def test_set_ecdh_curve(self):
  525. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  526. ctx.set_ecdh_curve("prime256v1")
  527. ctx.set_ecdh_curve(b"prime256v1")
  528. self.assertRaises(TypeError, ctx.set_ecdh_curve)
  529. self.assertRaises(TypeError, ctx.set_ecdh_curve, None)
  530. self.assertRaises(ValueError, ctx.set_ecdh_curve, "foo")
  531. self.assertRaises(ValueError, ctx.set_ecdh_curve, b"foo")
  532. class SSLErrorTests(unittest.TestCase):
  533. def test_str(self):
  534. # The str() of a SSLError doesn't include the errno
  535. e = ssl.SSLError(1, "foo")
  536. self.assertEqual(str(e), "foo")
  537. self.assertEqual(e.errno, 1)
  538. # Same for a subclass
  539. e = ssl.SSLZeroReturnError(1, "foo")
  540. self.assertEqual(str(e), "foo")
  541. self.assertEqual(e.errno, 1)
  542. def test_lib_reason(self):
  543. # Test the library and reason attributes
  544. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  545. with self.assertRaises(ssl.SSLError) as cm:
  546. ctx.load_dh_params(CERTFILE)
  547. self.assertEqual(cm.exception.library, 'PEM')
  548. self.assertEqual(cm.exception.reason, 'NO_START_LINE')
  549. s = str(cm.exception)
  550. self.assertTrue(s.startswith("[PEM: NO_START_LINE] no start line"), s)
  551. def test_subclass(self):
  552. # Check that the appropriate SSLError subclass is raised
  553. # (this only tests one of them)
  554. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  555. with socket.socket() as s:
  556. s.bind(("127.0.0.1", 0))
  557. s.listen(5)
  558. with socket.socket() as c:
  559. c.connect(s.getsockname())
  560. c.setblocking(False)
  561. c = ctx.wrap_socket(c, False, do_handshake_on_connect=False)
  562. with self.assertRaises(ssl.SSLWantReadError) as cm:
  563. c.do_handshake()
  564. s = str(cm.exception)
  565. self.assertTrue(s.startswith("The operation did not complete (read)"), s)
  566. # For compatibility
  567. self.assertEqual(cm.exception.errno, ssl.SSL_ERROR_WANT_READ)
  568. class NetworkedTests(unittest.TestCase):
  569. def test_connect(self):
  570. with support.transient_internet("svn.python.org"):
  571. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  572. cert_reqs=ssl.CERT_NONE)
  573. try:
  574. s.connect(("svn.python.org", 443))
  575. self.assertEqual({}, s.getpeercert())
  576. finally:
  577. s.close()
  578. # this should fail because we have no verification certs
  579. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  580. cert_reqs=ssl.CERT_REQUIRED)
  581. self.assertRaisesRegex(ssl.SSLError, "certificate verify failed",
  582. s.connect, ("svn.python.org", 443))
  583. s.close()
  584. # this should succeed because we specify the root cert
  585. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  586. cert_reqs=ssl.CERT_REQUIRED,
  587. ca_certs=SVN_PYTHON_ORG_ROOT_CERT)
  588. try:
  589. s.connect(("svn.python.org", 443))
  590. self.assertTrue(s.getpeercert())
  591. finally:
  592. s.close()
  593. def test_connect_ex(self):
  594. # Issue #11326: check connect_ex() implementation
  595. with support.transient_internet("svn.python.org"):
  596. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  597. cert_reqs=ssl.CERT_REQUIRED,
  598. ca_certs=SVN_PYTHON_ORG_ROOT_CERT)
  599. try:
  600. self.assertEqual(0, s.connect_ex(("svn.python.org", 443)))
  601. self.assertTrue(s.getpeercert())
  602. finally:
  603. s.close()
  604. def test_non_blocking_connect_ex(self):
  605. # Issue #11326: non-blocking connect_ex() should allow handshake
  606. # to proceed after the socket gets ready.
  607. with support.transient_internet("svn.python.org"):
  608. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  609. cert_reqs=ssl.CERT_REQUIRED,
  610. ca_certs=SVN_PYTHON_ORG_ROOT_CERT,
  611. do_handshake_on_connect=False)
  612. try:
  613. s.setblocking(False)
  614. rc = s.connect_ex(('svn.python.org', 443))
  615. # EWOULDBLOCK under Windows, EINPROGRESS elsewhere
  616. self.assertIn(rc, (0, errno.EINPROGRESS, errno.EWOULDBLOCK))
  617. # Wait for connect to finish
  618. select.select([], [s], [], 5.0)
  619. # Non-blocking handshake
  620. while True:
  621. try:
  622. s.do_handshake()
  623. break
  624. except ssl.SSLWantReadError:
  625. select.select([s], [], [], 5.0)
  626. except ssl.SSLWantWriteError:
  627. select.select([], [s], [], 5.0)
  628. # SSL established
  629. self.assertTrue(s.getpeercert())
  630. finally:
  631. s.close()
  632. def test_timeout_connect_ex(self):
  633. # Issue #12065: on a timeout, connect_ex() should return the original
  634. # errno (mimicking the behaviour of non-SSL sockets).
  635. with support.transient_internet("svn.python.org"):
  636. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  637. cert_reqs=ssl.CERT_REQUIRED,
  638. ca_certs=SVN_PYTHON_ORG_ROOT_CERT,
  639. do_handshake_on_connect=False)
  640. try:
  641. s.settimeout(0.0000001)
  642. rc = s.connect_ex(('svn.python.org', 443))
  643. if rc == 0:
  644. self.skipTest("svn.python.org responded too quickly")
  645. self.assertIn(rc, (errno.EAGAIN, errno.EWOULDBLOCK))
  646. finally:
  647. s.close()
  648. def test_connect_with_context(self):
  649. with support.transient_internet("svn.python.org"):
  650. # Same as test_connect, but with a separately created context
  651. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  652. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  653. s.connect(("svn.python.org", 443))
  654. try:
  655. self.assertEqual({}, s.getpeercert())
  656. finally:
  657. s.close()
  658. # Same with a server hostname
  659. s = ctx.wrap_socket(socket.socket(socket.AF_INET),
  660. server_hostname="svn.python.org")
  661. if ssl.HAS_SNI:
  662. s.connect(("svn.python.org", 443))
  663. s.close()
  664. else:
  665. self.assertRaises(ValueError, s.connect, ("svn.python.org", 443))
  666. # This should fail because we have no verification certs
  667. ctx.verify_mode = ssl.CERT_REQUIRED
  668. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  669. self.assertRaisesRegex(ssl.SSLError, "certificate verify failed",
  670. s.connect, ("svn.python.org", 443))
  671. s.close()
  672. # This should succeed because we specify the root cert
  673. ctx.load_verify_locations(SVN_PYTHON_ORG_ROOT_CERT)
  674. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  675. s.connect(("svn.python.org", 443))
  676. try:
  677. cert = s.getpeercert()
  678. self.assertTrue(cert)
  679. finally:
  680. s.close()
  681. def test_connect_capath(self):
  682. # Verify server certificates using the `capath` argument
  683. # NOTE: the subject hashing algorithm has been changed between
  684. # OpenSSL 0.9.8n and 1.0.0, as a result the capath directory must
  685. # contain both versions of each certificate (same content, different
  686. # filename) for this test to be portable across OpenSSL releases.
  687. with support.transient_internet("svn.python.org"):
  688. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  689. ctx.verify_mode = ssl.CERT_REQUIRED
  690. ctx.load_verify_locations(capath=CAPATH)
  691. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  692. s.connect(("svn.python.org", 443))
  693. try:
  694. cert = s.getpeercert()
  695. self.assertTrue(cert)
  696. finally:
  697. s.close()
  698. # Same with a bytes `capath` argument
  699. ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  700. ctx.verify_mode = ssl.CERT_REQUIRED
  701. ctx.load_verify_locations(capath=BYTES_CAPATH)
  702. s = ctx.wrap_socket(socket.socket(socket.AF_INET))
  703. s.connect(("svn.python.org", 443))
  704. try:
  705. cert = s.getpeercert()
  706. self.assertTrue(cert)
  707. finally:
  708. s.close()
  709. @unittest.skipIf(os.name == "nt", "Can't use a socket as a file under Windows")
  710. def test_makefile_close(self):
  711. # Issue #5238: creating a file-like object with makefile() shouldn't
  712. # delay closing the underlying "real socket" (here tested with its
  713. # file descriptor, hence skipping the test under Windows).
  714. with support.transient_internet("svn.python.org"):
  715. ss = ssl.wrap_socket(socket.socket(socket.AF_INET))
  716. ss.connect(("svn.python.org", 443))
  717. fd = ss.fileno()
  718. f = ss.makefile()
  719. f.close()
  720. # The fd is still open
  721. os.read(fd, 0)
  722. # Closing the SSL socket should close the fd too
  723. ss.close()
  724. gc.collect()
  725. with self.assertRaises(OSError) as e:
  726. os.read(fd, 0)
  727. self.assertEqual(e.exception.errno, errno.EBADF)
  728. def test_non_blocking_handshake(self):
  729. with support.transient_internet("svn.python.org"):
  730. s = socket.socket(socket.AF_INET)
  731. s.connect(("svn.python.org", 443))
  732. s.setblocking(False)
  733. s = ssl.wrap_socket(s,
  734. cert_reqs=ssl.CERT_NONE,
  735. do_handshake_on_connect=False)
  736. count = 0
  737. while True:
  738. try:
  739. count += 1
  740. s.do_handshake()
  741. break
  742. except ssl.SSLWantReadError:
  743. select.select([s], [], [])
  744. except ssl.SSLWantWriteError:
  745. select.select([], [s], [])
  746. s.close()
  747. if support.verbose:
  748. sys.stdout.write("\nNeeded %d calls to do_handshake() to establish session.\n" % count)
  749. def test_get_server_certificate(self):
  750. def _test_get_server_certificate(host, port, cert=None):
  751. with support.transient_internet(host):
  752. pem = ssl.get_server_certificate((host, port))
  753. if not pem:
  754. self.fail("No server certificate on %s:%s!" % (host, port))
  755. try:
  756. pem = ssl.get_server_certificate((host, port), ca_certs=CERTFILE)
  757. except ssl.SSLError as x:
  758. #should fail
  759. if support.verbose:
  760. sys.stdout.write("%s\n" % x)
  761. else:
  762. self.fail("Got server certificate %s for %s:%s!" % (pem, host, port))
  763. pem = ssl.get_server_certificate((host, port), ca_certs=cert)
  764. if not pem:
  765. self.fail("No server certificate on %s:%s!" % (host, port))
  766. if support.verbose:
  767. sys.stdout.write("\nVerified certificate for %s:%s is\n%s\n" % (host, port ,pem))
  768. _test_get_server_certificate('svn.python.org', 443, SVN_PYTHON_ORG_ROOT_CERT)
  769. if support.IPV6_ENABLED:
  770. _test_get_server_certificate('ipv6.google.com', 443)
  771. def test_ciphers(self):
  772. remote = ("svn.python.org", 443)
  773. with support.transient_internet(remote[0]):
  774. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  775. cert_reqs=ssl.CERT_NONE, ciphers="ALL")
  776. s.connect(remote)
  777. s = ssl.wrap_socket(socket.socket(socket.AF_INET),
  778. cert_reqs=ssl.CERT_NONE, ciphers="DEFAULT")
  779. s.connect(remote)
  780. # Error checking can happen at instantiation or when connecting
  781. with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
  782. with socket.socket(socket.AF_INET) as sock:
  783. s = ssl.wrap_socket(sock,
  784. cert_reqs=ssl.CERT_NONE, ciphers="^$:,;?*'dorothyx")
  785. s.connect(remote)
  786. def test_algorithms(self):
  787. # Issue #8484: all algorithms should be available when verifying a
  788. # certificate.
  789. # SHA256 was added in OpenSSL 0.9.8
  790. if ssl.OPENSSL_VERSION_INFO < (0, 9, 8, 0, 15):
  791. self.skipTest("SHA256 not available on %r" % ssl.OPENSSL_VERSION)
  792. # sha256.tbs-internet.com needs SNI to use the correct certificate
  793. if not ssl.HAS_SNI:
  794. self.skipTest("SNI needed for this test")
  795. # https://sha2.hboeck.de/ was used until 2011-01-08 (no route to host)
  796. remote = ("sha256.tbs-internet.com", 443)
  797. sha256_cert = os.path.join(os.path.dirname(__file__), "sha256.pem")
  798. with support.transient_internet("sha256.tbs-internet.com"):
  799. ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  800. ctx.verify_mode = ssl.CERT_REQUIRED
  801. ctx.load_verify_locations(sha256_cert)
  802. s = ctx.wrap_socket(socket.socket(socket.AF_INET),
  803. server_hostname="sha256.tbs-internet.com")
  804. try:
  805. s.connect(remote)
  806. if support.verbose:
  807. sys.stdout.write("\nCipher with %r is %r\n" %
  808. (remote, s.cipher()))
  809. sys.stdout.write("Certificate is:\n%s\n" %
  810. pprint.pformat(s.getpeercert()))
  811. finally:
  812. s.close()
  813. try:
  814. import threading
  815. except ImportError:
  816. _have_threads = False
  817. else:
  818. _have_threads = True
  819. from test.ssl_servers import make_https_server
  820. class ThreadedEchoServer(threading.Thread):
  821. class ConnectionHandler(threading.Thread):
  822. """A mildly complicated class, because we want it to work both
  823. with and without the SSL wrapper around the socket connection, so
  824. that we can test the STARTTLS functionality."""
  825. def __init__(self, server, connsock, addr):
  826. self.server = server
  827. self.running = False
  828. self.sock = connsock
  829. self.addr = addr
  830. self.sock.setblocking(1)
  831. self.sslconn = None
  832. threading.Thread.__init__(self)
  833. self.daemon = True
  834. def wrap_conn(self):
  835. try:
  836. self.sslconn = self.server.context.wrap_socket(
  837. self.sock, server_side=True)
  838. self.server.selected_protocols.append(self.sslconn.selected_npn_protocol())
  839. except ssl.SSLError as e:
  840. # XXX Various errors can have happened here, for example
  841. # a mismatching protocol version, an invalid certificate,
  842. # or a low-level bug. This should be made more discriminating.
  843. self.server.conn_errors.append(e)
  844. if self.server.chatty:
  845. handle_error("\n server: bad connection attempt from " + repr(self.addr) + ":\n")
  846. self.running = False
  847. self.server.stop()
  848. self.close()
  849. return False
  850. else:
  851. if self.server.context.verify_mode == ssl.CERT_REQUIRED:
  852. cert = self.sslconn.getpeercert()
  853. if support.verbose and self.server.chatty:
  854. sys.stdout.write(" client cert is " + pprint.pformat(cert) + "\n")
  855. cert_binary = self.sslconn.getpeercert(True)
  856. if support.verbose and self.server.chatty:
  857. sys.stdout.write(" cert binary is " + str(len(cert_binary)) + " bytes\n")
  858. cipher = self.sslconn.cipher()
  859. if support.verbose and self.server.chatty:
  860. sys.stdout.write(" server: connection cipher is now " + str(cipher) + "\n")
  861. sys.stdout.write(" server: selected protocol is now "
  862. + str(self.sslconn.selected_npn_protocol()) + "\n")
  863. return True
  864. def read(self):
  865. if self.sslconn:
  866. return self.sslconn.read()
  867. else:
  868. return self.sock.recv(1024)
  869. def write(self, bytes):
  870. if self.sslconn:
  871. return self.sslconn.write(bytes)
  872. else:
  873. return self.sock.send(bytes)
  874. def close(self):
  875. if self.sslconn:
  876. self.sslconn.close()
  877. else:
  878. self.sock.close()
  879. def run(self):
  880. self.running = True
  881. if not self.server.starttls_server:
  882. if not self.wrap_conn():
  883. return
  884. while self.running:
  885. try:
  886. msg = self.read()
  887. stripped = msg.strip()
  888. if not stripped:
  889. # eof, so quit this handler
  890. self.running = False
  891. self.close()
  892. elif stripped == b'over':
  893. if support.verbose and self.server.connectionchatty:
  894. sys.stdout.write(" server: client closed connection\n")
  895. self.close()
  896. return
  897. elif (self.server.starttls_server and
  898. stripped == b'STARTTLS'):
  899. if support.verbose and self.server.connectionchatty:
  900. sys.stdout.write(" server: read STARTTLS from client, sending OK...\n")
  901. self.write(b"OK\n")
  902. if not self.wrap_conn():
  903. return
  904. elif (self.server.starttls_server and self.sslconn
  905. and stripped == b'ENDTLS'):
  906. if support.verbose and self.server.connectionchatty:
  907. sys.stdout.write(" server: read ENDTLS from client, sending OK...\n")
  908. self.write(b"OK\n")
  909. self.sock = self.sslconn.unwrap()
  910. self.sslconn = None
  911. if support.verbose and self.server.connectionchatty:
  912. sys.stdout.write(" server: connection is now unencrypted...\n")
  913. elif stripped == b'CB tls-unique':
  914. if support.verbose and self.server.connectionchatty:
  915. sys.stdout.write(" server: read CB tls-unique from client, sending our CB data...\n")
  916. data = self.sslconn.get_channel_binding("tls-unique")
  917. self.write(repr(data).encode("us-ascii") + b"\n")
  918. else:
  919. if (support.verbose and
  920. self.server.connectionchatty):
  921. ctype = (self.sslconn and "encrypted") or "unencrypted"
  922. sys.stdout.write(" server: read %r (%s), sending back %r (%s)...\n"
  923. % (msg, ctype, msg.lower(), ctype))
  924. self.write(msg.lower())
  925. except socket.error:
  926. if self.server.chatty:
  927. handle_error("Test server failure:\n")
  928. self.close()
  929. self.running = False
  930. # normally, we'd just stop here, but for the test
  931. # harness, we want to stop the server
  932. self.server.stop()
  933. def __init__(self, certificate=None, ssl_version=None,
  934. certreqs=None, cacerts=None,
  935. chatty=True, connectionchatty=False, starttls_server=False,
  936. npn_protocols=None, ciphers=None, context=None):
  937. if context:
  938. self.context = context
  939. else:
  940. self.context = ssl.SSLContext(ssl_version
  941. if ssl_version is not None
  942. else ssl.PROTOCOL_TLSv1)
  943. self.context.verify_mode = (certreqs if certreqs is not None
  944. else ssl.CERT_NONE)
  945. if cacerts:
  946. self.context.load_verify_locations(cacerts)
  947. if certificate:
  948. self.context.load_cert_chain(certificate)
  949. if npn_protocols:
  950. self.context.set_npn_protocols(npn_protocols)
  951. if ciphers:
  952. self.context.set_ciphers(ciphers)
  953. self.chatty = chatty
  954. self.connectionchatty = connectionchatty
  955. self.starttls_server = starttls_server
  956. self.sock = socket.socket()
  957. self.port = support.bind_port(self.sock)
  958. self.flag = None
  959. self.active = False
  960. self.selected_protocols = []
  961. self.conn_errors = []
  962. threading.Thread.__init__(self)
  963. self.daemon = True
  964. def __enter__(self):
  965. self.start(threading.Event())
  966. self.flag.wait()
  967. return self
  968. def __exit__(self, *args):
  969. self.stop()
  970. self.join()
  971. def start(self, flag=None):
  972. self.flag = flag
  973. threading.Thread.start(self)
  974. def run(self):
  975. self.sock.settimeout(0.05)
  976. self.sock.listen(5)
  977. self.active = True
  978. if self.flag:
  979. # signal an event
  980. self.flag.set()
  981. while self.active:
  982. try:
  983. newconn, connaddr = self.sock.accept()
  984. if support.verbose and self.chatty:
  985. sys.stdout.write(' server: new connection from '
  986. + repr(connaddr) + '\n')
  987. handler = self.ConnectionHandler(self, newconn, connaddr)
  988. handler.start()
  989. handler.join()
  990. except socket.timeout:
  991. pass
  992. except KeyboardInterrupt:
  993. self.stop()
  994. self.sock.close()
  995. def stop(self):
  996. self.active = False
  997. class AsyncoreEchoServer(threading.Thread):
  998. # this one's based on asyncore.dispatcher
  999. class EchoServer (asyncore.dispatcher):
  1000. class ConnectionHandler (asyncore.dispatcher_with_send):
  1001. def __init__(self, conn, certfile):
  1002. self.socket = ssl.wrap_socket(conn, server_side=True,
  1003. certfile=certfile,
  1004. do_handshake_on_connect=False)
  1005. asyncore.dispatcher_with_send.__init__(self, self.socket)
  1006. self._ssl_accepting = True
  1007. self._do_ssl_handshake()
  1008. def readable(self):
  1009. if isinstance(self.socket, ssl.SSLSocket):
  1010. while self.socket.pending() > 0:
  1011. self.handle_read_event()
  1012. return True
  1013. def _do_ssl_handshake(self):
  1014. try:
  1015. self.socket.do_handshake()
  1016. except (ssl.SSLWantReadError, ssl.SSLWantWriteError):
  1017. return
  1018. except ssl.SSLEOFError:
  1019. return self.handle_close()
  1020. except ssl.SSLError:
  1021. raise
  1022. except socket.error as err:
  1023. if err.args[0] == errno.ECONNABORTED:
  1024. return self.handle_close()
  1025. else:
  1026. self._ssl_accepting = False
  1027. def handle_read(self):
  1028. if self._ssl_accepting:
  1029. self._do_ssl_handshake()
  1030. else:
  1031. data = self.recv(1024)
  1032. if support.verbose:
  1033. sys.stdout.write(" server: read %s from client\n" % repr(data))
  1034. if not data:
  1035. self.close()
  1036. else:
  1037. self.send(data.lower())
  1038. def handle_close(self):
  1039. self.close()
  1040. if support.verbose:
  1041. sys.stdout.write(" server: closed connection %s\n" % self.socket)
  1042. def handle_error(self):
  1043. raise
  1044. def __init__(self, certfile):
  1045. self.certfile = certfile
  1046. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  1047. self.port = support.bind_port(sock, '')
  1048. asyncore.dispatcher.__init__(self, sock)
  1049. self.listen(5)
  1050. def handle_accepted(self, sock_obj, addr):
  1051. if support.verbose:
  1052. sys.stdout.write(" server: new connection from %s:%s\n" %addr)
  1053. self.ConnectionHandler(sock_obj, self.certfile)
  1054. def handle_error(self):
  1055. raise
  1056. def __init__(self, certfile):
  1057. self.flag = None
  1058. self.active = False
  1059. self.server = self.EchoServer(certfile)
  1060. self.port = self.server.port
  1061. threading.Thread.__init__(self)
  1062. self.daemon = True
  1063. def __str__(self):
  1064. return "<%s %s>" % (self.__class__.__name__, self.server)
  1065. def __enter__(self):
  1066. self.start(threading.Event())
  1067. self.flag.wait()
  1068. return self
  1069. def __exit__(self, *args):
  1070. if support.verbose:
  1071. sys.stdout.write(" cleanup: stopping server.\n")
  1072. self.stop()
  1073. if support.verbose:
  1074. sys.stdout.write(" cleanup: joining server thread.\n")
  1075. self.join()
  1076. if support.verbose:
  1077. sys.stdout.write(" cleanup: successfully joined.\n")
  1078. def start (self, flag=None):
  1079. self.flag = flag
  1080. threading.Thread.start(self)
  1081. def run(self):
  1082. self.active = True
  1083. if self.flag:
  1084. self.flag.set()
  1085. while self.active:
  1086. try:
  1087. asyncore.loop(1)
  1088. except:
  1089. pass
  1090. def stop(self):
  1091. self.active = False
  1092. self.server.close()
  1093. def bad_cert_test(certfile):
  1094. """
  1095. Launch a server with CERT_REQUIRED, and check that trying to
  1096. connect to it with the given client certificate fails.
  1097. """
  1098. server = ThreadedEchoServer(CERTFILE,
  1099. certreqs=ssl.CERT_REQUIRED,
  1100. cacerts=CERTFILE, chatty=False,
  1101. connectionchatty=False)
  1102. with server:
  1103. try:
  1104. with socket.socket() as sock:
  1105. s = ssl.wrap_socket(sock,
  1106. certfile=certfile,
  1107. ssl_version=ssl.PROTOCOL_TLSv1)
  1108. s.connect((HOST, server.port))
  1109. except ssl.SSLError as x:
  1110. if support.verbose:
  1111. sys.stdout.write("\nSSLError is %s\n" % x.args[1])
  1112. except socket.error as x:
  1113. if support.verbose:
  1114. sys.stdout.write("\nsocket.error is %s\n" % x.args[1])
  1115. except IOError as x:
  1116. if x.errno != errno.ENOENT:
  1117. raise
  1118. if support.verbose:
  1119. sys.stdout.write("\IOError is %s\n" % str(x))
  1120. else:
  1121. raise AssertionError("Use of invalid cert should have failed!")
  1122. def server_params_test(client_context, server_context, indata=b"FOO\n",
  1123. chatty=True, connectionchatty=False):
  1124. """
  1125. Launch a server, connect a client to it and try various reads
  1126. and writes.
  1127. """
  1128. stats = {}
  1129. server = ThreadedEchoServer(context=server_context,
  1130. chatty=chatty,
  1131. connectionchatty=False)
  1132. with server:
  1133. with client_context.wrap_socket(socket.socket()) as s:
  1134. s.connect((HOST, server.port))
  1135. for arg in [indata, bytearray(indata), memoryview(indata)]:
  1136. if connectionchatty:
  1137. if support.verbose:
  1138. sys.stdout.write(
  1139. " client: sending %r...\n" % indata)
  1140. s.write(arg)
  1141. outdata = s.read()
  1142. if connectionchatty:
  1143. if support.verbose:
  1144. sys.stdout.write(" client: read %r\n" % outdata)
  1145. if outdata != indata.lower():
  1146. raise AssertionError(
  1147. "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
  1148. % (outdata[:20], len(outdata),
  1149. indata[:20].lower(), len(indata)))
  1150. s.write(b"over\n")
  1151. if connectionchatty:
  1152. if support.verbose:
  1153. sys.stdout.write(" client: closing connection.\n")
  1154. stats.update({
  1155. 'compression': s.compression(),
  1156. 'cipher': s.cipher(),
  1157. 'client_npn_protocol': s.selected_npn_protocol()
  1158. })
  1159. s.close()
  1160. stats['server_npn_protocols'] = server.selected_protocols
  1161. return stats
  1162. def try_protocol_combo(server_protocol, client_protocol, expect_success,
  1163. certsreqs=None, server_options=0, client_options=0):
  1164. if certsreqs is None:
  1165. certsreqs = ssl.CERT_NONE
  1166. certtype = {
  1167. ssl.CERT_NONE: "CERT_NONE",
  1168. ssl.CERT_OPTIONAL: "CERT_OPTIONAL",
  1169. ssl.CERT_REQUIRED: "CERT_REQUIRED",
  1170. }[certsreqs]
  1171. if support.verbose:
  1172. formatstr = (expect_success and " %s->%s %s\n") or " {%s->%s} %s\n"
  1173. sys.stdout.write(formatstr %
  1174. (ssl.get_protocol_name(client_protocol),
  1175. ssl.get_protocol_name(server_protocol),
  1176. certtype))
  1177. client_context = ssl.SSLContext(client_protocol)
  1178. client_context.options = ssl.OP_ALL | client_options
  1179. server_context = ssl.SSLContext(server_protocol)
  1180. server_context.options = ssl.OP_ALL | server_options
  1181. for ctx in (client_context, server_context):
  1182. ctx.verify_mode = certsreqs
  1183. # NOTE: we must enable "ALL" ciphers, otherwise an SSLv23 client
  1184. # will send an SSLv3 hello (rather than SSLv2) starting from
  1185. # OpenSSL 1.0.0 (see issue #8322).
  1186. ctx.set_ciphers("ALL")
  1187. ctx.load_cert_chain(CERTFILE)
  1188. ctx.load_verify_locations(CERTFILE)
  1189. try:
  1190. server_params_test(client_context, server_context,
  1191. chatty=False, connectionchatty=False)
  1192. # Protocol mismatch can result in either an SSLError, or a
  1193. # "Connection reset by peer" error.
  1194. except ssl.SSLError:
  1195. if expect_success:
  1196. raise
  1197. except socket.error as e:
  1198. if expect_success or e.errno != errno.ECONNRESET:
  1199. raise
  1200. else:
  1201. if not expect_success:
  1202. raise AssertionError(
  1203. "Client protocol %s succeeded with server protocol %s!"
  1204. % (ssl.get_protocol_name(client_protocol),
  1205. ssl.get_protocol_name(server_protocol)))
  1206. class ThreadedTests(unittest.TestCase):
  1207. @skip_if_broken_ubuntu_ssl
  1208. def test_echo(self):
  1209. """Basic test of an SSL client connecting to a server"""
  1210. if support.verbose:
  1211. sys.stdout.write("\n")
  1212. for protocol in PROTOCOLS:
  1213. context = ssl.SSLContext(protocol)
  1214. context.load_cert_chain(CERTFILE)
  1215. server_params_test(context, context,
  1216. chatty=True, connectionchatty=True)
  1217. def test_getpeercert(self):
  1218. if support.verbose:
  1219. sys.stdout.write("\n")
  1220. context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  1221. context.verify_mode = ssl.CERT_REQUIRED
  1222. context.load_verify_locations(CERTFILE)
  1223. context.load_cert_chain(CERTFILE)
  1224. server = ThreadedEchoServer(context=context, chatty=False)
  1225. with server:
  1226. s = context.wrap_socket(socket.socket())
  1227. s.connect((HOST, server.port))
  1228. cert = s.getpeercert()
  1229. self.assertTrue(cert, "Can't get peer certificate.")
  1230. cipher = s.cipher()
  1231. if support.verbose:
  1232. sys.stdout.write(pprint.pformat(cert) + '\n')
  1233. sys.stdout.write("Connection cipher is " + str(cipher) + '.\n')
  1234. if 'subject' not in cert:
  1235. self.fail("No subject field in certificate: %s." %
  1236. pprint.pformat(cert))
  1237. if ((('organizationName', 'Python Software Foundation'),)
  1238. not in cert['subject']):
  1239. self.fail(
  1240. "Missing or invalid 'organizationName' field in certificate subject; "
  1241. "should be 'Python Software Foundation'.")
  1242. self.assertIn('notBefore', cert)
  1243. self.assertIn('notAfter', cert)
  1244. before = ssl.cert_time_to_seconds(cert['notBefore'])
  1245. after = ssl.cert_time_to_seconds(cert['notAfter'])
  1246. self.assertLess(before, after)
  1247. s.close()
  1248. def test_empty_cert(self):
  1249. """Connecting with an empty cert file"""
  1250. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1251. "nullcert.pem"))
  1252. def test_malformed_cert(self):
  1253. """Connecting with a badly formatted certificate (syntax error)"""
  1254. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1255. "badcert.pem"))
  1256. def test_nonexisting_cert(self):
  1257. """Connecting with a non-existing cert file"""
  1258. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1259. "wrongcert.pem"))
  1260. def test_malformed_key(self):
  1261. """Connecting with a badly formatted key (syntax error)"""
  1262. bad_cert_test(os.path.join(os.path.dirname(__file__) or os.curdir,
  1263. "badkey.pem"))
  1264. def test_rude_shutdown(self):
  1265. """A brutal shutdown of an SSL server should raise an IOError
  1266. in the client when attempting handshake.
  1267. """
  1268. listener_ready = threading.Event()
  1269. listener_gone = threading.Event()
  1270. s = socket.socket()
  1271. port = support.bind_port(s, HOST)
  1272. # `listener` runs in a thread. It sits in an accept() until
  1273. # the main thread connects. Then it rudely closes the socket,
  1274. # and sets Event `listener_gone` to let the main thread know
  1275. # the socket is gone.
  1276. def listener():
  1277. s.listen(5)
  1278. listener_ready.set()
  1279. newsock, addr = s.accept()
  1280. newsock.close()
  1281. s.close()
  1282. listener_gone.set()
  1283. def connector():
  1284. listener_ready.wait()
  1285. with socket.socket() as c:
  1286. c.connect((HOST, port))
  1287. listener_gone.wait()
  1288. try:
  1289. ssl_sock = ssl.wrap_socket(c)
  1290. except IOError:
  1291. pass
  1292. else:
  1293. self.fail('connecting to closed SSL socket should have failed')
  1294. t = threading.Thread(target=listener)
  1295. t.start()
  1296. try:
  1297. connector()
  1298. finally:
  1299. t.join()
  1300. @skip_if_broken_ubuntu_ssl
  1301. @unittest.skipUnless(hasattr(ssl, 'PROTOCOL_SSLv2'),
  1302. "OpenSSL is compiled without SSLv2 support")
  1303. def test_protocol_sslv2(self):
  1304. """Connecting to an SSLv2 server with various client options"""
  1305. if support.verbose:
  1306. sys.stdout.write("\n")
  1307. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv2, True)
  1308. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv2, True, ssl.CERT_OPTIONAL)
  1309. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv2, True, ssl.CERT_REQUIRED)
  1310. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv23, True)
  1311. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv3, False)
  1312. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_TLSv1, False)
  1313. # SSLv23 client with specific SSL options
  1314. if no_sslv2_implies_sslv3_hello():
  1315. # No SSLv2 => client will use an SSLv3 hello on recent OpenSSLs
  1316. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv23, False,
  1317. client_options=ssl.OP_NO_SSLv2)
  1318. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv23, True,
  1319. client_options=ssl.OP_NO_SSLv3)
  1320. try_protocol_combo(ssl.PROTOCOL_SSLv2, ssl.PROTOCOL_SSLv23, True,
  1321. client_options=ssl.OP_NO_TLSv1)
  1322. @skip_if_broken_ubuntu_ssl
  1323. def test_protocol_sslv23(self):
  1324. """Connecting to an SSLv23 server with various client options"""
  1325. if support.verbose:
  1326. sys.stdout.write("\n")
  1327. if hasattr(ssl, 'PROTOCOL_SSLv2'):
  1328. try:
  1329. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv2, True)
  1330. except (ssl.SSLError, socket.error) as x:
  1331. # this fails on some older versions of OpenSSL (0.9.7l, for instance)
  1332. if support.verbose:
  1333. sys.stdout.write(
  1334. " SSL2 client to SSL23 server test unexpectedly failed:\n %s\n"
  1335. % str(x))
  1336. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv3, True)
  1337. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv23, True)
  1338. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_TLSv1, True)
  1339. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv3, True, ssl.CERT_OPTIONAL)
  1340. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv23, True, ssl.CERT_OPTIONAL)
  1341. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_TLSv1, True, ssl.CERT_OPTIONAL)
  1342. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv3, True, ssl.CERT_REQUIRED)
  1343. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv23, True, ssl.CERT_REQUIRED)
  1344. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_TLSv1, True, ssl.CERT_REQUIRED)
  1345. # Server with specific SSL options
  1346. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv3, False,
  1347. server_options=ssl.OP_NO_SSLv3)
  1348. # Will choose TLSv1
  1349. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_SSLv23, True,
  1350. server_options=ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3)
  1351. try_protocol_combo(ssl.PROTOCOL_SSLv23, ssl.PROTOCOL_TLSv1, False,
  1352. server_options=ssl.OP_NO_TLSv1)
  1353. @skip_if_broken_ubuntu_ssl
  1354. def test_protocol_sslv3(self):
  1355. """Connecting to an SSLv3 server with various client options"""
  1356. if support.verbose:
  1357. sys.stdout.write("\n")
  1358. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, True)
  1359. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, True, ssl.CERT_OPTIONAL)
  1360. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, True, ssl.CERT_REQUIRED)
  1361. if hasattr(ssl, 'PROTOCOL_SSLv2'):
  1362. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv2, False)
  1363. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv23, False,
  1364. client_options=ssl.OP_NO_SSLv3)
  1365. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_TLSv1, False)
  1366. if no_sslv2_implies_sslv3_hello():
  1367. # No SSLv2 => client will use an SSLv3 hello on recent OpenSSLs
  1368. try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv23, True,
  1369. client_options=ssl.OP_NO_SSLv2)
  1370. @skip_if_broken_ubuntu_ssl
  1371. def test_protocol_tlsv1(self):
  1372. """Connecting to a TLSv1 server with various client options"""
  1373. if support.verbose:
  1374. sys.stdout.write("\n")
  1375. try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, True)
  1376. try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, True, ssl.CERT_OPTIONAL)
  1377. try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, True, ssl.CERT_REQUIRED)
  1378. if hasattr(ssl, 'PROTOCOL_SSLv2'):
  1379. try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_SSLv2, False)
  1380. try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_SSLv3, False)
  1381. try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_SSLv23, False,
  1382. client_options=ssl.OP_NO_TLSv1)
  1383. def test_starttls(self):
  1384. """Switching from clear text to encrypted and back again."""
  1385. msgs = (b"msg 1", b"MSG 2", b"STARTTLS", b"MSG 3", b"msg 4", b"ENDTLS", b"msg 5", b"msg 6")
  1386. server = ThreadedEchoServer(CERTFILE,
  1387. ssl_version=ssl.PROTOCOL_TLSv1,
  1388. starttls_server=True,
  1389. chatty=True,
  1390. connectionchatty=True)
  1391. wrapped = False
  1392. with server:
  1393. s = socket.socket()
  1394. s.setblocking(1)
  1395. s.connect((HOST, server.port))
  1396. if support.verbose:
  1397. sys.stdout.write("\n")
  1398. for indata in msgs:
  1399. if support.verbose:
  1400. sys.stdout.write(
  1401. " client: sending %r...\n" % indata)
  1402. if wrapped:
  1403. conn.write(indata)
  1404. outdata = conn.read()
  1405. else:
  1406. s.send(indata)
  1407. outdata = s.recv(1024)
  1408. msg = outdata.strip().lower()
  1409. if indata == b"STARTTLS" and msg.startswith(b"ok"):
  1410. # STARTTLS ok, switch to secure mode
  1411. if support.verbose:
  1412. sys.stdout.write(
  1413. " client: read %r from server, starting TLS...\n"
  1414. % msg)
  1415. conn = ssl.wrap_socket(s, ssl_version=ssl.PROTOCOL_TLSv1)
  1416. wrapped = True
  1417. elif indata == b"ENDTLS" and msg.startswith(b"ok"):
  1418. # ENDTLS ok, switch back to clear text
  1419. if support.verbose:
  1420. sys.stdout.write(
  1421. " client: read %r from server, ending TLS...\n"
  1422. % msg)
  1423. s = conn.unwrap()
  1424. wrapped = False
  1425. else:
  1426. if support.verbose:
  1427. sys.stdout.write(
  1428. " client: read %r from server\n" % msg)
  1429. if support.verbose:
  1430. sys.stdout.write(" client: closing connection.\n")
  1431. if wrapped:
  1432. conn.write(b"over\n")
  1433. else:
  1434. s.send(b"over\n")
  1435. if wrapped:
  1436. conn.close()
  1437. else:
  1438. s.close()
  1439. def test_socketserver(self):
  1440. """Using a SocketServer to create and manage SSL connections."""
  1441. server = make_https_server(self, CERTFILE)
  1442. # try to connect
  1443. if support.verbose:
  1444. sys.stdout.write('\n')
  1445. with open(CERTFILE, 'rb') as f:
  1446. d1 = f.read()
  1447. d2 = ''
  1448. # now fetch the same data from the HTTPS server
  1449. url = 'https://%s:%d/%s' % (
  1450. HOST, server.port, os.path.split(CERTFILE)[1])
  1451. f = urllib.request.urlopen(url)
  1452. try:
  1453. dlen = f.info().get("content-length")
  1454. if dlen and (int(dlen) > 0):
  1455. d2 = f.read(int(dlen))
  1456. if support.verbose:
  1457. sys.stdout.write(
  1458. " client: read %d bytes from remote server '%s'\n"
  1459. % (len(d2), server))
  1460. finally:
  1461. f.close()
  1462. self.assertEqual(d1, d2)
  1463. def test_asyncore_server(self):
  1464. """Check the example asyncore integration."""
  1465. indata = "TEST MESSAGE of mixed case\n"
  1466. if support.verbose:
  1467. sys.stdout.write("\n")
  1468. indata = b"FOO\n"
  1469. server = AsyncoreEchoServer(CERTFILE)
  1470. with server:
  1471. s = ssl.wrap_socket(socket.socket())
  1472. s.connect(('127.0.0.1', server.port))
  1473. if support.verbose:
  1474. sys.stdout.write(
  1475. " client: sending %r...\n" % indata)
  1476. s.write(indata)
  1477. outdata = s.read()
  1478. if support.verbose:
  1479. sys.stdout.write(" client: read %r\n" % outdata)
  1480. if outdata != indata.lower():
  1481. self.fail(
  1482. "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
  1483. % (outdata[:20], len(outdata),
  1484. indata[:20].lower(), len(indata)))
  1485. s.write(b"over\n")
  1486. if support.verbose:
  1487. sys.stdout.write(" client: closing connection.\n")
  1488. s.close()
  1489. if support.verbose:
  1490. sys.stdout.write(" client: connection closed.\n")
  1491. def test_recv_send(self):
  1492. """Test recv(), send() and friends."""
  1493. if support.verbose:
  1494. sys.stdout.write("\n")
  1495. server = ThreadedEchoServer(CERTFILE,
  1496. certreqs=ssl.CERT_NONE,
  1497. ssl_version=ssl.PROTOCOL_TLSv1,
  1498. cacerts=CERTFILE,
  1499. chatty=True,
  1500. connectionchatty=False)
  1501. with server:
  1502. s = ssl.wrap_socket(socket.socket(),
  1503. server_side=False,
  1504. certfile=CERTFILE,
  1505. ca_certs=CERTFILE,
  1506. cert_reqs=ssl.CERT_NONE,
  1507. ssl_version=ssl.PROTOCOL_TLSv1)
  1508. s.connect((HOST, server.port))
  1509. # helper methods for standardising recv* method signatures
  1510. def _recv_into():
  1511. b = bytearray(b"\0"*100)
  1512. count = s.recv_into(b)
  1513. return b[:count]
  1514. def _recvfrom_into():
  1515. b = bytearray(b"\0"*100)
  1516. count, addr = s.recvfrom_into(b)
  1517. return b[:count]
  1518. # (name, method, whether to expect success, *args)
  1519. send_methods = [
  1520. ('send', s.send, True, []),
  1521. ('sendto', s.sendto, False, ["some.address"]),
  1522. ('sendall', s.sendall, True, []),
  1523. ]
  1524. recv_methods = [
  1525. ('recv', s.recv, True, []),
  1526. ('recvfrom', s.recvfrom, False, ["some.address"]),
  1527. ('recv_into', _recv_into, True, []),
  1528. ('recvfrom_into', _recvfrom_into, False, []),
  1529. ]
  1530. data_prefix = "PREFIX_"
  1531. for meth_name, send_meth, expect_success, args in send_methods:
  1532. indata = (data_prefix + meth_name).encode('ascii')
  1533. try:
  1534. send_meth(indata, *args)
  1535. outdata = s.read()
  1536. if outdata != indata.lower():
  1537. self.fail(
  1538. "While sending with <<{name:s}>> bad data "
  1539. "<<{outdata:r}>> ({nout:d}) received; "
  1540. "expected <<{indata:r}>> ({nin:d})\n".format(
  1541. name=meth_name, outdata=outdata[:20],
  1542. nout=len(outdata),
  1543. indata=indata[:20], nin=len(indata)
  1544. )
  1545. )
  1546. except ValueError as e:
  1547. if expect_success:
  1548. self.fail(
  1549. "Failed to send with method <<{name:s}>>; "
  1550. "expected to succeed.\n".format(name=meth_name)
  1551. )
  1552. if not str(e).startswith(meth_name):
  1553. self.fail(
  1554. "Method <<{name:s}>> failed with unexpected "
  1555. "exception message: {exp:s}\n".format(
  1556. name=meth_name, exp=e
  1557. )
  1558. )
  1559. for meth_name, recv_meth, expect_success, args in recv_methods:
  1560. indata = (data_prefix + meth_name).encode('ascii')
  1561. try:
  1562. s.send(indata)
  1563. outdata = recv_meth(*args)
  1564. if outdata != indata.lower():
  1565. self.fail(
  1566. "While receiving with <<{name:s}>> bad data "
  1567. "<<{outdata:r}>> ({nout:d}) received; "
  1568. "expected <<{indata:r}>> ({nin:d})\n".format(
  1569. name=meth_name, outdata=outdata[:20],
  1570. nout=len(outdata),
  1571. indata=indata[:20], nin=len(indata)
  1572. )
  1573. )
  1574. except ValueError as e:
  1575. if expect_success:
  1576. self.fail(
  1577. "Failed to receive with method <<{name:s}>>; "
  1578. "expected to succeed.\n".format(name=meth_name)
  1579. )
  1580. if not str(e).startswith(meth_name):
  1581. self.fail(
  1582. "Method <<{name:s}>> failed with unexpected "
  1583. "exception message: {exp:s}\n".format(
  1584. name=meth_name, exp=e
  1585. )
  1586. )
  1587. # consume data
  1588. s.read()
  1589. # Make sure sendmsg et al are disallowed to avoid
  1590. # inadvertent disclosure of data and/or corruption
  1591. # of the encrypted data stream
  1592. self.assertRaises(NotImplementedError, s.sendmsg, [b"data"])
  1593. self.assertRaises(NotImplementedError, s.recvmsg, 100)
  1594. self.assertRaises(NotImplementedError,
  1595. s.recvmsg_into, bytearray(100))
  1596. s.write(b"over\n")
  1597. s.close()
  1598. def test_handshake_timeout(self):
  1599. # Issue #5103: SSL handshake must respect the socket timeout
  1600. server = socket.socket(socket.AF_INET)
  1601. host = "127.0.0.1"
  1602. port = support.bind_port(server)
  1603. started = threading.Event()
  1604. finish = False
  1605. def serve():
  1606. server.listen(5)
  1607. started.set()
  1608. conns = []
  1609. while not finish:
  1610. r, w, e = select.select([server], [], [], 0.1)
  1611. if server in r:
  1612. # Let the socket hang around rather than having
  1613. # it closed by garbage collection.
  1614. conns.append(server.accept()[0])
  1615. for sock in conns:
  1616. sock.close()
  1617. t = threading.Thread(target=serve)
  1618. t.start()
  1619. started.wait()
  1620. try:
  1621. try:
  1622. c = socket.socket(socket.AF_INET)
  1623. c.settimeout(0.2)
  1624. c.connect((host, port))
  1625. # Will attempt handshake and time out
  1626. self.assertRaisesRegex(socket.timeout, "timed out",
  1627. ssl.wrap_socket, c)
  1628. finally:
  1629. c.close()
  1630. try:
  1631. c = socket.socket(socket.AF_INET)
  1632. c = ssl.wrap_socket(c)
  1633. c.settimeout(0.2)
  1634. # Will attempt handshake and time out
  1635. self.assertRaisesRegex(socket.timeout, "timed out",
  1636. c.connect, (host, port))
  1637. finally:
  1638. c.close()
  1639. finally:
  1640. finish = True
  1641. t.join()
  1642. server.close()
  1643. def test_server_accept(self):
  1644. # Issue #16357: accept() on a SSLSocket created through
  1645. # SSLContext.wrap_socket().
  1646. context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  1647. context.verify_mode = ssl.CERT_REQUIRED
  1648. context.load_verify_locations(CERTFILE)
  1649. context.load_cert_chain(CERTFILE)
  1650. server = socket.socket(socket.AF_INET)
  1651. host = "127.0.0.1"
  1652. port = support.bind_port(server)
  1653. server = context.wrap_socket(server, server_side=True)
  1654. evt = threading.Event()
  1655. remote = None
  1656. peer = None
  1657. def serve():
  1658. nonlocal remote, peer
  1659. server.listen(5)
  1660. # Block on the accept and wait on the connection to close.
  1661. evt.set()
  1662. remote, peer = server.accept()
  1663. remote.recv(1)
  1664. t = threading.Thread(target=serve)
  1665. t.start()
  1666. # Client wait until server setup and perform a connect.
  1667. evt.wait()
  1668. client = context.wrap_socket(socket.socket())
  1669. client.connect((host, port))
  1670. client_addr = client.getsockname()
  1671. client.close()
  1672. t.join()
  1673. # Sanity checks.
  1674. self.assertIsInstance(remote, ssl.SSLSocket)
  1675. self.assertEqual(peer, client_addr)
  1676. def test_default_ciphers(self):
  1677. context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
  1678. try:
  1679. # Force a set of weak ciphers on our client context
  1680. context.set_ciphers("DES")
  1681. except ssl.SSLError:
  1682. self.skipTest("no DES cipher available")
  1683. with ThreadedEchoServer(CERTFILE,
  1684. ssl_version=ssl.PROTOCOL_SSLv23,
  1685. chatty=False) as server:
  1686. with socket.socket() as sock:
  1687. s = context.wrap_socket(sock)
  1688. with self.assertRaises((OSError, ssl.SSLError)):
  1689. s.connect((HOST, server.port))
  1690. self.assertIn("no shared cipher", str(server.conn_errors[0]))
  1691. @unittest.skipUnless("tls-unique" in ssl.CHANNEL_BINDING_TYPES,
  1692. "'tls-unique' channel binding not available")
  1693. def test_tls_unique_channel_binding(self):
  1694. """Test tls-unique channel binding."""
  1695. if support.verbose:
  1696. sys.stdout.write("\n")
  1697. server = ThreadedEchoServer(CERTFILE,
  1698. certreqs=ssl.CERT_NONE,
  1699. ssl_version=ssl.PROTOCOL_TLSv1,
  1700. cacerts=CERTFILE,
  1701. chatty=True,
  1702. connectionchatty=False)
  1703. with server:
  1704. s = ssl.wrap_socket(socket.socket(),
  1705. server_side=False,
  1706. certfile=CERTFILE,
  1707. ca_certs=CERTFILE,
  1708. cert_reqs=ssl.CERT_NONE,
  1709. ssl_version=ssl.PROTOCOL_TLSv1)
  1710. s.connect((HOST, server.port))
  1711. # get the data
  1712. cb_data = s.get_channel_binding("tls-unique")
  1713. if support.verbose:
  1714. sys.stdout.write(" got channel binding data: {0!r}\n"
  1715. .format(cb_data))
  1716. # check if it is sane
  1717. self.assertIsNotNone(cb_data)
  1718. self.assertEqual(len(cb_data), 12) # True for TLSv1
  1719. # and compare with the peers version
  1720. s.write(b"CB tls-unique\n")
  1721. peer_data_repr = s.read().strip()
  1722. self.assertEqual(peer_data_repr,
  1723. repr(cb_data).encode("us-ascii"))
  1724. s.close()
  1725. # now, again
  1726. s = ssl.wrap_socket(socket.socket(),
  1727. server_side=False,
  1728. certfile=CERTFILE,
  1729. ca_certs=CERTFILE,
  1730. cert_reqs=ssl.CERT_NONE,
  1731. ssl_version=ssl.PROTOCOL_TLSv1)
  1732. s.connect((HOST, server.port))
  1733. new_cb_data = s.get_channel_binding("tls-unique")
  1734. if support.verbose:
  1735. sys.stdout.write(" got another channel binding data: {0!r}\n"
  1736. .format(new_cb_data))
  1737. # is it really unique
  1738. self.assertNotEqual(cb_data, new_cb_data)
  1739. self.assertIsNotNone(cb_data)
  1740. self.assertEqual(len(cb_data), 12) # True for TLSv1
  1741. s.write(b"CB tls-unique\n")
  1742. peer_data_repr = s.read().strip()
  1743. self.assertEqual(peer_data_repr,
  1744. repr(new_cb_data).encode("us-ascii"))
  1745. s.close()
  1746. def test_compression(self):
  1747. context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  1748. context.load_cert_chain(CERTFILE)
  1749. stats = server_params_test(context, context,
  1750. chatty=True, connectionchatty=True)
  1751. if support.verbose:
  1752. sys.stdout.write(" got compression: {!r}\n".format(stats['compression']))
  1753. self.assertIn(stats['compression'], { None, 'ZLIB', 'RLE' })
  1754. @unittest.skipUnless(hasattr(ssl, 'OP_NO_COMPRESSION'),
  1755. "ssl.OP_NO_COMPRESSION needed for this test")
  1756. def test_compression_disabled(self):
  1757. context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  1758. context.load_cert_chain(CERTFILE)
  1759. context.options |= ssl.OP_NO_COMPRESSION
  1760. stats = server_params_test(context, context,
  1761. chatty=True, connectionchatty=True)
  1762. self.assertIs(stats['compression'], None)
  1763. def test_dh_params(self):
  1764. # Check we can get a connection with ephemeral Diffie-Hellman
  1765. context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  1766. context.load_cert_chain(CERTFILE)
  1767. context.load_dh_params(DHFILE)
  1768. context.set_ciphers("kEDH")
  1769. stats = server_params_test(context, context,
  1770. chatty=True, connectionchatty=True)
  1771. cipher = stats["cipher"][0]
  1772. parts = cipher.split("-")
  1773. if "ADH" not in parts and "EDH" not in parts and "DHE" not in parts:
  1774. self.fail("Non-DH cipher: " + cipher[0])
  1775. def test_selected_npn_protocol(self):
  1776. # selected_npn_protocol() is None unless NPN is used
  1777. context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  1778. context.load_cert_chain(CERTFILE)
  1779. stats = server_params_test(context, context,
  1780. chatty=True, connectionchatty=True)
  1781. self.assertIs(stats['client_npn_protocol'], None)
  1782. @unittest.skipUnless(ssl.HAS_NPN, "NPN support needed for this test")
  1783. def test_npn_protocols(self):
  1784. server_protocols = ['http/1.1', 'spdy/2']
  1785. protocol_tests = [
  1786. (['http/1.1', 'spdy/2'], 'http/1.1'),
  1787. (['spdy/2', 'http/1.1'], 'http/1.1'),
  1788. (['spdy/2', 'test'], 'spdy/2'),
  1789. (['abc', 'def'], 'abc')
  1790. ]
  1791. for client_protocols, expected in protocol_tests:
  1792. server_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  1793. server_context.load_cert_chain(CERTFILE)
  1794. server_context.set_npn_protocols(server_protocols)
  1795. client_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
  1796. client_context.load_cert_chain(CERTFILE)
  1797. client_context.set_npn_protocols(client_protocols)
  1798. stats = server_params_test(client_context, server_context,
  1799. chatty=True, connectionchatty=True)
  1800. msg = "failed trying %s (s) and %s (c).\n" \
  1801. "was expecting %s, but got %%s from the %%s" \
  1802. % (str(server_protocols), str(client_protocols),
  1803. str(expected))
  1804. client_result = stats['client_npn_protocol']
  1805. self.assertEqual(client_result, expected, msg % (client_result, "client"))
  1806. server_result = stats['server_npn_protocols'][-1] \
  1807. if len(stats['server_npn_protocols']) else 'nothing'
  1808. self.assertEqual(server_result, expected, msg % (server_result, "server"))
  1809. def test_main(verbose=False):
  1810. if support.verbose:
  1811. plats = {
  1812. 'Linux': platform.linux_distribution,
  1813. 'Mac': platform.mac_ver,
  1814. 'Windows': platform.win32_ver,
  1815. }
  1816. for name, func in plats.items():
  1817. plat = func()
  1818. if plat and plat[0]:
  1819. plat = '%s %r' % (name, plat)
  1820. break
  1821. else:
  1822. plat = repr(platform.platform())
  1823. print("test_ssl: testing with %r %r" %
  1824. (ssl.OPENSSL_VERSION, ssl.OPENSSL_VERSION_INFO))
  1825. print(" under %s" % plat)
  1826. print(" HAS_SNI = %r" % ssl.HAS_SNI)
  1827. for filename in [
  1828. CERTFILE, SVN_PYTHON_ORG_ROOT_CERT, BYTES_CERTFILE,
  1829. ONLYCERT, ONLYKEY, BYTES_ONLYCERT, BYTES_ONLYKEY,
  1830. BADCERT, BADKEY, EMPTYCERT]:
  1831. if not os.path.exists(filename):
  1832. raise support.TestFailed("Can't read certificate file %r" % filename)
  1833. tests = [ContextTests, BasicSocketTests, SSLErrorTests]
  1834. if support.is_resource_enabled('network'):
  1835. tests.append(NetworkedTests)
  1836. if _have_threads:
  1837. thread_info = support.threading_setup()
  1838. if thread_info and support.is_resource_enabled('network'):
  1839. tests.append(ThreadedTests)
  1840. try:
  1841. support.run_unittest(*tests)
  1842. finally:
  1843. if _have_threads:
  1844. support.threading_cleanup(*thread_info)
  1845. if __name__ == "__main__":
  1846. test_main()