python-socks 2.8.1__tar.gz → 2.8.2__tar.gz

{python_socks-2.8.1/python_socks.egg-info → python_socks-2.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-socks
-Version: 2.8.1
+Version: 2.8.2
 Summary: Proxy (SOCKS4, SOCKS5, HTTP CONNECT) client for Python
 Author-email: Roman Snegirev <snegiryev@gmail.com>
 License: Apache-2.0

{python_socks-2.8.1 → python_socks-2.8.2}/python_socks/_protocols/http.py

@@ -6,6 +6,7 @@ from collections import namedtuple
 from typing import Optional
 
 from .._version import __title__, __version__
+from .._helpers import is_ipv6_address
 
 from .errors import ReplyError
 
@@ -94,8 +95,17 @@ class ConnectRequest:
 
     def dumps(self) -> bytes:
         buff = _Buffer()
-        buff.append_line(f'CONNECT {self.host}:{self.port} HTTP/1.1')
-        buff.append_line(f'Host: {self.host}:{self.port}')
+        # RFC 3986 § 3.2.2 / RFC 7230 § 5.4: a literal IPv6 address in an
+        # authority component must be enclosed in square brackets so the
+        # `:` between literal and port is unambiguous. Without brackets,
+        # `2001:db8::1:443` could be parsed as either the address
+        # `2001:db8::1` with port `443` or the address `2001:db8::1:443`
+        # with no port — proxies disagree, and several misroute the
+        # unbracketed form (typically returning `200 Connection
+        # established` against a connection that was never actually made).
+        host = f'[{self.host}]' if is_ipv6_address(self.host) else self.host
+        buff.append_line(f'CONNECT {host}:{self.port} HTTP/1.1')
+        buff.append_line(f'Host: {host}:{self.port}')
         buff.append_line(f'User-Agent: {DEFAULT_USER_AGENT}')
 
         if self.username and self.password:

{python_socks-2.8.1 → python_socks-2.8.2}/python_socks/_protocols/socks5.py

@@ -1,13 +1,13 @@
 import enum
+from functools import singledispatchmethod
 import ipaddress
 import socket
-from typing import Optional, Union
+from typing import Optional, Type, Union
 from dataclasses import dataclass, field
 
 from .errors import ReplyError
 from .._helpers import is_ip_address
 
-
 RSV = NULL = AUTH_GRANTED = 0x00
 SOCKS_VER = 0x05
 
@@ -302,34 +302,38 @@ ConnectionState = Union[
 
 
 class Connection:
-    _state: ConnectionState
-
     def __init__(self):
         self._state = StateServerWaitingForAuthMethods()
 
+    @singledispatchmethod
     def send(self, request: Request) -> bytes:
-        if type(request) is AuthMethodsRequest:
-            if type(self._state) is not StateServerWaitingForAuthMethods:
-                raise RuntimeError('Server is not currently waiting for auth methods')
-            self._state = StateClientSentAuthMethods(request)
-            return request.dumps()
-
-        if type(request) is AuthRequest:
-            if type(self._state) is not StateServerWaitingForAuth:
-                raise RuntimeError('Server is not currently waiting for authentication')
-            self._state = StateClientSentAuthRequest(request)
-            return request.dumps()
-
-        if type(request) is ConnectRequest:
-            if type(self._state) is not StateClientAuthenticated:
-                raise RuntimeError('Client is not authenticated')
-            self._state = StateClientSentConnectRequest(request)
-            return request.dumps()
-
-        raise RuntimeError(f'Invalid request type: {type(request)}')
+        raise RuntimeError(f'Invalid request type: {request.__class__}')
+
+    @send.register
+    def _send_auth_methods(self, request: AuthMethodsRequest) -> bytes:
+        if not self._state_is(StateServerWaitingForAuthMethods):
+            raise RuntimeError('Server is not currently waiting for auth methods')
+        self._state = StateClientSentAuthMethods(request)
+        return request.dumps()
+
+    @send.register
+    def _send_auth(self, request: AuthRequest) -> bytes:
+        if not self._state_is(StateServerWaitingForAuth):
+            raise RuntimeError('Server is not currently waiting for authentication')
+        self._state = StateClientSentAuthRequest(request)
+        return request.dumps()
+
+    @send.register
+    def _send_connect(self, request: ConnectRequest) -> bytes:
+        if not self._state_is(StateClientAuthenticated):
+            raise RuntimeError('Client is not authenticated')
+        self._state = StateClientSentConnectRequest(request)
+        return request.dumps()
 
     def receive(self, data: bytes) -> Reply:
-        if type(self._state) is StateClientSentAuthMethods:
+        reply: Reply
+
+        if self._state_is(StateClientSentAuthMethods):
             reply = AuthMethodReply.loads(data)
             reply.validate(self._state.data)
             if reply.method == AuthMethod.USERNAME_PASSWORD:
@@ -338,18 +342,21 @@ class Connection:
                 self._state = StateClientAuthenticated()
             return reply
 
-        if type(self._state) is StateClientSentAuthRequest:
+        if self._state_is(StateClientSentAuthRequest):
             reply = AuthReply.loads(data)
             self._state = StateClientAuthenticated(data=reply)
             return reply
 
-        if type(self._state) is StateClientSentConnectRequest:
+        if self._state_is(StateClientSentConnectRequest):
             reply = ConnectReply.loads(data)
             self._state = StateServerConnected(data=reply)
             return reply
 
         raise RuntimeError(f'Invalid connection state: {self._state}')
 
+    def _state_is(self, state_cls: Type[ConnectionState]):
+        return self.state.__class__ is state_cls
+
     @property
     def state(self):
         return self._state

{python_socks-2.8.1 → python_socks-2.8.2}/python_socks/_version.py

@@ -1,2 +1,2 @@
 __title__ = 'python-socks'
-__version__ = '2.8.1'
+__version__ = '2.8.2'

{python_socks-2.8.1 → python_socks-2.8.2/python_socks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-socks
-Version: 2.8.1
+Version: 2.8.2
 Summary: Proxy (SOCKS4, SOCKS5, HTTP CONNECT) client for Python
 Author-email: Roman Snegirev <snegiryev@gmail.com>
 License: Apache-2.0

python_socks-2.8.2/tests/test_misc.py

@@ -0,0 +1,50 @@
+# noinspection PyPackageRequirements
+import pytest
+
+from python_socks._helpers import is_ip_address  # noqa
+from python_socks._protocols.http import BasicAuth, ConnectRequest  # noqa
+
+
+@pytest.mark.parametrize('address', ('::1', b'::1', '127.0.0.1', b'127.0.0.1'))
+def test_is_ip_address(address):
+    assert is_ip_address(address)
+
+
+def test_basic_auth():
+    login = 'login'
+    password = 'password'
+
+    auth1 = BasicAuth(login=login, password=password)
+    auth2 = BasicAuth.decode(auth1.encode())
+
+    assert auth2.login == login
+    assert auth2.password == password
+
+
+def test_connect_request_brackets_ipv6_host():
+    """RFC 7230 § 5.4: literal IPv6 in host:port MUST be bracketed."""
+    req = ConnectRequest(
+        host='2001:db8::1', port=443, username=None, password=None,
+    )
+    raw = req.dumps()
+    first_line = raw.split(b'\r\n', 1)[0]
+    assert first_line == b'CONNECT [2001:db8::1]:443 HTTP/1.1'
+    assert b'Host: [2001:db8::1]:443\r\n' in raw
+
+
+def test_connect_request_does_not_bracket_ipv4_host():
+    req = ConnectRequest(
+        host='192.0.2.1', port=443, username=None, password=None,
+    )
+    raw = req.dumps()
+    assert raw.split(b'\r\n', 1)[0] == b'CONNECT 192.0.2.1:443 HTTP/1.1'
+    assert b'Host: 192.0.2.1:443\r\n' in raw
+
+
+def test_connect_request_does_not_bracket_hostname():
+    req = ConnectRequest(
+        host='example.com', port=443, username=None, password=None,
+    )
+    raw = req.dumps()
+    assert raw.split(b'\r\n', 1)[0] == b'CONNECT example.com:443 HTTP/1.1'
+    assert b'Host: example.com:443\r\n' in raw

python_socks-2.8.1/tests/test_misc.py

@@ -1,21 +0,0 @@
-# noinspection PyPackageRequirements
-import pytest
-
-from python_socks._helpers import is_ip_address  # noqa
-from python_socks._protocols.http import BasicAuth  # noqa
-
-
-@pytest.mark.parametrize('address', ('::1', b'::1', '127.0.0.1', b'127.0.0.1'))
-def test_is_ip_address(address):
-    assert is_ip_address(address)
-
-
-def test_basic_auth():
-    login = 'login'
-    password = 'password'
-
-    auth1 = BasicAuth(login=login, password=password)
-    auth2 = BasicAuth.decode(auth1.encode())
-
-    assert auth2.login == login
-    assert auth2.password == password