Added support for SSL connection to unverified host. (#137)

engineio/asyncio_client.py

@@ -1,4 +1,5 @@
 import asyncio
+import ssl
 
 try:
     import aiohttp
@@ -248,9 +249,17 @@ async def _connect_websocket(self, url, headers, engineio_path):
             headers['Cookie'] = cookies
 
         try:
-            ws = await websockets.connect(
-                websocket_url + self._get_url_timestamp(),
-                extra_headers=headers)
+            if not self.ssl_verify:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+                ws = await websockets.connect(
+                    websocket_url + self._get_url_timestamp(),
+                    extra_headers=headers, ssl=ssl_context)
+            else:
+                ws = await websockets.connect(
+                    websocket_url + self._get_url_timestamp(),
+                    extra_headers=headers)
         except (websockets.exceptions.InvalidURI,
                 websockets.exceptions.InvalidHandshake,
                 OSError):
@@ -357,10 +366,17 @@ async def _send_request(
         if self.http is None or self.http.closed:
             self.http = aiohttp.ClientSession()
         http_method = getattr(self.http, method.lower())
+
         try:
-            return await http_method(
-                url, headers=headers, data=body,
-                timeout=aiohttp.ClientTimeout(total=timeout))
+            if not self.ssl_verify:
+                return await http_method(
+                    url, headers=headers, data=body,
+                    timeout=aiohttp.ClientTimeout(total=timeout), ssl=False)
+            else:
+                return await http_method(
+                    url, headers=headers, data=body,
+                    timeout=aiohttp.ClientTimeout(total=timeout))
+
         except (aiohttp.ClientError, asyncio.TimeoutError) as exc:
             self.logger.info('HTTP %s request to %s failed with error %s.',
                              method, url, exc)

engineio/client.py

@@ -4,6 +4,7 @@
 except ImportError:  # pragma: no cover
     import Queue as queue
 import signal
+import ssl
 import threading
 import time
 
@@ -59,10 +60,18 @@ class Client(object):
                  versions.
     :param request_timeout: A timeout in seconds for requests. The default is
                             5 seconds.
+    :param ssl_verify: ``True`` if SSL connections should be fully verified or
+                       ``False`` to skip SSL certificate verification allowing
+                       connection to server with self signed certificates. The
+                       default is ``True``
     """
     event_names = ['connect', 'disconnect', 'message']
 
-    def __init__(self, logger=False, json=None, request_timeout=5):
+    def __init__(self,
+                 logger=False,
+                 json=None,
+                 request_timeout=5,
+                 ssl_verify=True):
         self.handlers = {}
         self.base_url = None
         self.transports = None
@@ -80,6 +89,7 @@ def __init__(self, logger=False, json=None, request_timeout=5):
         self.ping_loop_event = self.create_event()
         self.queue = None
         self.state = 'disconnected'
+        self.ssl_verify = ssl_verify
 
         if json is not None:
             packet.Packet.json = json
@@ -340,10 +350,16 @@ def _connect_websocket(self, url, headers, engineio_path):
         if self.http:
             cookies = '; '.join(["{}={}".format(cookie.name, cookie.value)
                                  for cookie in self.http.cookies])
+
         try:
-            ws = websocket.create_connection(
-                websocket_url + self._get_url_timestamp(), header=headers,
-                cookie=cookies)
+            if not self.ssl_verify:
+                ws = websocket.create_connection(
+                    websocket_url + self._get_url_timestamp(), header=headers,
+                    cookie=cookies, sslopt={"cert_reqs": ssl.CERT_NONE})
+            else:
+                ws = websocket.create_connection(
+                    websocket_url + self._get_url_timestamp(), header=headers,
+                    cookie=cookies)
         except ConnectionError:
             if upgrade:
                 self.logger.warning(
@@ -448,7 +464,7 @@ def _send_request(
             self.http = requests.Session()
         try:
             return self.http.request(method, url, headers=headers, data=body,
-                                     timeout=timeout)
+                                     timeout=timeout, verify=self.ssl_verify)
         except requests.exceptions.RequestException as exc:
             self.logger.info('HTTP %s request to %s failed with error %s.',
                              method, url, exc)

tests/asyncio/test_asyncio_client.py

@@ -1,4 +1,5 @@
 import asyncio
+import ssl
 import sys
 import time
 import unittest
@@ -337,6 +338,41 @@ def test_polling_connection_successful(self):
         self.assertEqual(c.upgrades, [])
         self.assertEqual(c.transport(), 'polling')
 
+    def test_polling_https_noverify_connection_successful(self):
+        c = asyncio_client.AsyncClient(ssl_verify=False)
+        c._send_request = AsyncMock()
+        c._send_request.mock.return_value.status = 200
+        c._send_request.mock.return_value.read = AsyncMock(
+            return_value=payload.Payload(packets=[
+                packet.Packet(packet.OPEN, {
+                    'sid': '123', 'upgrades': [], 'pingInterval': 1000,
+                    'pingTimeout': 2000
+                })
+            ]).encode())
+        c._ping_loop = AsyncMock()
+        c._read_loop_polling = AsyncMock()
+        c._read_loop_websocket = AsyncMock()
+        c._write_loop = AsyncMock()
+        on_connect = AsyncMock()
+        c.on('connect', on_connect)
+        _run(c.connect('https://foo'))
+        time.sleep(0.1)
+
+        c._ping_loop.mock.assert_called_once_with()
+        c._read_loop_polling.mock.assert_called_once_with()
+        c._read_loop_websocket.mock.assert_not_called()
+        c._write_loop.mock.assert_called_once_with()
+        on_connect.mock.assert_called_once_with()
+        self.assertIn(c, client.connected_clients)
+        self.assertEqual(
+            c.base_url,
+            'https://foo/engine.io/?transport=polling&EIO=3&sid=123')
+        self.assertEqual(c.sid, '123')
+        self.assertEqual(c.ping_interval, 1)
+        self.assertEqual(c.ping_timeout, 2)
+        self.assertEqual(c.upgrades, [])
+        self.assertEqual(c.transport(), 'polling')
+
     def test_polling_connection_with_more_packets(self):
         c = asyncio_client.AsyncClient()
         c._send_request = AsyncMock()
@@ -493,6 +529,45 @@ def test_websocket_connection_successful(self, _time):
             'ws://foo/engine.io/?transport=websocket&EIO=3&t=123.456',
             extra_headers={})
 
+    @mock.patch('engineio.client.time.time', return_value=123.456)
+    @mock.patch('engineio.asyncio_client.websockets.connect', new=AsyncMock())
+    def test_websocket_https_noverify_connection_successful(self, _time):
+        ws = asyncio_client.websockets.connect.mock.return_value
+        ws.recv = AsyncMock(return_value=packet.Packet(
+            packet.OPEN, {
+                'sid': '123', 'upgrades': [], 'pingInterval': 1000,
+                'pingTimeout': 2000
+            }).encode())
+        c = asyncio_client.AsyncClient(ssl_verify=False)
+        c._ping_loop = AsyncMock()
+        c._read_loop_polling = AsyncMock()
+        c._read_loop_websocket = AsyncMock()
+        c._write_loop = AsyncMock()
+        on_connect = mock.MagicMock()
+        c.on('connect', on_connect)
+        _run(c.connect('wss://foo', transports=['websocket']))
+        time.sleep(0.1)
+
+        c._ping_loop.mock.assert_called_once_with()
+        c._read_loop_polling.mock.assert_not_called()
+        c._read_loop_websocket.mock.assert_called_once_with()
+        c._write_loop.mock.assert_called_once_with()
+        on_connect.assert_called_once_with()
+        self.assertIn(c, client.connected_clients)
+        self.assertEqual(
+            c.base_url,
+            'wss://foo/engine.io/?transport=websocket&EIO=3')
+        self.assertEqual(c.sid, '123')
+        self.assertEqual(c.ping_interval, 1)
+        self.assertEqual(c.ping_timeout, 2)
+        self.assertEqual(c.upgrades, [])
+        self.assertEqual(c.transport(), 'websocket')
+        self.assertEqual(c.ws, ws)
+        _, kwargs = asyncio_client.websockets.connect.mock.call_args
+        self.assertTrue('ssl' in kwargs)
+        self.assertTrue(isinstance(kwargs['ssl'], ssl.SSLContext))
+        self.assertEqual(kwargs['ssl'].verify_mode, ssl.CERT_NONE)
+
     @mock.patch('engineio.client.time.time', return_value=123.456)
     @mock.patch('engineio.asyncio_client.websockets.connect', new=AsyncMock())
     def test_websocket_connection_with_cookies(self, _time):

tests/common/test_client.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import ssl
 import time
 import unittest
 
@@ -349,6 +350,40 @@ def test_polling_connection_successful(self, _send_request):
         self.assertEqual(c.upgrades, [])
         self.assertEqual(c.transport(), 'polling')
 
+    @mock.patch('engineio.client.Client._send_request')
+    def test_polling_https_noverify_connection_successful(self, _send_request):
+        _send_request.return_value.status_code = 200
+        _send_request.return_value.content = payload.Payload(packets=[
+            packet.Packet(packet.OPEN, {
+                'sid': '123', 'upgrades': [], 'pingInterval': 1000,
+                'pingTimeout': 2000
+            })
+        ]).encode()
+        c = client.Client(ssl_verify=False)
+        c._ping_loop = mock.MagicMock()
+        c._read_loop_polling = mock.MagicMock()
+        c._read_loop_websocket = mock.MagicMock()
+        c._write_loop = mock.MagicMock()
+        on_connect = mock.MagicMock()
+        c.on('connect', on_connect)
+        c.connect('https://foo')
+        time.sleep(0.1)
+
+        c._ping_loop.assert_called_once_with()
+        c._read_loop_polling.assert_called_once_with()
+        c._read_loop_websocket.assert_not_called()
+        c._write_loop.assert_called_once_with()
+        on_connect.assert_called_once_with()
+        self.assertIn(c, client.connected_clients)
+        self.assertEqual(
+            c.base_url,
+            'https://foo/engine.io/?transport=polling&EIO=3&sid=123')
+        self.assertEqual(c.sid, '123')
+        self.assertEqual(c.ping_interval, 1)
+        self.assertEqual(c.ping_timeout, 2)
+        self.assertEqual(c.upgrades, [])
+        self.assertEqual(c.transport(), 'polling')
+
     @mock.patch('engineio.client.Client._send_request')
     def test_polling_connection_with_more_packets(self, _send_request):
         _send_request.return_value.status_code = 200
@@ -496,6 +531,44 @@ def test_websocket_connection_successful(self, create_connection):
         self.assertEqual(create_connection.call_args[1],
                          {'header': {}, 'cookie': None})
 
+    @mock.patch('engineio.client.websocket.create_connection')
+    def test_websocket_https_noverify_connection_successful(
+            self, create_connection):
+        create_connection.return_value.recv.return_value = packet.Packet(
+            packet.OPEN, {
+                'sid': '123', 'upgrades': [], 'pingInterval': 1000,
+                'pingTimeout': 2000
+            }).encode()
+        c = client.Client(ssl_verify=False)
+        c._ping_loop = mock.MagicMock()
+        c._read_loop_polling = mock.MagicMock()
+        c._read_loop_websocket = mock.MagicMock()
+        c._write_loop = mock.MagicMock()
+        on_connect = mock.MagicMock()
+        c.on('connect', on_connect)
+        c.connect('wss://foo', transports=['websocket'])
+        time.sleep(0.1)
+
+        c._ping_loop.assert_called_once_with()
+        c._read_loop_polling.assert_not_called()
+        c._read_loop_websocket.assert_called_once_with()
+        c._write_loop.assert_called_once_with()
+        on_connect.assert_called_once_with()
+        self.assertIn(c, client.connected_clients)
+        self.assertEqual(
+            c.base_url,
+            'wss://foo/engine.io/?transport=websocket&EIO=3')
+        self.assertEqual(c.sid, '123')
+        self.assertEqual(c.ping_interval, 1)
+        self.assertEqual(c.ping_timeout, 2)
+        self.assertEqual(c.upgrades, [])
+        self.assertEqual(c.transport(), 'websocket')
+        self.assertEqual(c.ws, create_connection.return_value)
+        self.assertEqual(len(create_connection.call_args_list), 1)
+        self.assertEqual(create_connection.call_args[1],
+                         {'header': {}, 'cookie': None,
+                          'sslopt': {'cert_reqs': ssl.CERT_NONE}})
+
     @mock.patch('engineio.client.websocket.create_connection')
     def test_websocket_connection_with_cookies(self, create_connection):
         create_connection.return_value.recv.return_value = packet.Packet(