Debian Codegraph @

tests/websocket_new_test.py

raw
1 import errno
2 import struct
3 import re
4
5 import eventlet
6 from eventlet import event
7 from eventlet import websocket
8 from eventlet.green import httplib
9 from eventlet.green import socket
10
11 import tests.wsgi_test
12
13
14 # demo app
15 def handle(ws):
16 if ws.path == '/echo':
17 while True:
18 m = ws.wait()
19 if m is None:
20 break
21 ws.send(m)
22 elif ws.path == '/range':
23 for i in range(10):
24 ws.send("msg %d" % i)
25 eventlet.sleep(0.01)
26 elif ws.path == '/error':
27 # some random socket error that we shouldn't normally get
28 raise OSError(errno.ENOTSOCK)
29 else:
30 ws.close()
31
32
33 # Set a lower limit of DEFAULT_MAX_FRAME_LENGTH for testing, as
34 # sending an 8MiB frame over the loopback interface can trigger a
35 # timeout.
36 TEST_MAX_FRAME_LENGTH = 50000
37 wsapp = websocket.WebSocketWSGI(handle, max_frame_length=TEST_MAX_FRAME_LENGTH)
38
39
40 class TestWebSocket(tests.wsgi_test._TestBase):
41 TEST_TIMEOUT = 5
42
43 def set_site(self):
44 self.site = wsapp
45
46 def test_incomplete_headers_13(self):
47 headers = dict(kv.split(': ') for kv in [
48 "Upgrade: websocket",
49 # NOTE: intentionally no connection header
50 "Host: %s:%s" % self.server_addr,
51 "Origin: http://%s:%s" % self.server_addr,
52 "Sec-WebSocket-Version: 13",
53 ])
54 http = httplib.HTTPConnection(*self.server_addr)
55 http.request("GET", "/echo", headers=headers)
56 resp = http.getresponse()
57
58 self.assertEqual(resp.status, 400)
59 self.assertEqual(resp.getheader('connection'), 'close')
60 self.assertEqual(resp.read(), b'')
61
62 # Now, miss off key
63 headers = dict(kv.split(': ') for kv in [
64 "Upgrade: websocket",
65 "Connection: Upgrade",
66 "Host: %s:%s" % self.server_addr,
67 "Origin: http://%s:%s" % self.server_addr,
68 "Sec-WebSocket-Version: 13",
69 ])
70 http = httplib.HTTPConnection(*self.server_addr)
71 http.request("GET", "/echo", headers=headers)
72 resp = http.getresponse()
73
74 self.assertEqual(resp.status, 400)
75 self.assertEqual(resp.getheader('connection'), 'close')
76 self.assertEqual(resp.read(), b'')
77
78 # No Upgrade now
79 headers = dict(kv.split(': ') for kv in [
80 "Connection: Upgrade",
81 "Host: %s:%s" % self.server_addr,
82 "Origin: http://%s:%s" % self.server_addr,
83 "Sec-WebSocket-Version: 13",
84 ])
85 http = httplib.HTTPConnection(*self.server_addr)
86 http.request("GET", "/echo", headers=headers)
87 resp = http.getresponse()
88
89 self.assertEqual(resp.status, 400)
90 self.assertEqual(resp.getheader('connection'), 'close')
91 self.assertEqual(resp.read(), b'')
92
93 def test_correct_upgrade_request_13(self):
94 for http_connection in ['Upgrade', 'UpGrAdE', 'keep-alive, Upgrade']:
95 connect = [
96 "GET /echo HTTP/1.1",
97 "Upgrade: websocket",
98 "Connection: %s" % http_connection,
99 "Host: %s:%s" % self.server_addr,
100 "Origin: http://%s:%s" % self.server_addr,
101 "Sec-WebSocket-Version: 13",
102 "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==",
103 ]
104 sock = eventlet.connect(self.server_addr)
105
106 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
107 result = sock.recv(1024)
108 # The server responds the correct Websocket handshake
109 print('Connection string: %r' % http_connection)
110 self.assertEqual(result, ('\r\n'.join([
111 'HTTP/1.1 101 Switching Protocols',
112 'Upgrade: websocket',
113 'Connection: Upgrade',
114 'Sec-WebSocket-Accept: ywSyWXCPNsDxLrQdQrn5RFNRfBU=\r\n\r\n',
115 ])).encode())
116
117 def test_send_recv_13(self):
118 connect = [
119 "GET /echo HTTP/1.1",
120 "Upgrade: websocket",
121 "Connection: Upgrade",
122 "Host: %s:%s" % self.server_addr,
123 "Origin: http://%s:%s" % self.server_addr,
124 "Sec-WebSocket-Version: 13",
125 "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==",
126 ]
127 sock = eventlet.connect(self.server_addr)
128 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
129 sock.recv(1024)
130 ws = websocket.RFC6455WebSocket(sock, {}, client=True)
131 ws.send(b'hello')
132 assert ws.wait() == b'hello'
133 ws.send(b'hello world!\x01')
134 ws.send('hello world again!')
135 assert ws.wait() == b'hello world!\x01'
136 assert ws.wait() == 'hello world again!'
137 ws.close()
138 eventlet.sleep(0.01)
139
140 def test_breaking_the_connection_13(self):
141 error_detected = [False]
142 done_with_request = event.Event()
143 site = self.site
144
145 def error_detector(environ, start_response):
146 try:
147 try:
148 return site(environ, start_response)
149 except:
150 error_detected[0] = True
151 raise
152 finally:
153 done_with_request.send(True)
154 self.site = error_detector
155 self.spawn_server()
156 connect = [
157 "GET /echo HTTP/1.1",
158 "Upgrade: websocket",
159 "Connection: Upgrade",
160 "Host: %s:%s" % self.server_addr,
161 "Origin: http://%s:%s" % self.server_addr,
162 "Sec-WebSocket-Version: 13",
163 "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==",
164 ]
165 sock = eventlet.connect(self.server_addr)
166 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
167 sock.recv(1024) # get the headers
168 sock.close() # close while the app is running
169 done_with_request.wait()
170 assert not error_detected[0]
171
172 def test_client_closing_connection_13(self):
173 error_detected = [False]
174 done_with_request = event.Event()
175 site = self.site
176
177 def error_detector(environ, start_response):
178 try:
179 try:
180 return site(environ, start_response)
181 except:
182 error_detected[0] = True
183 raise
184 finally:
185 done_with_request.send(True)
186 self.site = error_detector
187 self.spawn_server()
188 connect = [
189 "GET /echo HTTP/1.1",
190 "Upgrade: websocket",
191 "Connection: Upgrade",
192 "Host: %s:%s" % self.server_addr,
193 "Origin: http://%s:%s" % self.server_addr,
194 "Sec-WebSocket-Version: 13",
195 "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==",
196 ]
197 sock = eventlet.connect(self.server_addr)
198 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
199 sock.recv(1024) # get the headers
200 closeframe = struct.pack('!BBIH', 1 << 7 | 8, 1 << 7 | 2, 0, 1000)
201 sock.sendall(closeframe) # "Close the connection" packet.
202 done_with_request.wait()
203 assert not error_detected[0]
204
205 def test_client_invalid_packet_13(self):
206 error_detected = [False]
207 done_with_request = event.Event()
208 site = self.site
209
210 def error_detector(environ, start_response):
211 try:
212 try:
213 return site(environ, start_response)
214 except:
215 error_detected[0] = True
216 raise
217 finally:
218 done_with_request.send(True)
219 self.site = error_detector
220 self.spawn_server()
221 connect = [
222 "GET /echo HTTP/1.1",
223 "Upgrade: websocket",
224 "Connection: Upgrade",
225 "Host: %s:%s" % self.server_addr,
226 "Origin: http://%s:%s" % self.server_addr,
227 "Sec-WebSocket-Version: 13",
228 "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==",
229 ]
230 sock = eventlet.connect(self.server_addr)
231 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
232 sock.recv(1024) # get the headers
233 sock.sendall(b'\x07\xff') # Weird packet.
234 done_with_request.wait()
235 assert not error_detected[0]
236
237
238 class TestWebSocketWithCompression(tests.wsgi_test._TestBase):
239 TEST_TIMEOUT = 5
240
241 def set_site(self):
242 self.site = wsapp
243
244 def setUp(self):
245 super().setUp()
246 self.connect = '\r\n'.join([
247 "GET /echo HTTP/1.1",
248 "Upgrade: websocket",
249 "Connection: upgrade",
250 "Host: %s:%s" % self.server_addr,
251 "Origin: http://%s:%s" % self.server_addr,
252 "Sec-WebSocket-Version: 13",
253 "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==",
254 "Sec-WebSocket-Extensions: %s",
255 '\r\n'
256 ])
257 self.handshake_re = re.compile('\r\n'.join([
258 'HTTP/1.1 101 Switching Protocols',
259 'Upgrade: websocket',
260 'Connection: Upgrade',
261 'Sec-WebSocket-Accept: ywSyWXCPNsDxLrQdQrn5RFNRfBU=',
262 'Sec-WebSocket-Extensions: (.+)'
263 '\r\n',
264 ]).encode())
265
266 @staticmethod
267 def get_deflated_reply(ws):
268 msg = ws._recv_frame(None)
269 msg.decompressor = None
270 return msg.getvalue()
271
272 def test_accept_basic_deflate_ext_13(self):
273 for extension in [
274 'permessage-deflate',
275 'PeRMessAGe-dEFlaTe',
276 ]:
277 sock = eventlet.connect(self.server_addr)
278
279 sock.sendall((self.connect % extension).encode())
280 result = sock.recv(1024)
281
282 # The server responds the correct Websocket handshake
283 # print('Extension offer: %r' % extension)
284 match = re.match(self.handshake_re, result)
285 assert match is not None
286 assert len(match.groups()) == 1
287
288 def test_accept_deflate_ext_context_takeover_13(self):
289 for extension in [
290 'permessage-deflate;CLient_No_conteXT_TAkeOver',
291 'permessage-deflate; SerVER_No_conteXT_TAkeOver',
292 'permessage-deflate; server_no_context_takeover; client_no_context_takeover',
293 ]:
294 sock = eventlet.connect(self.server_addr)
295
296 sock.sendall((self.connect % extension).encode())
297 result = sock.recv(1024)
298
299 # The server responds the correct Websocket handshake
300 # print('Extension offer: %r' % extension)
301 match = re.match(self.handshake_re, result)
302 assert match is not None
303 assert len(match.groups()) == 1
304 offered_ext_parts = (ex.strip().lower() for ex in extension.split(';'))
305 accepted_ext_parts = match.groups()[0].decode().split('; ')
306 assert all(oep in accepted_ext_parts for oep in offered_ext_parts)
307
308 def test_accept_deflate_ext_window_max_bits_13(self):
309 for extension_string, vals in [
310 ('permessage-deflate; client_max_window_bits', [15]),
311 ('permessage-deflate; Server_Max_Window_Bits = 11', [11]),
312 ('permessage-deflate; server_max_window_bits; '
313 'client_max_window_bits=9', [15, 9])
314 ]:
315 sock = eventlet.connect(self.server_addr)
316
317 sock.sendall((self.connect % extension_string).encode())
318 result = sock.recv(1024)
319
320 # The server responds the correct Websocket handshake
321 # print('Extension offer: %r' % extension_string)
322 match = re.match(self.handshake_re, result)
323 assert match is not None
324 assert len(match.groups()) == 1
325
326 offered_parts = [part.strip().lower() for part in extension_string.split(';')]
327 offered_parts_names = [part.split('=')[0].strip() for part in offered_parts]
328 offered_parts_dict = dict(zip(offered_parts_names[1:], vals))
329
330 accepted_ext_parts = match.groups()[0].decode().split('; ')
331 assert accepted_ext_parts[0] == 'permessage-deflate'
332 for param, val in (part.split('=') for part in accepted_ext_parts[1:]):
333 assert int(val) == offered_parts_dict[param]
334
335 def test_reject_max_window_bits_out_of_range_13(self):
336 extension_string = ('permessage-deflate; client_max_window_bits=7,'
337 'permessage-deflate; server_max_window_bits=16, '
338 'permessage-deflate; client_max_window_bits=16; '
339 'server_max_window_bits=7, '
340 'permessage-deflate')
341 sock = eventlet.connect(self.server_addr)
342
343 sock.sendall((self.connect % extension_string).encode())
344 result = sock.recv(1024)
345
346 # The server responds the correct Websocket handshake
347 # print('Extension offer: %r' % extension_string)
348 match = re.match(self.handshake_re, result)
349 assert match.groups()[0] == b'permessage-deflate'
350
351 def test_server_compress_with_context_takeover_13(self):
352 extensions_string = 'permessage-deflate; client_no_context_takeover;'
353 extensions = {'permessage-deflate': {
354 'client_no_context_takeover': True,
355 'server_no_context_takeover': False}}
356
357 sock = eventlet.connect(self.server_addr)
358 sock.sendall((self.connect % extensions_string).encode())
359 sock.recv(1024)
360 ws = websocket.RFC6455WebSocket(sock, {}, client=True,
361 extensions=extensions)
362
363 # Deflated values taken from Section 7.2.3 of RFC 7692
364 # https://tools.ietf.org/html/rfc7692#section-7.2.3
365 ws.send(b'Hello')
366 msg1 = self.get_deflated_reply(ws)
367 assert msg1 == b'\xf2\x48\xcd\xc9\xc9\x07\x00'
368
369 ws.send(b'Hello')
370 msg2 = self.get_deflated_reply(ws)
371 assert msg2 == b'\xf2\x00\x11\x00\x00'
372
373 ws.close()
374 eventlet.sleep(0.01)
375
376 def test_server_compress_no_context_takeover_13(self):
377 extensions_string = 'permessage-deflate; server_no_context_takeover;'
378 extensions = {'permessage-deflate': {
379 'client_no_context_takeover': False,
380 'server_no_context_takeover': True}}
381
382 sock = eventlet.connect(self.server_addr)
383 sock.sendall((self.connect % extensions_string).encode())
384 sock.recv(1024)
385 ws = websocket.RFC6455WebSocket(sock, {}, client=True,
386 extensions=extensions)
387
388 masked_msg1 = ws._pack_message(b'Hello', masked=True)
389 ws._send(masked_msg1)
390 masked_msg2 = ws._pack_message(b'Hello', masked=True)
391 ws._send(masked_msg2)
392 # Verify that client uses context takeover by checking
393 # that the second message
394 assert len(masked_msg2) < len(masked_msg1)
395
396 # Verify that server drops context between messages
397 # Deflated values taken from Section 7.2.3 of RFC 7692
398 # https://tools.ietf.org/html/rfc7692#section-7.2.3
399 reply_msg1 = self.get_deflated_reply(ws)
400 assert reply_msg1 == b'\xf2\x48\xcd\xc9\xc9\x07\x00'
401 reply_msg2 = self.get_deflated_reply(ws)
402 assert reply_msg2 == b'\xf2\x48\xcd\xc9\xc9\x07\x00'
403
404 def test_client_compress_with_context_takeover_13(self):
405 extensions = {'permessage-deflate': {
406 'client_no_context_takeover': False,
407 'server_no_context_takeover': True}}
408 ws = websocket.RFC6455WebSocket(None, {}, client=True,
409 extensions=extensions)
410
411 # Deflated values taken from Section 7.2.3 of RFC 7692
412 # modified opcode to Binary instead of Text
413 # https://tools.ietf.org/html/rfc7692#section-7.2.3
414 packed_msg_1 = ws._pack_message(b'Hello', masked=False)
415 assert packed_msg_1 == b'\xc2\x07\xf2\x48\xcd\xc9\xc9\x07\x00'
416 packed_msg_2 = ws._pack_message(b'Hello', masked=False)
417 assert packed_msg_2 == b'\xc2\x05\xf2\x00\x11\x00\x00'
418
419 eventlet.sleep(0.01)
420
421 def test_client_compress_no_context_takeover_13(self):
422 extensions = {'permessage-deflate': {
423 'client_no_context_takeover': True,
424 'server_no_context_takeover': False}}
425 ws = websocket.RFC6455WebSocket(None, {}, client=True,
426 extensions=extensions)
427
428 # Deflated values taken from Section 7.2.3 of RFC 7692
429 # modified opcode to Binary instead of Text
430 # https://tools.ietf.org/html/rfc7692#section-7.2.3
431 packed_msg_1 = ws._pack_message(b'Hello', masked=False)
432 assert packed_msg_1 == b'\xc2\x07\xf2\x48\xcd\xc9\xc9\x07\x00'
433 packed_msg_2 = ws._pack_message(b'Hello', masked=False)
434 assert packed_msg_2 == b'\xc2\x07\xf2\x48\xcd\xc9\xc9\x07\x00'
435
436 def test_compressed_send_recv_13(self):
437 extensions_string = 'permessage-deflate'
438 extensions = {'permessage-deflate': {
439 'client_no_context_takeover': False,
440 'server_no_context_takeover': False}}
441
442 sock = eventlet.connect(self.server_addr)
443 sock.sendall((self.connect % extensions_string).encode())
444 sock.recv(1024)
445 ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions)
446
447 ws.send(b'hello')
448 assert ws.wait() == b'hello'
449 ws.send(b'hello world!')
450 ws.send('hello world again!')
451 assert ws.wait() == b'hello world!'
452 assert ws.wait() == 'hello world again!'
453
454 ws.close()
455 eventlet.sleep(0.01)
456
457 def test_send_uncompressed_msg_13(self):
458 extensions_string = 'permessage-deflate'
459 extensions = {'permessage-deflate': {
460 'client_no_context_takeover': False,
461 'server_no_context_takeover': False}}
462
463 sock = eventlet.connect(self.server_addr)
464 sock.sendall((self.connect % extensions_string).encode())
465 sock.recv(1024)
466
467 # Send without using deflate, having rsv1 unset
468 ws = websocket.RFC6455WebSocket(sock, {}, client=True)
469 ws.send(b'Hello')
470
471 # Adding extensions to recognise deflated response
472 ws.extensions = extensions
473 assert ws.wait() == b'Hello'
474
475 ws.close()
476 eventlet.sleep(0.01)
477
478 def test_compressed_send_recv_client_no_context_13(self):
479 extensions_string = 'permessage-deflate; client_no_context_takeover'
480 extensions = {'permessage-deflate': {
481 'client_no_context_takeover': True,
482 'server_no_context_takeover': False}}
483
484 sock = eventlet.connect(self.server_addr)
485 sock.sendall((self.connect % extensions_string).encode())
486 sock.recv(1024)
487 ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions)
488
489 ws.send(b'hello')
490 assert ws.wait() == b'hello'
491 ws.send(b'hello world!')
492 ws.send('hello world again!')
493 assert ws.wait() == b'hello world!'
494 assert ws.wait() == 'hello world again!'
495
496 ws.close()
497 eventlet.sleep(0.01)
498
499 def test_compressed_send_recv_server_no_context_13(self):
500 extensions_string = 'permessage-deflate; server_no_context_takeover'
501 extensions = {'permessage-deflate': {
502 'client_no_context_takeover': False,
503 'server_no_context_takeover': False}}
504
505 sock = eventlet.connect(self.server_addr)
506 sock.sendall((self.connect % extensions_string).encode())
507 sock.recv(1024)
508 ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions)
509
510 ws.send(b'hello')
511 assert ws.wait() == b'hello'
512 ws.send(b'hello world!')
513 ws.send('hello world again!')
514 assert ws.wait() == b'hello world!'
515 assert ws.wait() == 'hello world again!'
516
517 ws.close()
518 eventlet.sleep(0.01)
519
520 def test_compressed_send_recv_both_no_context_13(self):
521 extensions_string = ('permessage-deflate;'
522 ' server_no_context_takeover; client_no_context_takeover')
523 extensions = {'permessage-deflate': {
524 'client_no_context_takeover': True,
525 'server_no_context_takeover': True}}
526
527 sock = eventlet.connect(self.server_addr)
528 sock.sendall((self.connect % extensions_string).encode())
529 sock.recv(1024)
530 ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions)
531
532 ws.send(b'hello')
533 assert ws.wait() == b'hello'
534 ws.send(b'hello world!')
535 ws.send('hello world again!')
536 assert ws.wait() == b'hello world!'
537 assert ws.wait() == 'hello world again!'
538
539 ws.close()
540 eventlet.sleep(0.01)
541
542 def test_large_frame_size_compressed_13(self):
543 # Test fix for GHSA-9p9m-jm8w-94p2
544 extensions_string = 'permessage-deflate'
545 extensions = {'permessage-deflate': {
546 'client_no_context_takeover': False,
547 'server_no_context_takeover': False}}
548
549 sock = eventlet.connect(self.server_addr)
550 sock.sendall((self.connect % extensions_string).encode())
551 sock.recv(1024)
552 ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions)
553
554 should_still_fit = b"x" * TEST_MAX_FRAME_LENGTH
555 one_too_much = should_still_fit + b"x"
556
557 # send just fitting frame twice to make sure they are fine independently
558 ws.send(should_still_fit)
559 assert ws.wait() == should_still_fit
560 ws.send(should_still_fit)
561 assert ws.wait() == should_still_fit
562 ws.send(one_too_much)
563
564 res = ws.wait()
565 assert res is None # socket closed
566 # TODO: The websocket currently sents compressed control frames, which contradicts RFC7692.
567 # Renable the following assert after that has been fixed.
568 # assert ws._remote_close_data == b"\x03\xf1Incoming compressed frame is above length limit."
569 eventlet.sleep(0.01)
570
571 def test_large_frame_size_uncompressed_13(self):
572 # Test fix for GHSA-9p9m-jm8w-94p2
573 sock = eventlet.connect(self.server_addr)
574 sock.sendall(self.connect.encode())
575 sock.recv(1024)
576 ws = websocket.RFC6455WebSocket(sock, {}, client=True)
577
578 should_still_fit = b"x" * TEST_MAX_FRAME_LENGTH
579 one_too_much = should_still_fit + b"x"
580
581 # send just fitting frame twice to make sure they are fine independently
582 ws.send(should_still_fit)
583 assert ws.wait() == should_still_fit
584 ws.send(should_still_fit)
585 assert ws.wait() == should_still_fit
586 ws.send(one_too_much)
587
588 res = ws.wait()
589 assert res is None # socket closed
590 # close code should be available now
591 assert ws._remote_close_data == b"\x03\xf1Incoming frame of 50001 bytes is above length limit of 50000 bytes."
592 eventlet.sleep(0.01)