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

{python_socks-2.8.0/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.0
+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.0 → python_socks-2.8.2}/python_socks/_connectors/socks5_async.py

@@ -72,7 +72,7 @@ class Socks5AsyncConnector(AsyncConnector):
 
     # noinspection PyMethodMayBeStatic
     async def _read_reply(self, stream: AsyncSocketStream) -> bytes:
-        data = await stream.read_exact(4)
+        data = await stream.read_exact(3)
         if data[0] != socks5.SOCKS_VER:
             return data
         if data[1] != socks5.ReplyCode.SUCCEEDED:
@@ -80,6 +80,7 @@ class Socks5AsyncConnector(AsyncConnector):
         if data[2] != socks5.RSV:
             return data
 
+        data += await stream.read_exact(1)
         addr_type = data[3]
 
         if addr_type == socks5.AddressType.IPV4:

{python_socks-2.8.0 → python_socks-2.8.2}/python_socks/_connectors/socks5_sync.py

@@ -63,7 +63,7 @@ class Socks5SyncConnector(SyncConnector):
 
     # noinspection PyMethodMayBeStatic
     def _read_reply(self, stream: SyncSocketStream) -> bytes:
-        data = stream.read_exact(4)
+        data = stream.read_exact(3)
         if data[0] != socks5.SOCKS_VER:
             return data
         if data[1] != socks5.ReplyCode.SUCCEEDED:
@@ -71,6 +71,7 @@ class Socks5SyncConnector(SyncConnector):
         if data[2] != socks5.RSV:
             return data
 
+        data += stream.read_exact(1)
         addr_type = data[3]
 
         if addr_type == socks5.AddressType.IPV4:

{python_socks-2.8.0 → 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.0 → 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.0 → python_socks-2.8.2}/python_socks/_version.py

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

{python_socks-2.8.0 → 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.0
+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/python_socks.egg-info/SOURCES.txt

@@ -0,0 +1,100 @@
+LICENSE.txt
+MANIFEST.in
+README.md
+pyproject.toml
+python_socks/__init__.py
+python_socks/_abc.py
+python_socks/_errors.py
+python_socks/_helpers.py
+python_socks/_types.py
+python_socks/_version.py
+python_socks/py.typed
+python_socks.egg-info/PKG-INFO
+python_socks.egg-info/SOURCES.txt
+python_socks.egg-info/dependency_links.txt
+python_socks.egg-info/requires.txt
+python_socks.egg-info/top_level.txt
+python_socks/_connectors/__init__.py
+python_socks/_connectors/abc.py
+python_socks/_connectors/factory_async.py
+python_socks/_connectors/factory_sync.py
+python_socks/_connectors/http_async.py
+python_socks/_connectors/http_sync.py
+python_socks/_connectors/socks4_async.py
+python_socks/_connectors/socks4_sync.py
+python_socks/_connectors/socks5_async.py
+python_socks/_connectors/socks5_sync.py
+python_socks/_protocols/__init__.py
+python_socks/_protocols/errors.py
+python_socks/_protocols/http.py
+python_socks/_protocols/socks4.py
+python_socks/_protocols/socks5.py
+python_socks/async_/__init__.py
+python_socks/async_/_proxy_chain.py
+python_socks/async_/anyio/__init__.py
+python_socks/async_/anyio/_chain.py
+python_socks/async_/anyio/_connect.py
+python_socks/async_/anyio/_proxy.py
+python_socks/async_/anyio/_resolver.py
+python_socks/async_/anyio/_stream.py
+python_socks/async_/anyio/v2/__init__.py
+python_socks/async_/anyio/v2/_chain.py
+python_socks/async_/anyio/v2/_connect.py
+python_socks/async_/anyio/v2/_proxy.py
+python_socks/async_/anyio/v2/_stream.py
+python_socks/async_/asyncio/__init__.py
+python_socks/async_/asyncio/_connect.py
+python_socks/async_/asyncio/_proxy.py
+python_socks/async_/asyncio/_resolver.py
+python_socks/async_/asyncio/_stream.py
+python_socks/async_/asyncio/v2/__init__.py
+python_socks/async_/asyncio/v2/_chain.py
+python_socks/async_/asyncio/v2/_connect.py
+python_socks/async_/asyncio/v2/_proxy.py
+python_socks/async_/asyncio/v2/_stream.py
+python_socks/async_/curio/__init__.py
+python_socks/async_/curio/_connect.py
+python_socks/async_/curio/_proxy.py
+python_socks/async_/curio/_resolver.py
+python_socks/async_/curio/_stream.py
+python_socks/async_/trio/__init__.py
+python_socks/async_/trio/_connect.py
+python_socks/async_/trio/_proxy.py
+python_socks/async_/trio/_resolver.py
+python_socks/async_/trio/_stream.py
+python_socks/async_/trio/v2/__init__.py
+python_socks/async_/trio/v2/_chain.py
+python_socks/async_/trio/v2/_connect.py
+python_socks/async_/trio/v2/_proxy.py
+python_socks/async_/trio/v2/_stream.py
+python_socks/sync/__init__.py
+python_socks/sync/_chain.py
+python_socks/sync/_connect.py
+python_socks/sync/_proxy.py
+python_socks/sync/_resolver.py
+python_socks/sync/_stream.py
+python_socks/sync/v2/__init__.py
+python_socks/sync/v2/_chain.py
+python_socks/sync/v2/_connect.py
+python_socks/sync/v2/_proxy.py
+python_socks/sync/v2/_ssl_transport.py
+python_socks/sync/v2/_stream.py
+tests/__init__.py
+tests/config.py
+tests/conftest.py
+tests/http_app.py
+tests/http_server.py
+tests/mocks.py
+tests/proxy_server.py
+tests/test_misc.py
+tests/test_proxy_async_aio.py
+tests/test_proxy_async_aio_v2.py
+tests/test_proxy_async_anyio.py
+tests/test_proxy_async_anyio_v2.py
+tests/test_proxy_async_curio.py
+tests/test_proxy_async_trio.py
+tests/test_proxy_async_trio_v2.py
+tests/test_proxy_sync.py
+tests/test_proxy_sync_v2.py
+tests/test_resolvers.py
+tests/utils.py

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