Allow for other hosts than localhost to be proxied. (#128)

Allow for other hosts than `localhost` to be proxied.

Author: yuvipanda

jupyter_server_proxy/handlers.py

@@ -28,59 +28,49 @@ def get(self, *args):
         dest = src._replace(path=src.path + '/')
         self.redirect(urlunparse(dest))
 
-class LocalProxyHandler(WebSocketHandlerMixin, IPythonHandler):
-
+class ProxyHandler(WebSocketHandlerMixin, IPythonHandler):
+    """
+    A tornado request handler that proxies HTTP and websockets from
+    a given host/port combination. This class is not meant to be
+    used directly as a means of overriding CORS. This presents significant
+    security risks, and could allow arbitrary remote code access. Instead, it is
+    meant to be subclassed and used for proxying URLs from trusted sources.
+
+    Subclasses should implement open, http_get, post, put, delete, head, patch,
+    and options.
+    """
     def __init__(self, *args, **kwargs):
         self.proxy_base = ''
         self.absolute_url = kwargs.pop('absolute_url', False)
         super().__init__(*args, **kwargs)
 
-    async def open(self, port, proxied_path=''):
-        """
-        Called when a client opens a websocket connection.
+    # Support all the methods that torando does by default except for GET which
+    # is passed to WebSocketHandlerMixin and then to WebSocketHandler.
 
-        We establish a websocket connection to the proxied backend &
-        set up a callback to relay messages through.
-        """
-        if not proxied_path.startswith('/'):
-            proxied_path = '/' + proxied_path
+    async def open(self, port, proxied_path):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement open')
 
-        client_uri = self.get_client_uri('ws', port, proxied_path)
-        headers = self.request.headers
+    async def http_get(self, host, port, proxy_path=''):
+        '''Our non-websocket GET.'''
+        raise NotImplementedError('Subclasses of ProxyHandler should implement http_get')
 
-        def message_cb(message):
-            """
-            Callback when the backend sends messages to us
+    def post(self, host, port, proxy_path=''):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement this post')
 
-            We just pass it back to the frontend
-            """
-            # Websockets support both string (utf-8) and binary data, so let's
-            # make sure we signal that appropriately when proxying
-            self._record_activity()
-            if message is None:
-                self.close()
-            else:
-                self.write_message(message, binary=isinstance(message, bytes))
+    def put(self, port, proxy_path=''):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement this put')
 
-        def ping_cb(data):
-            """
-            Callback when the backend sends pings to us.
+    def delete(self, host, port, proxy_path=''):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement delete')
 
-            We just pass it back to the frontend.
-            """
-            self._record_activity()
-            self.ping(data)
+    def head(self, host, port, proxy_path=''):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement head')
 
-        async def start_websocket_connection():
-            self.log.info('Trying to establish websocket connection to {}'.format(client_uri))
-            self._record_activity()
-            request = httpclient.HTTPRequest(url=client_uri, headers=headers)
-            self.ws = await pingable_ws_connect(request=request,
-                on_message_callback=message_cb, on_ping_callback=ping_cb)
-            self._record_activity()
-            self.log.info('Websocket connection established to {}'.format(client_uri))
+    def patch(self, host, port, proxy_path=''):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement patch')
 
-        ioloop.IOLoop.current().add_callback(start_websocket_connection)
+    def options(self, host, port, proxy_path=''):
+        raise NotImplementedError('Subclasses of ProxyHandler should implement options')
 
     def on_message(self, message):
         """
@@ -141,7 +131,7 @@ def _get_context_path(self, port):
         else:
             return url_path_join(self.base_url, 'proxy', str(port))
 
-    def get_client_uri(self, protocol, port, proxied_path):
+    def get_client_uri(self, protocol, host, port, proxied_path):
         context_path = self._get_context_path(port)
         if self.absolute_url:
             client_path = url_path_join(context_path, proxied_path)
@@ -150,7 +140,7 @@ def get_client_uri(self, protocol, port, proxied_path):
 
         client_uri = '{protocol}://{host}:{port}{path}'.format(
             protocol=protocol,
-            host='localhost',
+            host=host,
             port=port,
             path=client_path
         )
@@ -159,11 +149,11 @@ def get_client_uri(self, protocol, port, proxied_path):
 
         return client_uri
 
-    def _build_proxy_request(self, port, proxied_path, body):
+    def _build_proxy_request(self, host, port, proxied_path, body):
 
         headers = self.proxy_request_headers()
 
-        client_uri = self.get_client_uri('http', port, proxied_path)
+        client_uri = self.get_client_uri('http', host, port, proxied_path)
         # Some applications check X-Forwarded-Context and X-ProxyContextPath
         # headers to see if and where they are being proxied from.
         if not self.absolute_url:
@@ -177,7 +167,7 @@ def _build_proxy_request(self, port, proxied_path, body):
         return req
 
     @web.authenticated
-    async def proxy(self, port, proxied_path):
+    async def proxy(self, host, port, proxied_path):
         '''
         This serverextension handles:
             {base_url}/proxy/{port([0-9]+)}/{proxied_path}
@@ -205,7 +195,7 @@ async def proxy(self, port, proxied_path):
 
         client = httpclient.AsyncHTTPClient()
 
-        req = self._build_proxy_request(port, proxied_path, body)
+        req = self._build_proxy_request(host, port, proxied_path, body)
         response = await client.fetch(req, raise_error=False)
         # record activity at start and end of requests
         self._record_activity()
@@ -229,40 +219,63 @@ async def proxy(self, port, proxied_path):
             if response.body:
                 self.write(response.body)
 
-    def proxy_request_headers(self):
-        '''A dictionary of headers to be used when constructing
-        a tornado.httpclient.HTTPRequest instance for the proxy request.'''
-        return self.request.headers.copy()
+    async def proxy_open(self, host, port, proxied_path=''):
+        """
+        Called when a client opens a websocket connection.
 
-    def proxy_request_options(self):
-        '''A dictionary of options to be used when constructing
-        a tornado.httpclient.HTTPRequest instance for the proxy request.'''
-        return dict(follow_redirects=False)
+        We establish a websocket connection to the proxied backend &
+        set up a callback to relay messages through.
+        """
+        if not proxied_path.startswith('/'):
+            proxied_path = '/' + proxied_path
 
-    # Support all the methods that torando does by default except for GET which
-    # is passed to WebSocketHandlerMixin and then to WebSocketHandler.
+        client_uri = self.get_client_uri('ws', host, port, proxied_path)
+        headers = self.request.headers
 
-    async def http_get(self, port, proxy_path=''):
-        '''Our non-websocket GET.'''
-        return await self.proxy(port, proxy_path)
+        def message_cb(message):
+            """
+            Callback when the backend sends messages to us
 
-    def post(self, port, proxy_path=''):
-        return self.proxy(port, proxy_path)
+            We just pass it back to the frontend
+            """
+            # Websockets support both string (utf-8) and binary data, so let's
+            # make sure we signal that appropriately when proxying
+            self._record_activity()
+            if message is None:
+                self.close()
+            else:
+                self.write_message(message, binary=isinstance(message, bytes))
 
-    def put(self, port, proxy_path=''):
-        return self.proxy(port, proxy_path)
+        def ping_cb(data):
+            """
+            Callback when the backend sends pings to us.
+
+            We just pass it back to the frontend.
+            """
+            self._record_activity()
+            self.ping(data)
+
+        async def start_websocket_connection():
+            self.log.info('Trying to establish websocket connection to {}'.format(client_uri))
+            self._record_activity()
+            request = httpclient.HTTPRequest(url=client_uri, headers=headers)
+            self.ws = await pingable_ws_connect(request=request,
+                on_message_callback=message_cb, on_ping_callback=ping_cb)
+            self._record_activity()
+            self.log.info('Websocket connection established to {}'.format(client_uri))
 
-    def delete(self, port, proxy_path=''):
-        return self.proxy(port, proxy_path)
+        ioloop.IOLoop.current().add_callback(start_websocket_connection)
 
-    def head(self, port, proxy_path=''):
-        return self.proxy(port, proxy_path)
 
-    def patch(self, port, proxy_path=''):
-        return self.proxy(port, proxy_path)
+    def proxy_request_headers(self):
+        '''A dictionary of headers to be used when constructing
+        a tornado.httpclient.HTTPRequest instance for the proxy request.'''
+        return self.request.headers.copy()
 
-    def options(self, port, proxy_path=''):
-        return self.proxy(port, proxy_path)
+    def proxy_request_options(self):
+        '''A dictionary of options to be used when constructing
+        a tornado.httpclient.HTTPRequest instance for the proxy request.'''
+        return dict(follow_redirects=False)
 
     def check_xsrf_cookie(self):
         '''
@@ -280,6 +293,40 @@ def select_subprotocol(self, subprotocols):
         return super().select_subprotocol(subprotocols)
 
 
+class LocalProxyHandler(ProxyHandler):
+    """
+    A tornado request handler that proxies HTTP and websockets
+    from a port on the local system. Same as the above ProxyHandler,
+    but specific to 'localhost'.
+    """
+    async def http_get(self, port, proxied_path):
+        return await self.proxy(port, proxied_path)
+
+    async def open(self, port, proxied_path):
+        return await self.proxy_open('localhost', port, proxied_path)
+
+    def post(self, port, proxied_path):
+        return self.proxy(port, proxied_path)
+
+    def put(self, port, proxied_path):
+        return self.proxy(port, proxied_path)
+
+    def delete(self, port, proxied_path):
+        return self.proxy(port, proxied_path)
+
+    def head(self, port, proxied_path):
+        return self.proxy(port, proxied_path)
+
+    def patch(self, port, proxied_path):
+        return self.proxy(port, proxied_path)
+
+    def options(self, port, proxied_path):
+        return self.proxy(port, proxied_path)
+
+    def proxy(self, port, proxied_path):
+        return super().proxy('localhost', port, proxied_path)
+
+
 # FIXME: Move this to its own file. Too many packages now import this from nbrserverproxy.handlers
 class SuperviseAndProxyHandler(LocalProxyHandler):
     '''Manage a given process and requests to it '''

tests/resources/jupyter_server_config.py

@@ -11,4 +11,8 @@
         'port': 54321,
     },
 }
+
+import sys
+sys.path.append('./tests/resources')
+c.NotebookApp.nbserver_extensions = { 'proxyextension': True }
 #c.Application.log_level = 'DEBUG'

tests/resources/proxyextension.py

@@ -0,0 +1,47 @@
+from jupyter_server_proxy.handlers import ProxyHandler
+from notebook.utils import url_path_join
+
+class NewHandler(ProxyHandler):
+    async def http_get(self):
+        return await self.proxy()
+
+    async def open(self):
+        host = '127.0.0.1'
+        port = 54321
+        return await super().proxy_open(host, port)
+
+    def post(self):
+        return self.proxy()
+
+    def put(self):
+        return self.proxy()
+
+    def delete(self):
+        return self.proxy()
+
+    def head(self):
+        return self.proxy()
+
+    def patch(self):
+        return self.proxy()
+
+    def options(self):
+        return self.proxy()
+
+    def proxy(self):
+        host = '127.0.0.1'
+        port = 54321
+        proxied_path = ''
+        return super().proxy(host, port, proxied_path)
+
+
+def _jupyter_server_extension_paths():
+    return [{"module": "dask_labextension"}]
+
+
+def load_jupyter_server_extension(nb_server_app):
+    web_app = nb_server_app.web_app
+    base_url = web_app.settings["base_url"]
+    proxy_path = url_path_join(base_url, "newproxy/" + "?")
+    handlers = [(proxy_path, NewHandler)]
+    web_app.add_handlers(".*$", handlers)

tests/test_proxies.py

@@ -5,8 +5,8 @@
 TOKEN = os.getenv('JUPYTER_TOKEN', 'secret')
 
 
-def request_get(port, path, token):
-    h = HTTPConnection('localhost', port, 10)
+def request_get(port, path, token, host='localhost'):
+    h = HTTPConnection(host, port, 10)
     h.request('GET', '{}?token={}'.format(path, token))
     return h.getresponse()
 
@@ -57,3 +57,7 @@ def test_server_proxy_port_absolute():
     assert s.startswith('GET /proxy/absolute/54321/nmo?token=')
     assert 'X-Forwarded-Context' not in s
     assert 'X-Proxycontextpath' not in s
+
+def test_server_proxy_remote():
+    r = request_get(PORT, '/newproxy', TOKEN, host='127.0.0.1')
+    assert r.code == 200