| 1 |
# -*- coding: utf-8 -*- |
| 2 |
import asyncio |
| 3 |
import socket |
| 4 |
import struct |
| 5 |
from enum import Enum |
| 6 |
|
| 7 |
from .errors import ( |
| 8 |
SocksConnectionError, InvalidServerReply, SocksError, |
| 9 |
InvalidServerVersion, NoAcceptableAuthMethods, |
| 10 |
LoginAuthenticationFailed, UnknownAuthMethod |
| 11 |
) |
| 12 |
|
| 13 |
RSV = NULL = 0x00 |
| 14 |
SOCKS_VER4 = 0x04 |
| 15 |
SOCKS_VER5 = 0x05 |
| 16 |
|
| 17 |
SOCKS_CMD_CONNECT = 0x01 |
| 18 |
SOCKS_CMD_BIND = 0x02 |
| 19 |
SOCKS_CMD_UDP_ASSOCIATE = 0x03 |
| 20 |
|
| 21 |
SOCKS4_GRANTED = 0x5A |
| 22 |
SOCKS5_GRANTED = 0x00 |
| 23 |
|
| 24 |
SOCKS5_AUTH_ANONYMOUS = 0x00 |
| 25 |
SOCKS5_AUTH_UNAME_PWD = 0x02 |
| 26 |
SOCKS5_AUTH_NO_ACCEPTABLE_METHODS = 0xFF |
| 27 |
|
| 28 |
SOCKS5_ATYP_IPv4 = 0x01 |
| 29 |
SOCKS5_ATYP_DOMAIN = 0x03 |
| 30 |
SOCKS5_ATYP_IPv6 = 0x04 |
| 31 |
|
| 32 |
SOCKS4_ERRORS = { |
| 33 |
0x5B: 'Request rejected or failed', |
| 34 |
0x5C: 'Request rejected because SOCKS server ' |
| 35 |
'cannot connect to identd on the client', |
| 36 |
0x5D: 'Request rejected because the client program ' |
| 37 |
'and identd report different user-ids' |
| 38 |
} |
| 39 |
|
| 40 |
SOCKS5_ERRORS = { |
| 41 |
0x01: 'General SOCKS server failure', |
| 42 |
0x02: 'Connection not allowed by ruleset', |
| 43 |
0x03: 'Network unreachable', |
| 44 |
0x04: 'Host unreachable', |
| 45 |
0x05: 'Connection refused', |
| 46 |
0x06: 'TTL expired', |
| 47 |
0x07: 'Command not supported, or protocol error', |
| 48 |
0x08: 'Address type not supported' |
| 49 |
} |
| 50 |
|
| 51 |
|
| 52 |
def _is_proactor(loop): # pragma: no cover |
| 53 |
try: |
| 54 |
from asyncio import ProactorEventLoop |
| 55 |
except ImportError: |
| 56 |
return False |
| 57 |
return isinstance(loop, ProactorEventLoop) |
| 58 |
|
| 59 |
|
| 60 |
def _is_uvloop(loop): # pragma: no cover |
| 61 |
try: |
| 62 |
# noinspection PyPackageRequirements |
| 63 |
from uvloop import Loop |
| 64 |
except ImportError: |
| 65 |
return False |
| 66 |
return isinstance(loop, Loop) |
| 67 |
|
| 68 |
|
| 69 |
class ProxyType(Enum): |
| 70 |
SOCKS4 = 'socks4' |
| 71 |
SOCKS5 = 'socks5' |
| 72 |
HTTP = 'http' |
| 73 |
HTTPS = 'https' |
| 74 |
|
| 75 |
def is_http(self): |
| 76 |
return self.value in ['http', 'https'] |
| 77 |
|
| 78 |
def __str__(self): |
| 79 |
return self.name.lower() |
| 80 |
|
| 81 |
|
| 82 |
class BaseSocketWrapper(object): |
| 83 |
def __init__(self, loop, host, port, |
| 84 |
family=socket.AF_INET): |
| 85 |
self._loop = loop |
| 86 |
self._socks_host = host |
| 87 |
self._socks_port = port |
| 88 |
self._dest_host = None |
| 89 |
self._dest_port = None |
| 90 |
self._family = family |
| 91 |
self._socket = None |
| 92 |
|
| 93 |
async def _send(self, request): |
| 94 |
data = bytearray() |
| 95 |
for item in request: |
| 96 |
if isinstance(item, int): |
| 97 |
data.append(item) |
| 98 |
elif isinstance(item, (bytearray, bytes)): |
| 99 |
data += item |
| 100 |
else: |
| 101 |
raise ValueError('Unsupported item') |
| 102 |
await self._loop.sock_sendall(self._socket, data) |
| 103 |
|
| 104 |
async def _receive(self, n): |
| 105 |
data = b'' |
| 106 |
while len(data) < n: |
| 107 |
packet = await self._loop.sock_recv(self._socket, n - len(data)) |
| 108 |
if not packet: |
| 109 |
raise InvalidServerReply('Not all data available') |
| 110 |
data += packet |
| 111 |
return bytearray(data) |
| 112 |
|
| 113 |
async def _resolve_addr(self, host, port): |
| 114 |
addresses = await self._loop.getaddrinfo( |
| 115 |
host=host, port=port, family=socket.AF_UNSPEC, |
| 116 |
type=socket.SOCK_STREAM, proto=socket.IPPROTO_TCP, |
| 117 |
flags=socket.AI_ADDRCONFIG) |
| 118 |
if not addresses: |
| 119 |
raise OSError('Can`t resolve address %s:%s' % (host, port)) |
| 120 |
family = addresses[0][0] |
| 121 |
addr = addresses[0][4][0] |
| 122 |
return family, addr |
| 123 |
|
| 124 |
async def negotiate(self): |
| 125 |
raise NotImplementedError |
| 126 |
|
| 127 |
async def connect(self, address): |
| 128 |
self._dest_host = address[0] |
| 129 |
self._dest_port = address[1] |
| 130 |
|
| 131 |
self._socket = socket.socket( |
| 132 |
family=self._family, |
| 133 |
type=socket.SOCK_STREAM |
| 134 |
) |
| 135 |
self._socket.setblocking(False) |
| 136 |
|
| 137 |
try: |
| 138 |
await self._loop.sock_connect( |
| 139 |
sock=self._socket, |
| 140 |
address=(self._socks_host, self._socks_port) |
| 141 |
) |
| 142 |
except OSError as e: |
| 143 |
self.close() |
| 144 |
raise SocksConnectionError( |
| 145 |
e.errno, |
| 146 |
'Can not connect to proxy %s:%d [%s]' % |
| 147 |
(self._socks_host, self._socks_port, e.strerror)) from e |
| 148 |
except asyncio.CancelledError: # pragma: no cover |
| 149 |
self.close() |
| 150 |
raise |
| 151 |
|
| 152 |
try: |
| 153 |
await self.negotiate() |
| 154 |
except SocksError: |
| 155 |
self.close() |
| 156 |
raise |
| 157 |
except asyncio.CancelledError: # pragma: no cover |
| 158 |
if _is_proactor(self._loop) or _is_uvloop(self._loop): |
| 159 |
self.close() |
| 160 |
raise |
| 161 |
|
| 162 |
def close(self): |
| 163 |
self._socket.close() |
| 164 |
|
| 165 |
async def sendall(self, data): |
| 166 |
await self._loop.sock_sendall(self._socket, data) |
| 167 |
|
| 168 |
async def recv(self, nbytes): |
| 169 |
return await self._loop.sock_recv(self._socket, nbytes) |
| 170 |
|
| 171 |
@property |
| 172 |
def socket(self): |
| 173 |
return self._socket |
| 174 |
|
| 175 |
|
| 176 |
class Socks4SocketWrapper(BaseSocketWrapper): |
| 177 |
def __init__(self, loop, host, port, |
| 178 |
user_id=None, rdns=False): |
| 179 |
super().__init__( |
| 180 |
loop=loop, |
| 181 |
host=host, |
| 182 |
port=port, |
| 183 |
family=socket.AF_INET |
| 184 |
) |
| 185 |
self._user_id = user_id |
| 186 |
self._rdns = rdns |
| 187 |
|
| 188 |
async def _socks_connect(self): |
| 189 |
host, port = self._dest_host, self._dest_port |
| 190 |
port_bytes = struct.pack(b'>H', port) |
| 191 |
|
| 192 |
include_hostname = False |
| 193 |
try: |
| 194 |
# destination address provided is an IP address |
| 195 |
host_bytes = socket.inet_aton(host) |
| 196 |
except socket.error: |
| 197 |
# not IP address, probably a DNS name |
| 198 |
if self._rdns: |
| 199 |
# remote resolve (SOCKS4a) |
| 200 |
host_bytes = bytes([NULL, NULL, NULL, 0x01]) |
| 201 |
include_hostname = True |
| 202 |
else: |
| 203 |
# resolve locally |
| 204 |
family, host = await self._resolve_addr(host, port) |
| 205 |
host_bytes = socket.inet_aton(host) |
| 206 |
|
| 207 |
# build and send connect command |
| 208 |
req = [SOCKS_VER4, SOCKS_CMD_CONNECT, port_bytes, host_bytes] |
| 209 |
|
| 210 |
if self._user_id: |
| 211 |
req.append(self._user_id.encode()) |
| 212 |
|
| 213 |
req.append(NULL) |
| 214 |
|
| 215 |
if include_hostname: |
| 216 |
req += [host.encode('idna'), NULL] |
| 217 |
|
| 218 |
await self._send(req) |
| 219 |
|
| 220 |
res = await self._receive(8) |
| 221 |
|
| 222 |
if res[0] != NULL: |
| 223 |
raise InvalidServerReply('SOCKS4 proxy server sent invalid data') |
| 224 |
if res[1] != SOCKS4_GRANTED: |
| 225 |
error = SOCKS4_ERRORS.get(res[1], 'Unknown error') |
| 226 |
raise SocksError('[Errno {0:#04x}]: {1}'.format(res[1], error)) |
| 227 |
|
| 228 |
binded_addr = ( |
| 229 |
socket.inet_ntoa(res[4:]), |
| 230 |
struct.unpack('>H', res[2:4])[0] |
| 231 |
) |
| 232 |
return (host, port), binded_addr |
| 233 |
|
| 234 |
async def negotiate(self): |
| 235 |
await self._socks_connect() |
| 236 |
|
| 237 |
|
| 238 |
class Socks5SocketWrapper(BaseSocketWrapper): |
| 239 |
def __init__(self, loop, host, port, username=None, |
| 240 |
password=None, rdns=True, family=socket.AF_INET): |
| 241 |
super().__init__( |
| 242 |
loop=loop, |
| 243 |
host=host, |
| 244 |
port=port, |
| 245 |
family=family |
| 246 |
) |
| 247 |
self._username = username |
| 248 |
self._password = password |
| 249 |
self._rdns = rdns |
| 250 |
|
| 251 |
async def _socks_auth(self): |
| 252 |
# send auth methods |
| 253 |
if self._username and self._password: |
| 254 |
auth_methods = [SOCKS5_AUTH_UNAME_PWD, SOCKS5_AUTH_ANONYMOUS] |
| 255 |
else: |
| 256 |
auth_methods = [SOCKS5_AUTH_ANONYMOUS] |
| 257 |
|
| 258 |
req = [SOCKS_VER5, len(auth_methods)] + auth_methods |
| 259 |
|
| 260 |
await self._send(req) |
| 261 |
res = await self._receive(2) |
| 262 |
ver, auth_method = res[0], res[1] |
| 263 |
|
| 264 |
if ver != SOCKS_VER5: |
| 265 |
raise InvalidServerVersion( |
| 266 |
'Unexpected SOCKS version number: %s' % ver |
| 267 |
) |
| 268 |
|
| 269 |
if auth_method == SOCKS5_AUTH_NO_ACCEPTABLE_METHODS: |
| 270 |
raise NoAcceptableAuthMethods( |
| 271 |
'No acceptable authentication methods were offered' |
| 272 |
) |
| 273 |
|
| 274 |
if auth_method not in auth_methods: |
| 275 |
raise UnknownAuthMethod( |
| 276 |
'Unexpected SOCKS authentication method: %s' % auth_method |
| 277 |
) |
| 278 |
|
| 279 |
# authenticate |
| 280 |
if auth_method == SOCKS5_AUTH_UNAME_PWD: |
| 281 |
req = [0x01, |
| 282 |
chr(len(self._username)).encode(), |
| 283 |
self._username.encode(), |
| 284 |
chr(len(self._password)).encode(), |
| 285 |
self._password.encode()] |
| 286 |
|
| 287 |
await self._send(req) |
| 288 |
res = await self._receive(2) |
| 289 |
ver, status = res[0], res[1] |
| 290 |
if ver != 0x01: |
| 291 |
raise InvalidServerReply('Invalid authentication response') |
| 292 |
if status != SOCKS5_GRANTED: |
| 293 |
raise LoginAuthenticationFailed( |
| 294 |
'Username and password authentication failure' |
| 295 |
) |
| 296 |
|
| 297 |
async def _socks_connect(self): |
| 298 |
req_addr, resolved_addr = await self._build_dest_address() |
| 299 |
req = [SOCKS_VER5, SOCKS_CMD_CONNECT, RSV] + req_addr |
| 300 |
|
| 301 |
await self._send(req) |
| 302 |
res = await self._receive(3) |
| 303 |
ver, err_code, reserved = res[0], res[1], res[2] |
| 304 |
if ver != SOCKS_VER5: |
| 305 |
raise InvalidServerVersion( |
| 306 |
'Unexpected SOCKS version number: %s' % ver |
| 307 |
) |
| 308 |
if err_code != 0x00: |
| 309 |
raise SocksError(SOCKS5_ERRORS.get(err_code, 'Unknown error')) |
| 310 |
if reserved != 0x00: |
| 311 |
raise InvalidServerReply('The reserved byte must be 0x00') |
| 312 |
|
| 313 |
binded_addr = await self._read_binded_address() |
| 314 |
return resolved_addr, binded_addr |
| 315 |
|
| 316 |
async def _build_dest_address(self): |
| 317 |
host = self._dest_host |
| 318 |
port = self._dest_port |
| 319 |
|
| 320 |
family_to_byte = {socket.AF_INET: SOCKS5_ATYP_IPv4, |
| 321 |
socket.AF_INET6: SOCKS5_ATYP_IPv6} |
| 322 |
port_bytes = struct.pack('>H', port) |
| 323 |
|
| 324 |
# destination address provided is an IPv4 or IPv6 address |
| 325 |
for family in (socket.AF_INET, socket.AF_INET6): |
| 326 |
try: |
| 327 |
host_bytes = socket.inet_pton(family, host) |
| 328 |
req = [family_to_byte[family], host_bytes, port_bytes] |
| 329 |
return req, (host, port) |
| 330 |
except socket.error: |
| 331 |
pass |
| 332 |
|
| 333 |
# not IP address, probably a DNS name |
| 334 |
if self._rdns: |
| 335 |
# resolve remotely |
| 336 |
host_bytes = host.encode('idna') |
| 337 |
req = [SOCKS5_ATYP_DOMAIN, chr(len(host_bytes)).encode(), |
| 338 |
host_bytes, port_bytes] |
| 339 |
else: |
| 340 |
# resolve locally |
| 341 |
family, addr = await self._resolve_addr(host=host, port=port) |
| 342 |
host_bytes = socket.inet_pton(family, addr) |
| 343 |
req = [family_to_byte[family], host_bytes, port_bytes] |
| 344 |
host = socket.inet_ntop(family, host_bytes) |
| 345 |
|
| 346 |
return req, (host, port) |
| 347 |
|
| 348 |
async def _read_binded_address(self): |
| 349 |
atype = (await self._receive(1))[0] |
| 350 |
if atype == SOCKS5_ATYP_IPv4: |
| 351 |
addr = await self._receive(4) |
| 352 |
addr = socket.inet_ntoa(addr) |
| 353 |
elif atype == SOCKS5_ATYP_DOMAIN: |
| 354 |
length = await self._receive(1) |
| 355 |
addr = await self._receive(ord(length)) |
| 356 |
elif atype == SOCKS5_ATYP_IPv6: |
| 357 |
addr = await self._receive(16) |
| 358 |
addr = socket.inet_ntop(socket.AF_INET6, addr) |
| 359 |
else: |
| 360 |
raise InvalidServerReply('SOCKS5 proxy server sent invalid data') |
| 361 |
|
| 362 |
port = await self._receive(2) |
| 363 |
port = struct.unpack('>H', port)[0] |
| 364 |
|
| 365 |
return addr, port |
| 366 |
|
| 367 |
async def negotiate(self): |
| 368 |
await self._socks_auth() |
| 369 |
await self._socks_connect() |