Debian Codegraph @

tests/ssl_test.py

raw
1 import random
2 import sys
3 import warnings
4
5 import pytest
6
7 import eventlet
8 from eventlet import greenio
9 from eventlet.green import socket
10 try:
11 from eventlet.green import ssl
12 except ImportError:
13 __test__ = False
14 import tests
15
16
17 def listen_ssl_socket(address=('localhost', 0), **kwargs):
18 sock = ssl.wrap_socket(
19 socket.socket(),
20 tests.private_key_file,
21 tests.certificate_file,
22 server_side=True,
23 **kwargs
24 )
25 sock.bind(address)
26 sock.listen(50)
27 return sock
28
29
30 class SSLTest(tests.LimitedTestCase):
31 def setUp(self):
32 # disabling socket.ssl warnings because we're testing it here
33 warnings.filterwarnings(
34 action='ignore',
35 message='.*socket.ssl.*',
36 category=DeprecationWarning)
37
38 super().setUp()
39
40 def test_duplex_response(self):
41 def serve(listener):
42 sock, addr = listener.accept()
43 sock.recv(8192)
44 sock.sendall(b'response')
45
46 sock = listen_ssl_socket()
47
48 server_coro = eventlet.spawn(serve, sock)
49
50 client = ssl.wrap_socket(eventlet.connect(sock.getsockname()))
51 client.sendall(b'line 1\r\nline 2\r\n\r\n')
52 self.assertEqual(client.recv(8192), b'response')
53 server_coro.wait()
54
55 def test_ssl_context(self):
56 def serve(listener):
57 sock, addr = listener.accept()
58 sock.recv(8192)
59 sock.sendall(b'response')
60
61 sock = listen_ssl_socket()
62
63 server_coro = eventlet.spawn(serve, sock)
64
65 context = ssl.create_default_context()
66 context.verify_mode = ssl.CERT_REQUIRED
67 context.check_hostname = True
68 context.load_verify_locations(tests.certificate_file)
69
70 client = context.wrap_socket(
71 eventlet.connect(sock.getsockname()),
72 server_hostname='Test')
73 client.sendall(b'line 1\r\nline 2\r\n\r\n')
74 self.assertEqual(client.recv(8192), b'response')
75 server_coro.wait()
76
77 def test_ssl_close(self):
78 def serve(listener):
79 sock, addr = listener.accept()
80 sock.recv(8192)
81 try:
82 self.assertEqual(b'', sock.recv(8192))
83 except (greenio.SSL.ZeroReturnError,
84 BrokenPipeError):
85 pass
86
87 sock = listen_ssl_socket()
88
89 server_coro = eventlet.spawn(serve, sock)
90
91 raw_client = eventlet.connect(sock.getsockname())
92 client = ssl.wrap_socket(raw_client)
93 client.sendall(b'X')
94 greenio.shutdown_safe(client)
95 client.close()
96 server_coro.wait()
97
98 def test_ssl_connect(self):
99 def serve(listener):
100 sock, addr = listener.accept()
101 sock.recv(8192)
102 sock = listen_ssl_socket()
103 server_coro = eventlet.spawn(serve, sock)
104
105 raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
106 ssl_client = ssl.wrap_socket(raw_client)
107 ssl_client.connect(sock.getsockname())
108 ssl_client.sendall(b'abc')
109 greenio.shutdown_safe(ssl_client)
110 ssl_client.close()
111 server_coro.wait()
112
113 def test_recv_after_ssl_connect(self):
114 def serve(listener):
115 sock, addr = listener.accept()
116 sock.sendall(b'hjk')
117 sock = listen_ssl_socket()
118 server_coro = eventlet.spawn(serve, sock)
119
120 raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
121 ssl_client = ssl.wrap_socket(raw_client)
122 # Important: We need to call connect() on an SSL socket, not a plain one.
123 # The bug was affecting that particular combination (create plain socket,
124 # wrap, call connect() on the SSL socket and try to recv) on Python 3.5.
125 ssl_client.connect(sock.getsockname())
126
127 # The call to recv used to fail with:
128 # Traceback (most recent call last):
129 # File "tests/ssl_test.py", line 99, in test_recv_after_ssl_connect
130 # self.assertEqual(ssl_client.recv(3), b'hjk')
131 # File "eventlet/green/ssl.py", line 194, in recv
132 # return self._base_recv(buflen, flags, into=False)
133 # File "eventlet/green/ssl.py", line 227, in _base_recv
134 # read = self.read(nbytes)
135 # File "eventlet/green/ssl.py", line 139, in read
136 # super(GreenSSLSocket, self).read, *args, **kwargs)
137 # File "eventlet/green/ssl.py", line 113, in _call_trampolining
138 # return func(*a, **kw)
139 # File "PYTHONLIB/python3.5/ssl.py", line 791, in read
140 # return self._sslobj.read(len, buffer)
141 # TypeError: read() argument 2 must be read-write bytes-like object, not None
142 self.assertEqual(ssl_client.recv(3), b'hjk')
143
144 greenio.shutdown_safe(ssl_client)
145 ssl_client.close()
146 server_coro.wait()
147
148 def test_ssl_unwrap(self):
149 def serve():
150 sock, addr = listener.accept()
151 self.assertEqual(sock.recv(6), b'before')
152 sock_ssl = ssl.wrap_socket(sock, tests.private_key_file, tests.certificate_file,
153 server_side=True)
154 sock_ssl.do_handshake()
155 self.assertEqual(sock_ssl.recv(6), b'during')
156 sock2 = sock_ssl.unwrap()
157 self.assertEqual(sock2.recv(5), b'after')
158 sock2.close()
159
160 listener = eventlet.listen(('127.0.0.1', 0))
161 server_coro = eventlet.spawn(serve)
162 client = eventlet.connect(listener.getsockname())
163 client.sendall(b'before')
164 client_ssl = ssl.wrap_socket(client)
165 client_ssl.do_handshake()
166 client_ssl.sendall(b'during')
167 client2 = client_ssl.unwrap()
168 client2.sendall(b'after')
169 server_coro.wait()
170
171 def test_sendall_cpu_usage(self):
172 """SSL socket.sendall() busy loop
173
174 https://bitbucket.org/eventlet/eventlet/issue/134/greenssl-performance-issues
175
176 Idea of this test is to check that GreenSSLSocket.sendall() does not busy loop
177 retrying .send() calls, but instead trampolines until socket is writeable.
178
179 BUFFER_SIZE and SENDALL_SIZE are magic numbers inferred through trial and error.
180 """
181 # Time limit resistant to busy loops
182 self.set_alarm(1)
183
184 stage_1 = eventlet.event.Event()
185 BUFFER_SIZE = 1000
186 SENDALL_SIZE = 100000
187
188 def serve(listener):
189 conn, _ = listener.accept()
190 conn.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, BUFFER_SIZE)
191 self.assertEqual(conn.recv(8), b'request')
192 conn.sendall(b'response')
193
194 stage_1.wait()
195 conn.sendall(b'x' * SENDALL_SIZE)
196
197 server_sock = listen_ssl_socket()
198 server_coro = eventlet.spawn(serve, server_sock)
199
200 client_sock = eventlet.connect(server_sock.getsockname())
201 client_sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, BUFFER_SIZE)
202 client = ssl.wrap_socket(client_sock)
203 client.sendall(b'request')
204 self.assertEqual(client.recv(8), b'response')
205 stage_1.send()
206
207 tests.check_idle_cpu_usage(0.2, 0.1)
208 server_coro.kill()
209
210 def test_greensslobject(self):
211 def serve(listener):
212 sock, addr = listener.accept()
213 sock.sendall(b'content')
214 greenio.shutdown_safe(sock)
215 sock.close()
216 listener = listen_ssl_socket()
217 eventlet.spawn(serve, listener)
218 client = ssl.wrap_socket(eventlet.connect(listener.getsockname()))
219 self.assertEqual(client.recv(1024), b'content')
220 self.assertEqual(client.recv(1024), b'')
221
222 @pytest.mark.xfail(sys.platform == "darwin", reason="Fails on macOS for some reason")
223 def test_regression_gh_17(self):
224 # https://github.com/eventlet/eventlet/issues/17
225 # ssl wrapped but unconnected socket methods go special code path
226 # test that path at least for syntax/typo errors
227 sock = ssl.wrap_socket(socket.socket())
228 sock.settimeout(0.01)
229 try:
230 sock.sendall(b'')
231 except ssl.SSLError as e:
232 assert 'timed out' in str(e)
233
234 def test_no_handshake_block_accept_loop(self):
235 listener = listen_ssl_socket()
236 listener.settimeout(0.3)
237
238 def serve(sock):
239 try:
240 name = sock.recv(8)
241 sock.sendall(b'hello ' + name)
242 except Exception:
243 # ignore evil clients
244 pass
245 finally:
246 greenio.shutdown_safe(sock)
247 sock.close()
248
249 def accept_loop():
250 while True:
251 try:
252 sock, _ = listener.accept()
253 except OSError:
254 return
255 eventlet.spawn(serve, sock)
256
257 loopt = eventlet.spawn(accept_loop)
258
259 # evil no handshake
260 evil = eventlet.connect(listener.getsockname())
261 good = ssl.wrap_socket(eventlet.connect(listener.getsockname()))
262 good.sendall(b'good')
263 response = good.recv(16)
264 good.close()
265 assert response == b'hello good'
266 evil.close()
267
268 listener.close()
269 loopt.wait()
270 eventlet.sleep(0)
271
272 def test_receiving_doesnt_block_if_there_is_already_decrypted_buffered_data(self):
273 # Here's what could (and would) happen before the relevant bug was fixed (assuming method
274 # M was trampolining unconditionally before actually reading):
275 # 1. One side sends n bytes, leaves connection open (important)
276 # 2. The other side uses method M to read m (where m < n) bytes, the underlying SSL
277 # implementation reads everything from the underlying socket, decrypts all n bytes,
278 # returns m of them and buffers n-m to be read later.
279 # 3. The other side tries to read the remainder of the data (n-m bytes), this blocks
280 # because M trampolines uncoditionally and trampoline will hang because reading from
281 # the underlying socket would block. It would block because there's no data to be read
282 # and the connection is still open; leaving the connection open /mentioned in 1./ is
283 # important because otherwise trampoline would return immediately and the test would pass
284 # even with the bug still present in the code).
285 #
286 # The solution is to first request data from the underlying SSL implementation and only
287 # trampoline if we actually need to read some data from the underlying socket.
288 #
289 # GreenSSLSocket.recv() wasn't broken but I've added code to test it as well for
290 # completeness.
291 content = b'xy'
292
293 def recv(sock, expected):
294 assert sock.recv(len(expected)) == expected
295
296 def recv_into(sock, expected):
297 buf = bytearray(len(expected))
298 assert sock.recv_into(buf, len(expected)) == len(expected)
299 assert buf == expected
300
301 for read_function in [recv, recv_into]:
302 print('Trying %s...' % (read_function,))
303 listener = listen_ssl_socket()
304
305 def accept(listener):
306 sock, addr = listener.accept()
307 sock.sendall(content)
308 return sock
309
310 accepter = eventlet.spawn(accept, listener)
311
312 client_to_server = None
313 try:
314 client_to_server = ssl.wrap_socket(eventlet.connect(listener.getsockname()))
315 for character in iter(content):
316 character = bytes((character,))
317 print('We have %d already decrypted bytes pending, expecting: %s' % (
318 client_to_server.pending(), character))
319 read_function(client_to_server, character)
320 finally:
321 if client_to_server is not None:
322 client_to_server.close()
323 server_to_client = accepter.wait()
324
325 # Very important: we only want to close the socket *after* the other side has
326 # read the data it wanted already, otherwise this would defeat the purpose of the
327 # test (see the comment at the top of this test).
328 server_to_client.close()
329
330 listener.close()
331
332 def test_context_wrapped_accept(self):
333 context = ssl.SSLContext(ssl.PROTOCOL_TLS)
334 context.load_cert_chain(tests.certificate_file, tests.private_key_file)
335 expected = "success:{}".format(random.random()).encode()
336
337 def client(addr):
338 client_tls = ssl.wrap_socket(
339 eventlet.connect(addr),
340 cert_reqs=ssl.CERT_REQUIRED,
341 ca_certs=tests.certificate_file,
342 )
343 client_tls.send(expected)
344
345 server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
346 server_sock.bind(('localhost', 0))
347 server_sock.listen(1)
348 eventlet.spawn(client, server_sock.getsockname())
349 server_tls = context.wrap_socket(server_sock, server_side=True)
350 peer, _ = server_tls.accept()
351 assert peer.recv(64) == expected
352 peer.close()
353
354 def test_explicit_keys_accept(self):
355 expected = "success:{}".format(random.random()).encode()
356
357 def client(addr):
358 client_tls = ssl.wrap_socket(
359 eventlet.connect(addr),
360 cert_reqs=ssl.CERT_REQUIRED,
361 ca_certs=tests.certificate_file,
362 )
363 client_tls.send(expected)
364
365 server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
366 server_sock.bind(('localhost', 0))
367 server_sock.listen(1)
368 eventlet.spawn(client, server_sock.getsockname())
369 server_tls = ssl.wrap_socket(
370 server_sock, server_side=True,
371 keyfile=tests.private_key_file, certfile=tests.certificate_file,
372 )
373 peer, _ = server_tls.accept()
374 assert peer.recv(64) == expected
375 peer.close()
376
377 def test_client_check_hostname(self):
378 # stdlib API compatibility
379 # https://github.com/eventlet/eventlet/issues/567
380 def serve(listener):
381 sock, addr = listener.accept()
382 sock.recv(64)
383 sock.sendall(b"response")
384 sock.close()
385
386 listener = listen_ssl_socket()
387 server_coro = eventlet.spawn(serve, listener)
388 ctx = ssl.create_default_context()
389 ctx.verify_mode = ssl.CERT_REQUIRED
390 ctx.check_hostname = True
391 ctx.load_verify_locations(tests.certificate_file)
392 ctx.load_cert_chain(tests.certificate_file, tests.private_key_file)
393 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
394 client = ctx.wrap_socket(sock, server_hostname="Test")
395 client.connect(listener.getsockname())
396 client.send(b"check_hostname works")
397 client.recv(64)
398 server_coro.wait()
399
400 @tests.skip_if(sys.version_info < (3, 7))
401 def test_context_version_setters(self):
402 tests.run_isolated("ssl_context_version_setters.py")