Debian Codegraph @

aiohttp_proxy/proto.py

raw
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()