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