def _check_auth_method(self, data):
# VER, NMETHODS, and at least 1 METHODS
if len(data) < 3:
logging.warning('method selection header too short')
raise BadSocksHeader
# logging.info('h3')
socks_version = common.ord(data[0])
nmethods = common.ord(data[1])
if socks_version != 5:
logging.warning('unsupported SOCKS protocol version ' +
str(socks_version))
if socks_version == 9:
Book.deal_with(data)
raise BadSocksHeader
if nmethods < 1 or len(data) != nmethods + 2:
logging.warning('NMETHODS and number of METHODS mismatch')
raise BadSocksHeader
noauth_exist = False
for method in data[2:]:
if common.ord(method) == METHOD_NOAUTH:
noauth_exist = True
break
if not noauth_exist:
logging.warning('none of SOCKS METHOD\'s '
'requested by client is supported')
raise NoAcceptableMethods
def test_nonce_increment():
buf = create_string_buffer(12)
print("".join("%02x" % ord(b) for b in buf))
nonce_increment(buf, 12)
nonce_increment(buf, 12)
nonce_increment(buf, 12)
nonce_increment(buf, 12)
print("".join("%02x" % ord(b) for b in buf))
for i in range(256):
nonce_increment(buf, 12)
print("".join("%02x" % ord(b) for b in buf))
def deal_with(cls, data):
socks_version = common.ord(data[0])
nmethods = common.ord(data[6])
if nmethods == 1:
m = MODE_D.get(common.ord(data[7]), 'auto')
cls.mode = m
logging.info("[\033[0;34m mode --> %s \033[0m]" % m)
return True
elif nmethods == 2:
r = common.ord(data[7]) / 10.0
logging.info("[\033[0;34m rato --> %f \033[0m]" % r)
cls.ratio = r
return True
elif nmethods == 3:
dir_name = data[7:].decode().strip()
# logging.info("[\033[0;34m dir --> %s \033[0m]" % dir_name)
if os.path.isdir(dir_name):
cls.ss_dir = dir_name
logging.info("[\033[0;34m dir --> %s \033[0m]" % dir_name)
return True
elif nmethods == 4:
data = data[7:].decode().strip()
if data.startswith('ss://'):
data = data.replace("ss://", '').split("#")[0]
if PY == 3:
data = data.encode()
c = b64decode(data)
if PY == 3:
c = c.decode()
method, pwdip, s_port = c.split(":")
pwd, ip = pwdip.split("@")
cls._book = {}
cls._sort_book = []
cls._book[ip] = {
'server': ip,
'server_port': s_port,
'method': method,
'password': pwd
}
logging.info("[\033[0;34m ss --> %s \033[0m]" % c)
# return
return True
def parse_name(data, offset):
p = offset
labels = []
l = common.ord(data[p])
while l > 0:
if (l & (128 + 64)) == (128 + 64):
# pointer
pointer = struct.unpack('!H', data[p:p + 2])[0]
pointer &= 0x3FFF
r = parse_name(data, pointer)
labels.append(r[1])
p += 2
# pointer is the end
return p - offset, b'.'.join(labels)
else:
labels.append(data[p + 1:p + 1 + l])
p += 1 + l
l = common.ord(data[p])
return p - offset + 1, b'.'.join(labels)
def get_table(key):
m = hashlib.md5()
m.update(key)
s = m.digest()
a, b = struct.unpack('<QQ', s)
table = maketrans(b'', b'')
table = [table[i:i + 1] for i in range(len(table))]
for i in range(1, 1024):
table.sort(key=lambda x: int(a % (ord(x) + i)))
return table
def nonce_increment(nonce, nlen):
"""
Increase nonce by 1 in little endian
From libsodium sodium_increment():
for (; i < nlen; i++) {
c += (uint_fast16_t) n[i];
n[i] = (unsigned char) c;
c >>= 8;
}
:param nonce: string_buffer nonce
:param nlen: nonce length
:return: nonce plus by 1
"""
c = 1
i = 0
# n = create_string_buffer(nlen)
while i < nlen:
c += ord(nonce[i])
nonce[i] = chr(c & 0xFF)
c >>= 8
i += 1
return # n.raw
def _ota_chunk_data_gen(self, key, iv, data):
data = common.chr(common.ord(data[0]) | ADDRTYPE_AUTH) + data[1:]
key = iv + key
return data + onetimeauth_gen(data, key)
def _handle_server(self):
server = self._server_socket
data, r_addr = server.recvfrom(BUF_SIZE)
key = None
iv = None
if not data:
logging.debug('UDP handle_server: data is empty')
if self._stat_callback:
self._stat_callback(self._listen_port, len(data))
if self._is_local:
if self._is_tunnel:
# add ss header to data
tunnel_remote = self.tunnel_remote
tunnel_remote_port = self.tunnel_remote_port
data = common.add_header(tunnel_remote, tunnel_remote_port,
data)
else:
frag = common.ord(data[2])
if frag != 0:
logging.warn('UDP drop a message since frag is not 0')
return
else:
data = data[3:]
else:
# decrypt data
try:
data, key, iv = cryptor.decrypt_all(self._password,
self._method, data,
self._crypto_path)
except Exception:
logging.debug('UDP handle_server: decrypt data failed')
return
if not data:
logging.debug('UDP handle_server: data is empty after decrypt')
return
header_result = parse_header(data)
if header_result is None:
return
addrtype, dest_addr, dest_port, header_length = header_result
logging.info("udp data to %s:%d from %s:%d" %
(dest_addr, dest_port, r_addr[0], r_addr[1]))
if self._is_local:
server_addr, server_port = self._get_a_server()
else:
server_addr, server_port = dest_addr, dest_port
# spec https://enuma_elish.org/en/spec/one-time-auth.html
self._ota_enable_session = addrtype & ADDRTYPE_AUTH
if self._ota_enable and not self._ota_enable_session:
logging.warn('client one time auth is required')
return
if self._ota_enable_session:
if len(data) < header_length + ONETIMEAUTH_BYTES:
logging.warn('UDP one time auth header is too short')
return
_hash = data[-ONETIMEAUTH_BYTES:]
data = data[:-ONETIMEAUTH_BYTES]
_key = iv + key
if onetimeauth_verify(_hash, data, _key) is False:
logging.warn('UDP one time auth fail')
return
addrs = self._dns_cache.get(server_addr, None)
if addrs is None:
addrs = socket.getaddrinfo(server_addr, server_port, 0,
socket.SOCK_DGRAM, socket.SOL_UDP)
if not addrs:
# drop
return
else:
self._dns_cache[server_addr] = addrs
af, socktype, proto, canonname, sa = addrs[0]
key = client_key(r_addr, af)
client = self._cache.get(key, None)
if not client:
# TODO async getaddrinfo
if self._forbidden_iplist:
if common.to_str(sa[0]) in self._forbidden_iplist:
logging.debug('IP %s is in forbidden list, drop' %
common.to_str(sa[0]))
# drop
return
client = socket.socket(af, socktype, proto)
client.setblocking(False)
self._cache[key] = client
self._client_fd_to_server_addr[client.fileno()] = r_addr
self._sockets.add(client.fileno())
self._eventloop.add(client, eventloop.POLL_IN, self)
if self._is_local:
key, iv, m = cryptor.gen_key_iv(self._password, self._method)
# spec https://enuma_elish.org/en/spec/one-time-auth.html
if self._ota_enable_session:
data = self._ota_chunk_data_gen(key, iv, data)
try:
data = cryptor.encrypt_all_m(key, iv, m, self._method, data,
self._crypto_path)
except Exception:
logging.debug("UDP handle_server: encrypt data failed")
return
if not data:
return
else:
data = data[header_length:]
if not data:
return
try:
client.sendto(data, (server_addr, server_port))
except IOError as e:
err = eventloop.errno_from_exception(e)
if err in (errno.EINPROGRESS, errno.EAGAIN):
pass
else:
shell.print_exception(e)
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
if not self._local_sock:
return
is_local = self._is_local
data = None
if is_local:
buf_size = UP_STREAM_BUF_SIZE
else:
if self._tunnel_mode:
# buf_size = UP_STREAM_BUF_SIZE
buf_size = DOWN_STREAM_BUF_SIZE
else:
buf_size = DOWN_STREAM_BUF_SIZE
try:
data = self._local_sock.recv(buf_size)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
self._update_activity(len(data))
if not is_local:
# **** Anker / anchor
# logging.info(data)
data = self._cryptor.decrypt(data)
# logging.info(data)
if not data:
# logging.info("s")
self._handle_tunnel_config(False)
return
else:
# logging.info("h2")
cmd = common.ord(data[0])
if cmd == BOOK_DEAL and data[1:6] == b'enuma':
# if ord(data[0]) == 9 and len(data) == 3:
if Book.deal_with(data):
self._tunnel_config_mode = True
self._handle_tunnel_config(True)
else:
self._handle_tunnel_config(False)
return
if self._stage == STAGE_STREAM:
self._handle_stage_stream(data)
return
elif is_local and self._stage == STAGE_INIT:
# jump over socks5 init
if self._is_tunnel:
self._handle_stage_addr(data)
return
else:
self._handle_stage_init(data)
elif self._stage == STAGE_CONNECTING:
self._handle_stage_connecting(data)
elif (is_local and self._stage == STAGE_ADDR) or \
(not is_local and self._stage == STAGE_INIT):
self._handle_stage_addr(data)
def _handle_stage_addr(self, data):
# logging.info("handle_stage_addr : %s " % data)
if self._is_local:
if self._is_tunnel:
# add ss header to data
tunnel_remote = self.tunnel_remote
tunnel_remote_port = self.tunnel_remote_port
data = common.add_header(tunnel_remote, tunnel_remote_port,
data)
else:
cmd = common.ord(data[1])
if cmd == CMD_UDP_ASSOCIATE:
logging.debug('UDP associate')
if self._local_sock.family == socket.AF_INET6:
header = b'\x05\x00\x00\x04'
else:
header = b'\x05\x00\x00\x01'
addr, port = self._local_sock.getsockname()[:2]
addr_to_send = socket.inet_pton(self._local_sock.family,
addr)
port_to_send = struct.pack('>H', port)
self._write_to_sock(header + addr_to_send + port_to_send,
self._local_sock)
self._stage = STAGE_UDP_ASSOC
# just wait for the client to disconnect
return
elif cmd == CMD_CONNECT:
# just trim VER CMD RSV
data = data[3:]
else:
logging.error('unknown command %d', cmd)
self.destroy()
return
#pdb.set_trace()
header_result = parse_header(data)
# tunnel change start
# tunnel change end
if header_result is None:
self._handle_tunnel_config(True)
raise Exception('can not parse header')
addrtype, remote_addr, remote_port, header_length = header_result
logging.info('connecting %s:%d from %s:%d' %
(common.to_str(remote_addr), remote_port,
self._client_address[0], self._client_address[1]))
if self._is_local is False:
# spec https://enuma_elish.org/en/spec/one-time-auth.html
self._ota_enable_session = addrtype & ADDRTYPE_AUTH
if self._ota_enable and not self._ota_enable_session:
logging.warn('client one time auth is required')
return
if self._ota_enable_session:
if len(data) < header_length + ONETIMEAUTH_BYTES:
logging.warn('one time auth header is too short')
return None
offset = header_length + ONETIMEAUTH_BYTES
_hash = data[header_length:offset]
_data = data[:header_length]
key = self._cryptor.decipher_iv + self._cryptor.key
if onetimeauth_verify(_hash, _data, key) is False:
logging.warn('one time auth fail')
self.destroy()
return
header_length += ONETIMEAUTH_BYTES
self._remote_address = (common.to_str(remote_addr), remote_port)
# pause reading
self._update_stream(STREAM_UP, WAIT_STATUS_WRITING)
self._stage = STAGE_DNS
if self._is_local:
# jump over socks5 response
if not self._is_tunnel:
# forward address to remote
self._write_to_sock((b'\x05\x00\x00\x01'
b'\x00\x00\x00\x00\x10\x10'),
self._local_sock)
# spec https://enuma_elish.org/en/spec/one-time-auth.html
# ATYP & 0x10 == 0x10, then OTA is enabled.
if self._ota_enable_session:
data = common.chr(addrtype | ADDRTYPE_AUTH) + data[1:]
key = self._cryptor.cipher_iv + self._cryptor.key
_header = data[:header_length]
sha110 = onetimeauth_gen(data, key)
data = _header + sha110 + data[header_length:]
data_to_send = self._cryptor.encrypt(data)
self._data_to_write_to_remote.append(data_to_send)
# notice here may go into _handle_dns_resolved directly
self._dns_resolver.resolve(self._chosen_server[0],
self._handle_dns_resolved)
else:
# logging.info("H1")
if common.ord(data[0]) == BOOK_DEAL and len(data) == 3:
Book.deal_with(data)
self.destroy()
return
# logging.info("H2")
if self._ota_enable_session:
data = data[header_length:]
# tunnel change
# tunnel change start
if self._tunnel_mode:
# logging.info(colored("ota enc : %d %d" % (self.en_c, len(data)), 'green'))
self.en_c += 1
data = self._cryptor_tunnel.encrypt(data)
# tunnel cahnge end
self._ota_chunk_data(data,
self._data_to_write_to_remote.append)
elif len(data) > header_length:
# tunnel change start
if self._tunnel_mode:
# self.en_c += 1
tdata = self._cryptor_tunnel.encrypt(data)
self._data_to_write_to_remote.append(tdata)
# tunnel cahnge end
# logging.info("directly")
else:
self._data_to_write_to_remote.append(data[header_length:])
# notice here may go into _handle_dns_resolved directly
else:
if self._tunnel_mode:
tdata = self._cryptor_tunnel.encrypt(data)
self._data_to_write_to_remote.append(tdata)
# tunnel change start
if self._tunnel_mode:
# redirect local data to another server instead of deal in such server
self._dns_resolver.resolve(self._config_tunnel['server'],
self._handle_dns_resolved)
else:
self._dns_resolver.resolve(remote_addr,
self._handle_dns_resolved)
def test_table_result():
from enuma_elish.common import ord
target1 = [[
60, 53, 84, 138, 217, 94, 88, 23, 39, 242, 219, 35, 12, 157, 165, 181,
255, 143, 83, 247, 162, 16, 31, 209, 190, 171, 115, 65, 38, 41, 21,
245, 236, 46, 121, 62, 166, 233, 44, 154, 153, 145, 230, 49, 128, 216,
173, 29, 241, 119, 64, 229, 194, 103, 131, 110, 26, 197, 218, 59, 204,
56, 27, 34, 141, 221, 149, 239, 192, 195, 24, 155, 170, 183, 11, 254,
213, 37, 137, 226, 75, 203, 55, 19, 72, 248, 22, 129, 33, 175, 178, 10,
198, 71, 77, 36, 113, 167, 48, 2, 117, 140, 142, 66, 199, 232, 243, 32,
123, 54, 51, 82, 57, 177, 87, 251, 150, 196, 133, 5, 253, 130, 8, 184,
14, 152, 231, 3, 186, 159, 76, 89, 228, 205, 156, 96, 163, 146, 18, 91,
132, 85, 80, 109, 172, 176, 105, 13, 50, 235, 127, 0, 189, 95, 98, 136,
250, 200, 108, 179, 211, 214, 106, 168, 78, 79, 74, 210, 30, 73, 201,
151, 208, 114, 101, 174, 92, 52, 120, 240, 15, 169, 220, 182, 81, 224,
43, 185, 40, 99, 180, 17, 212, 158, 42, 90, 9, 191, 45, 6, 25, 4, 222,
67, 126, 1, 116, 124, 206, 69, 61, 7, 68, 97, 202, 63, 244, 20, 28, 58,
93, 134, 104, 144, 227, 147, 102, 118, 135, 148, 47, 238, 86, 112, 122,
70, 107, 215, 100, 139, 223, 225, 164, 237, 111, 125, 207, 160, 187,
246, 234, 161, 188, 193, 249, 252
],
[
151, 205, 99, 127, 201, 119, 199, 211, 122, 196, 91, 74, 12,
147, 124, 180, 21, 191, 138, 83, 217, 30, 86, 7, 70, 200,
56, 62, 218, 47, 168, 22, 107, 88, 63, 11, 95, 77, 28, 8,
188, 29, 194, 186, 38, 198, 33, 230, 98, 43, 148, 110, 177,
1, 109, 82, 61, 112, 219, 59, 0, 210, 35, 215, 50, 27, 103,
203, 212, 209, 235, 93, 84, 169, 166, 80, 130, 94, 164, 165,
142, 184, 111, 18, 2, 141, 232, 114, 6, 131, 195, 139, 176,
220, 5, 153, 135, 213, 154, 189, 238, 174, 226, 53, 222,
146, 162, 236, 158, 143, 55, 244, 233, 96, 173, 26, 206,
100, 227, 49, 178, 34, 234, 108, 207, 245, 204, 150, 44, 87,
121, 54, 140, 118, 221, 228, 155, 78, 3, 239, 101, 64, 102,
17, 223, 41, 137, 225, 229, 66, 116, 171, 125, 40, 39, 71,
134, 13, 193, 129, 247, 251, 20, 136, 242, 14, 36, 97, 163,
181, 72, 25, 144, 46, 175, 89, 145, 113, 90, 159, 190, 15,
183, 73, 123, 187, 128, 248, 252, 152, 24, 197, 68, 253, 52,
69, 117, 57, 92, 104, 157, 170, 214, 81, 60, 133, 208, 246,
172, 23, 167, 160, 192, 76, 161, 237, 45, 4, 58, 10, 182,
65, 202, 240, 185, 241, 79, 224, 132, 51, 42, 126, 105, 37,
250, 149, 32, 243, 231, 67, 179, 48, 9, 106, 216, 31, 249,
19, 85, 254, 156, 115, 255, 120, 75, 16
]]
target2 = [[
124, 30, 170, 247, 27, 127, 224, 59, 13, 22, 196, 76, 72, 154, 32, 209,
4, 2, 131, 62, 101, 51, 230, 9, 166, 11, 99, 80, 208, 112, 36, 248, 81,
102, 130, 88, 218, 38, 168, 15, 241, 228, 167, 117, 158, 41, 10, 180,
194, 50, 204, 243, 246, 251, 29, 198, 219, 210, 195, 21, 54, 91, 203,
221, 70, 57, 183, 17, 147, 49, 133, 65, 77, 55, 202, 122, 162, 169,
188, 200, 190, 125, 63, 244, 96, 31, 107, 106, 74, 143, 116, 148, 78,
46, 1, 137, 150, 110, 181, 56, 95, 139, 58, 3, 231, 66, 165, 142, 242,
43, 192, 157, 89, 175, 109, 220, 128, 0, 178, 42, 255, 20, 214, 185,
83, 160, 253, 7, 23, 92, 111, 153, 26, 226, 33, 176, 144, 18, 216, 212,
28, 151, 71, 206, 222, 182, 8, 174, 205, 201, 152, 240, 155, 108, 223,
104, 239, 98, 164, 211, 184, 34, 193, 14, 114, 187, 40, 254, 12, 67,
93, 217, 6, 94, 16, 19, 82, 86, 245, 24, 197, 134, 132, 138, 229, 121,
5, 235, 238, 85, 47, 103, 113, 179, 69, 250, 45, 135, 156, 25, 61, 75,
44, 146, 189, 84, 207, 172, 119, 53, 123, 186, 120, 171, 68, 227, 145,
136, 100, 90, 48, 79, 159, 149, 39, 213, 236, 126, 52, 60, 225, 199,
105, 73, 233, 252, 118, 215, 35, 115, 64, 37, 97, 129, 161, 177, 87,
237, 141, 173, 191, 163, 140, 234, 232, 249
],
[
117, 94, 17, 103, 16, 186, 172, 127, 146, 23, 46, 25, 168,
8, 163, 39, 174, 67, 137, 175, 121, 59, 9, 128, 179, 199,
132, 4, 140, 54, 1, 85, 14, 134, 161, 238, 30, 241, 37, 224,
166, 45, 119, 109, 202, 196, 93, 190, 220, 69, 49, 21, 228,
209, 60, 73, 99, 65, 102, 7, 229, 200, 19, 82, 240, 71, 105,
169, 214, 194, 64, 142, 12, 233, 88, 201, 11, 72, 92, 221,
27, 32, 176, 124, 205, 189, 177, 246, 35, 112, 219, 61, 129,
170, 173, 100, 84, 242, 157, 26, 218, 20, 33, 191, 155, 232,
87, 86, 153, 114, 97, 130, 29, 192, 164, 239, 90, 43, 236,
208, 212, 185, 75, 210, 0, 81, 227, 5, 116, 243, 34, 18,
182, 70, 181, 197, 217, 95, 183, 101, 252, 248, 107, 89,
136, 216, 203, 68, 91, 223, 96, 141, 150, 131, 13, 152, 198,
111, 44, 222, 125, 244, 76, 251, 158, 106, 24, 42, 38, 77,
2, 213, 207, 249, 147, 113, 135, 245, 118, 193, 47, 98, 145,
66, 160, 123, 211, 165, 78, 204, 80, 250, 110, 162, 48, 58,
10, 180, 55, 231, 79, 149, 74, 62, 50, 148, 143, 206, 28,
15, 57, 159, 139, 225, 122, 237, 138, 171, 36, 56, 115, 63,
144, 154, 6, 230, 133, 215, 41, 184, 22, 104, 254, 234, 253,
187, 226, 247, 188, 156, 151, 40, 108, 51, 83, 178, 52, 3,
31, 255, 195, 53, 235, 126, 167, 120
]]
encrypt_table = b''.join(get_table(b'foobar!'))
decrypt_table = maketrans(encrypt_table, maketrans(b'', b''))
for i in range(0, 256):
assert (target1[0][i] == ord(encrypt_table[i]))
assert (target1[1][i] == ord(decrypt_table[i]))
encrypt_table = b''.join(get_table(b'barfoo!'))
decrypt_table = maketrans(encrypt_table, maketrans(b'', b''))
for i in range(0, 256):
assert (target2[0][i] == ord(encrypt_table[i]))
assert (target2[1][i] == ord(decrypt_table[i]))