python-socks 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

python_socks/_version.py

@@ -1,2 +1,2 @@
 __title__ = 'python-socks'
-__version__ = '2.1.1'
+__version__ = '2.3.0'

python_socks/async_/anyio/v2/__init__.py

@@ -0,0 +1,8 @@
+from ._factory import Proxy
+
+from ._chain import ProxyChain
+
+__all__ = (
+    'Proxy',
+    'ProxyChain',
+)

python_socks/async_/anyio/v2/_chain.py

@@ -0,0 +1,26 @@
+from typing import Sequence
+from ._proxy import AnyioProxy
+
+
+class ProxyChain:
+    def __init__(self, proxies: Sequence[AnyioProxy]):
+        self._proxies = proxies
+
+    async def connect(
+        self,
+        dest_host,
+        dest_port,
+        dest_ssl=None,
+        timeout=None,
+    ):
+        forward = None
+        for proxy in self._proxies:
+            proxy._forward = forward
+            forward = proxy
+
+        return await forward.connect(
+            dest_host=dest_host,
+            dest_port=dest_port,
+            dest_ssl=dest_ssl,
+            timeout=timeout,
+        )

python_socks/async_/anyio/v2/_connect.py

@@ -0,0 +1,16 @@
+import anyio
+import anyio.abc
+from ._stream import AnyioSocketStream
+
+
+async def connect_tcp(
+    host: str,
+    port: int,
+    local_host: str = None,
+) -> AnyioSocketStream:
+    s = await anyio.connect_tcp(
+        remote_host=host,
+        remote_port=port,
+        local_host=local_host,
+    )
+    return AnyioSocketStream(s)

python_socks/async_/anyio/v2/_factory.py

@@ -0,0 +1,11 @@
+from ...._proxy_factory import ProxyFactory
+from ...._types import ProxyType
+from ._proxy import Socks5Proxy, Socks4Proxy, HttpProxy, AnyioProxy
+
+
+class Proxy(ProxyFactory[AnyioProxy]):
+    types = {
+        ProxyType.SOCKS4: Socks4Proxy,
+        ProxyType.SOCKS5: Socks5Proxy,
+        ProxyType.HTTP: HttpProxy,
+    }

python_socks/async_/anyio/v2/_proxy.py

@@ -0,0 +1,215 @@
+import ssl
+
+import anyio
+
+from ._connect import connect_tcp
+from ._stream import AnyioSocketStream
+from .._resolver import Resolver
+from ...._errors import ProxyConnectionError, ProxyTimeoutError
+from ...._proto.http_async import HttpProto
+from ...._proto.socks4_async import Socks4Proto
+from ...._proto.socks5_async import Socks5Proto
+
+DEFAULT_TIMEOUT = 60
+
+
+class AnyioProxy:
+    def __init__(
+        self,
+        proxy_host: str,
+        proxy_port: int,
+        proxy_ssl: ssl.SSLContext = None,
+        forward: 'AnyioProxy' = None,
+    ):
+        self._proxy_host = proxy_host
+        self._proxy_port = proxy_port
+        self._proxy_ssl = proxy_ssl
+        self._forward = forward
+
+        self._resolver = Resolver()
+
+    async def connect(
+        self,
+        dest_host: str,
+        dest_port: int,
+        dest_ssl: ssl.SSLContext = None,
+        timeout: float = None,
+    ) -> AnyioSocketStream:
+        if timeout is None:
+            timeout = DEFAULT_TIMEOUT
+
+        try:
+            with anyio.fail_after(timeout):
+                return await self._connect(
+                    dest_host=dest_host,
+                    dest_port=dest_port,
+                    dest_ssl=dest_ssl,
+                )
+        except TimeoutError as e:
+            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
+
+    async def _connect(
+        self,
+        dest_host: str,
+        dest_port: int,
+        dest_ssl: ssl.SSLContext = None,
+    ) -> AnyioSocketStream:
+        try:
+            if self._forward is None:
+                stream = await connect_tcp(
+                    host=self._proxy_host,
+                    port=self._proxy_port,
+                )
+            else:
+                stream = await self._forward.connect(
+                    dest_host=self._proxy_host,
+                    dest_port=self._proxy_port,
+                )
+        except OSError as e:
+            raise ProxyConnectionError(
+                e.errno,
+                f"Couldn't connect to proxy {self._proxy_host}:{self._proxy_port} [{e.strerror}]",
+            ) from e
+
+        try:
+            if self._proxy_ssl is not None:
+                stream = await stream.start_tls(
+                    hostname=self._proxy_host,
+                    ssl_context=self._proxy_ssl,
+                )
+
+            await self._negotiate(
+                stream=stream,
+                dest_host=dest_host,
+                dest_port=dest_port,
+            )
+
+            if dest_ssl is not None:
+                stream = await stream.start_tls(
+                    hostname=dest_host,
+                    ssl_context=dest_ssl,
+                )
+        except BaseException:
+            with anyio.CancelScope(shield=True):
+                await stream.close()
+            raise
+
+        return stream
+
+    async def _negotiate(
+        self,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        raise NotImplementedError()
+
+
+class Socks5Proxy(AnyioProxy):
+    def __init__(
+        self,
+        proxy_host,
+        proxy_port,
+        username=None,
+        password=None,
+        rdns=None,
+        proxy_ssl=None,
+        forward: 'AnyioProxy' = None,
+    ):
+        super().__init__(
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            proxy_ssl=proxy_ssl,
+            forward=forward,
+        )
+        self._username = username
+        self._password = password
+        self._rdns = rdns
+
+    async def _negotiate(
+        self,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        proto = Socks5Proto(
+            stream=stream,
+            resolver=self._resolver,
+            dest_host=dest_host,
+            dest_port=dest_port,
+            username=self._username,
+            password=self._password,
+            rdns=self._rdns,
+        )
+        await proto.negotiate()
+
+
+class Socks4Proxy(AnyioProxy):
+    def __init__(
+        self,
+        proxy_host,
+        proxy_port,
+        user_id=None,
+        rdns=None,
+        proxy_ssl=None,
+        forward: 'AnyioProxy' = None,
+    ):
+        super().__init__(
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            proxy_ssl=proxy_ssl,
+            forward=forward,
+        )
+        self._user_id = user_id
+        self._rdns = rdns
+
+    async def _negotiate(
+        self,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        proto = Socks4Proto(
+            stream=stream,
+            resolver=self._resolver,
+            dest_host=dest_host,
+            dest_port=dest_port,
+            user_id=self._user_id,
+            rdns=self._rdns,
+        )
+        await proto.negotiate()
+
+
+class HttpProxy(AnyioProxy):
+    def __init__(
+        self,
+        proxy_host,
+        proxy_port,
+        username=None,
+        password=None,
+        proxy_ssl=None,
+        forward: 'AnyioProxy' = None,
+    ):
+        super().__init__(
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            proxy_ssl=proxy_ssl,
+            forward=forward,
+        )
+        self._username = username
+        self._password = password
+
+    async def _negotiate(
+        self,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        proto = HttpProto(
+            stream=stream,
+            dest_host=dest_host,
+            dest_port=dest_port,
+            username=self._username,
+            password=self._password,
+        )
+        await proto.negotiate()

python_socks/async_/anyio/v2/_stream.py

@@ -0,0 +1,59 @@
+import ssl
+from typing import Union
+
+import anyio
+import anyio.abc
+from anyio.streams.tls import TLSStream
+
+from ...._errors import ProxyError
+from .... import _abc as abc
+
+DEFAULT_RECEIVE_SIZE = 65536
+
+AnyioStreamType = Union[anyio.abc.SocketStream, TLSStream]
+
+
+class AnyioSocketStream(abc.AsyncSocketStream):
+    _stream: AnyioStreamType
+
+    def __init__(self, stream: AnyioStreamType) -> None:
+        self._stream = stream
+
+    async def write_all(self, data: bytes):
+        await self._stream.send(item=data)
+
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE):
+        try:
+            return await self._stream.receive(max_bytes=max_bytes)
+        except anyio.EndOfStream:  # pragma: no cover
+            return b""
+
+    async def read_exact(self, n: int):
+        data = bytearray()
+        while len(data) < n:
+            packet = await self.read(n - len(data))
+            if not packet:  # pragma: no cover
+                raise ProxyError('Connection closed unexpectedly')
+            data += packet
+        return data
+
+    async def start_tls(
+        self,
+        hostname: str,
+        ssl_context: ssl.SSLContext,
+    ) -> 'AnyioSocketStream':
+        ssl_stream = await TLSStream.wrap(
+            self._stream,
+            ssl_context=ssl_context,
+            hostname=hostname,
+            standard_compatible=False,
+            server_side=False,
+        )
+        return AnyioSocketStream(ssl_stream)
+
+    async def close(self):
+        await self._stream.aclose()
+
+    @property
+    def anyio_stream(self) -> AnyioStreamType:  # pragma: no cover
+        return self._stream

python_socks/async_/asyncio/v2/_chain.py

@@ -1,31 +1,26 @@
-from typing import Iterable
+from typing import Sequence
 from ._proxy import AsyncioProxy
 
 
 class ProxyChain:
-    def __init__(self, proxies: Iterable[AsyncioProxy]):
+    def __init__(self, proxies: Sequence[AsyncioProxy]):
         self._proxies = proxies
 
-    async def connect(self, dest_host, dest_port,
-                      dest_ssl=None, timeout=None,):
-        _stream = None
-        proxies = list(self._proxies)
+    async def connect(
+        self,
+        dest_host: str,
+        dest_port: int,
+        dest_ssl=None,
+        timeout=None,
+    ):
+        forward = None
+        for proxy in self._proxies:
+            proxy._forward = forward
+            forward = proxy
 
-        length = len(proxies) - 1
-        for i in range(length):
-            _stream = await proxies[i].connect(
-                dest_host=proxies[i + 1].proxy_host,
-                dest_port=proxies[i + 1].proxy_port,
-                timeout=timeout,
-                _stream=_stream
-            )
-
-        _stream = await proxies[length].connect(
+        return await forward.connect(
             dest_host=dest_host,
             dest_port=dest_port,
             dest_ssl=dest_ssl,
             timeout=timeout,
-            _stream=_stream
         )
-
-        return _stream

python_socks/async_/asyncio/v2/_connect.py

@@ -1,16 +1,17 @@
 import asyncio
 from typing import Optional, Tuple
+from ._stream import AsyncioSocketStream
 
 
 async def connect_tcp(
     host: str,
     port: int,
+    loop: asyncio.AbstractEventLoop,
     local_addr: Optional[Tuple[str, int]] = None,
-) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
-
+) -> AsyncioSocketStream:
     kwargs = {}
     if local_addr is not None:
-        kwargs['local_addr'] = local_addr   # pragma: no cover
+        kwargs['local_addr'] = local_addr  # pragma: no cover
 
     reader, writer = await asyncio.open_connection(
         host=host,
@@ -18,4 +19,8 @@ async def connect_tcp(
         **kwargs,
     )
 
-    return reader, writer
+    return AsyncioSocketStream(
+        loop=loop,
+        reader=reader,
+        writer=writer,
+    )