dnomd343
/
shadowsocksr
mirror of https://github.com/dnomd343/shadowsocksr
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

fix on python3 

http2 obfs
dev
breakwa11 10 years ago
parent
2e3114f40f
commit
71338a7385
5 changed files with 133 additions and 51 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      shadowsocks/manager.py
  2. 127
      shadowsocks/obfsplugin/http_simple.py
  3. 1
      shadowsocks/shell.py
  4. 16
      shadowsocks/tcprelay.py
  5. 38
      shadowsocks/udprelay.py

2
shadowsocks/manager.py
View File

@ -44,7 +44,7 @@ class Manager(object):
self._statistics = collections.defaultdict(int) self._statistics = collections.defaultdict(int)
self._control_client_addr = None self._control_client_addr = None
try: try:
manager_address = config['manager_address'] manager_address = common.to_str(config['manager_address'])
if ':' in manager_address: if ':' in manager_address:
addr = manager_address.rsplit(':', 1) addr = manager_address.rsplit(':', 1)
addr = addr[0], int(addr[1]) addr = addr[0], int(addr[1])

127
shadowsocks/obfsplugin/http_simple.py
View File

@ -22,23 +22,35 @@ import sys
import hashlib import hashlib
import logging import logging
import binascii import binascii
import base64
import datetime import datetime
from shadowsocks.common import to_bytes, to_str
def create_obfs(method): def create_http_obfs(method):
return http_simple(method) return http_simple(method)
def create_http2_obfs(method):
return http2_simple(method)
obfs = { obfs = {
'http_simple': (create_obfs,), 'http_simple': (create_http_obfs,),
'http2_simple': (create_http2_obfs,),
} }
def match_begin(str1, str2):
if len(str1) >= len(str2):
if str1[:len(str2)] == str2:
return True
return False
class http_simple(object): class http_simple(object):
def __init__(self, method): def __init__(self, method):
self.method = method self.method = method
self.has_sent_header = False self.has_sent_header = False
self.has_recv_header = False self.has_recv_header = False
self.host = "" self.host = None
self.port = 0 self.port = 0
self.recv_buffer = "" self.recv_buffer = b''
def client_encode(self, buf): def client_encode(self, buf):
# TODO # TODO
@ -52,19 +64,33 @@ class http_simple(object):
if self.has_sent_header: if self.has_sent_header:
return buf return buf
else: else:
header = "HTTP/1.1 200 OK\r\nServer: openresty\r\nDate: " header = b'HTTP/1.1 200 OK\r\nServer: openresty\r\nDate: '
header += datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S GMT') header += to_bytes(datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S GMT'))
header += '''\r\nContent-Type: text/plain; charset=utf-8\r\nTransfer-Encoding: chunked\r\nConnection: keep-alive\r\nKeep-Alive: timeout=20\r\nVary: Accept-Encoding\r\nContent-Encoding: gzip\r\n\r\n''' header += b'\r\nContent-Type: text/plain; charset=utf-8\r\nTransfer-Encoding: chunked\r\nConnection: keep-alive\r\nKeep-Alive: timeout=20\r\nVary: Accept-Encoding\r\nContent-Encoding: gzip\r\n\r\n'
self.has_sent_header = True self.has_sent_header = True
return header + buf return header + buf
def get_data_from_http_header(self, buf):
ret_buf = b''
lines = buf.split(b'\r\n')
if lines and len(lines) > 4:
hex_items = lines[0].split(b'%')
if hex_items and len(hex_items) > 1:
for index in range(1, len(hex_items)):
if len(hex_items[index]) != 2:
ret_buf += binascii.unhexlify(hex_items[index][:2])
break
ret_buf += binascii.unhexlify(hex_items[index])
return ret_buf
return b''
def server_decode(self, buf): def server_decode(self, buf):
if self.has_recv_header: if self.has_recv_header:
return (buf, True, False) return (buf, True, False)
else: else:
buf = self.recv_buffer + buf buf = self.recv_buffer + buf
if len(buf) > 10: if len(buf) > 10:
if buf[:5] == "GET /" or buf[:6] == "POST /": if match_begin(buf, b'GET /') or match_begin(buf, b'POST /'):
pass pass
else: #not http header, run on original protocol else: #not http header, run on original protocol
self.has_sent_header = True self.has_sent_header = True
@ -73,26 +99,81 @@ class http_simple(object):
return (buf, True, False) return (buf, True, False)
else: else:
self.recv_buffer = buf self.recv_buffer = buf
return ("", True, False) return (b'', True, False)
datas = buf.split('\r\n\r\n', 1) datas = buf.split(b'\r\n\r\n', 1)
if datas and len(datas) > 1 and len(datas[1]) >= 7: ret_buf = b''
lines = buf.split('\r\n') if datas and len(datas) > 1:
if lines and len(lines) > 4: ret_buf = self.get_data_from_http_header(buf)
hex_items = lines[0].split('%') ret_buf += datas[1]
if hex_items and len(hex_items) > 1: if len(ret_buf) >= 15:
ret_buf = "" self.has_recv_header = True
for index in xrange(1, len(hex_items)): return (ret_buf, True, False)
if len(hex_items[index]) != 2: self.recv_buffer = buf
ret_buf += binascii.unhexlify(hex_items[index][:2]) return (b'', True, False)
break else:
ret_buf += binascii.unhexlify(hex_items[index]) self.recv_buffer = buf
return (b'', True, False)
self.has_sent_header = True
self.has_recv_header = True
return (buf, True, False)
class http2_simple(object):
def __init__(self, method):
self.method = method
self.has_sent_header = False
self.has_recv_header = False
self.host = None
self.port = 0
self.recv_buffer = b''
def client_encode(self, buf):
# TODO
return buf
def client_decode(self, buf):
# TODO
return (buf, False)
def server_encode(self, buf):
if self.has_sent_header:
return buf
else:
header = b'HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: h2c\r\n\r\n'
self.has_sent_header = True
return header + buf
def server_decode(self, buf):
if self.has_recv_header:
return (buf, True, False)
else:
buf = self.recv_buffer + buf
if len(buf) > 10:
if match_begin(buf, b'GET /'):
pass
else: #not http header, run on original protocol
self.has_sent_header = True
self.has_recv_header = True
self.recv_buffer = None
return (buf, True, False)
else:
self.recv_buffer = buf
return (b'', True, False)
datas = buf.split(b'\r\n\r\n', 1)
if datas and len(datas) > 1 and len(datas[0]) >= 4:
lines = buf.split(b'\r\n')
if lines and len(lines) >= 4:
if match_begin(lines[4], b'HTTP2-Settings: '):
ret_buf = base64.urlsafe_b64decode(lines[4][16:])
ret_buf += datas[1] ret_buf += datas[1]
self.has_recv_header = True self.has_recv_header = True
return (ret_buf, True, False) return (ret_buf, True, False)
self.recv_buffer = buf
return (b'', True, False)
else: else:
self.recv_buffer = buf self.recv_buffer = buf
return ("", True, False) return (b'', True, False)
self.has_sent_header = True self.has_sent_header = True
self.has_recv_header = True self.has_recv_header = True
return (buf, True, False) return (buf, True, False)

1
shadowsocks/shell.py
View File

@ -216,6 +216,7 @@ def get_config(is_local):
config['password'] = to_bytes(config.get('password', b'')) config['password'] = to_bytes(config.get('password', b''))
config['method'] = to_str(config.get('method', 'aes-256-cfb')) config['method'] = to_str(config.get('method', 'aes-256-cfb'))
config['obfs'] = to_str(config.get('obfs', 'plain'))
config['port_password'] = config.get('port_password', None) config['port_password'] = config.get('port_password', None)
config['timeout'] = int(config.get('timeout', 300)) config['timeout'] = int(config.get('timeout', 300))
config['fast_open'] = config.get('fast_open', False) config['fast_open'] = config.get('fast_open', False)

16
shadowsocks/tcprelay.py
View File

@ -117,11 +117,11 @@ class TCPRelayHandler(object):
self._encryptor = encrypt.Encryptor(config['password'], self._encryptor = encrypt.Encryptor(config['password'],
config['method']) config['method'])
self._encrypt_correct = True self._encrypt_correct = True
self._obfs = obfs.Obfs(config.get('obfs', 'plain')) self._obfs = obfs.Obfs(config['obfs'])
self._fastopen_connected = False self._fastopen_connected = False
self._data_to_write_to_local = [] self._data_to_write_to_local = []
self._data_to_write_to_remote = [] self._data_to_write_to_remote = []
self._udp_data_send_buffer = '' self._udp_data_send_buffer = b''
self._upstream_status = WAIT_STATUS_READING self._upstream_status = WAIT_STATUS_READING
self._downstream_status = WAIT_STATUS_INIT self._downstream_status = WAIT_STATUS_INIT
self._client_address = local_sock.getpeername()[:2] self._client_address = local_sock.getpeername()[:2]
@ -293,7 +293,7 @@ class TCPRelayHandler(object):
def _get_redirect_host(self, client_address, ogn_data): def _get_redirect_host(self, client_address, ogn_data):
# test # test
host_list = [("www.bing.com", 80), ("www.microsoft.com", 80), ("www.baidu.com", 443), ("www.qq.com", 80), ("www.csdn.net", 80), ("1.2.3.4", 1000)] host_list = [(b"www.bing.com", 80), (b"www.microsoft.com", 80), (b"www.baidu.com", 443), (b"www.qq.com", 80), (b"www.csdn.net", 80), (b"1.2.3.4", 1000)]
hash_code = binascii.crc32(ogn_data) hash_code = binascii.crc32(ogn_data)
addrs = socket.getaddrinfo(client_address[0], client_address[1], 0, socket.SOCK_STREAM, socket.SOL_TCP) addrs = socket.getaddrinfo(client_address[0], client_address[1], 0, socket.SOCK_STREAM, socket.SOL_TCP)
af, socktype, proto, canonname, sa = addrs[0] af, socktype, proto, canonname, sa = addrs[0]
@ -312,7 +312,7 @@ class TCPRelayHandler(object):
self._encrypt_correct = False self._encrypt_correct = False
#create redirect or disconnect by hash code #create redirect or disconnect by hash code
host, port = self._get_redirect_host(client_address, ogn_data) host, port = self._get_redirect_host(client_address, ogn_data)
data = "\x03" + chr(len(host)) + host + struct.pack('>H', port) data = b"\x03" + common.chr(len(host)) + host + struct.pack('>H', port)
logging.warn("TCP data redir %s:%d %s" % (host, port, binascii.hexlify(data))) logging.warn("TCP data redir %s:%d %s" % (host, port, binascii.hexlify(data)))
return data + ogn_data return data + ogn_data
@ -551,7 +551,7 @@ class TCPRelayHandler(object):
if self._encrypt_correct: if self._encrypt_correct:
obfs_decode = self._obfs.server_decode(data) obfs_decode = self._obfs.server_decode(data)
if obfs_decode[2]: if obfs_decode[2]:
self._write_to_sock("", self._local_sock) self._write_to_sock(b'', self._local_sock)
if obfs_decode[1]: if obfs_decode[1]:
data = self._encryptor.decrypt(obfs_decode[0]) data = self._encryptor.decrypt(obfs_decode[0])
else: else:
@ -588,10 +588,10 @@ class TCPRelayHandler(object):
port = struct.pack('>H', addr[1]) port = struct.pack('>H', addr[1])
try: try:
ip = socket.inet_aton(addr[0]) ip = socket.inet_aton(addr[0])
data = '\x00\x01' + ip + port + data data = b'\x00\x01' + ip + port + data
except Exception as e: except Exception as e:
ip = socket.inet_pton(socket.AF_INET6, addr[0]) ip = socket.inet_pton(socket.AF_INET6, addr[0])
data = '\x00\x04' + ip + port + data data = b'\x00\x04' + ip + port + data
data = struct.pack('>H', len(data) + 2) + data data = struct.pack('>H', len(data) + 2) + data
#logging.info('UDP over TCP recvfrom %s:%d %d bytes to %s:%d' % (addr[0], addr[1], len(data), self._client_address[0], self._client_address[1])) #logging.info('UDP over TCP recvfrom %s:%d %d bytes to %s:%d' % (addr[0], addr[1], len(data), self._client_address[0], self._client_address[1]))
else: else:
@ -608,7 +608,7 @@ class TCPRelayHandler(object):
if self._is_local: if self._is_local:
obfs_decode = self._obfs.client_decode(data) obfs_decode = self._obfs.client_decode(data)
if obfs_decode[1]: if obfs_decode[1]:
self._write_to_sock("", self._remote_sock) self._write_to_sock(b'', self._remote_sock)
data = self._encryptor.decrypt(obfs_decode[0]) data = self._encryptor.decrypt(obfs_decode[0])
else: else:
if self._encrypt_correct: if self._encrypt_correct:

38
shadowsocks/udprelay.py
View File

@ -115,15 +115,15 @@ CMD_POST_64 = 6
CMD_SYN_STATUS_64 = 7 CMD_SYN_STATUS_64 = 7
CMD_DISCONNECT = 8 CMD_DISCONNECT = 8
CMD_VER_STR = "\x08" CMD_VER_STR = b"\x08"
RSP_STATE_EMPTY = "" RSP_STATE_EMPTY = b""
RSP_STATE_REJECT = "\x00" RSP_STATE_REJECT = b"\x00"
RSP_STATE_CONNECTED = "\x01" RSP_STATE_CONNECTED = b"\x01"
RSP_STATE_CONNECTEDREMOTE = "\x02" RSP_STATE_CONNECTEDREMOTE = b"\x02"
RSP_STATE_ERROR = "\x03" RSP_STATE_ERROR = b"\x03"
RSP_STATE_DISCONNECT = "\x04" RSP_STATE_DISCONNECT = b"\x04"
RSP_STATE_REDIRECT = "\x05" RSP_STATE_REDIRECT = b"\x05"
class UDPLocalAddress(object): class UDPLocalAddress(object):
def __init__(self, addr): def __init__(self, addr):
@ -309,7 +309,7 @@ class TCPRelayHandler(object):
self._random_mtu_size = [random.randint(POST_MTU_MIN, POST_MTU_MAX) for i in range(1024)] self._random_mtu_size = [random.randint(POST_MTU_MIN, POST_MTU_MAX) for i in range(1024)]
self._random_mtu_index = 0 self._random_mtu_index = 0
self._rand_data = "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10" * 4 self._rand_data = b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10" * 4
def __hash__(self): def __hash__(self):
# default __hash__ is id / 16 # default __hash__ is id / 16
@ -589,29 +589,29 @@ class TCPRelayHandler(object):
def _pack_rsp_data(self, cmd, data): def _pack_rsp_data(self, cmd, data):
reqid_str = struct.pack(">H", self._request_id) reqid_str = struct.pack(">H", self._request_id)
return ''.join([CMD_VER_STR, chr(cmd), reqid_str, data, self._rand_data[:random.randint(0, len(self._rand_data))], reqid_str]) return b''.join([CMD_VER_STR, common.chr(cmd), reqid_str, data, self._rand_data[:random.randint(0, len(self._rand_data))], reqid_str])
def _pack_rnd_data(self, data): def _pack_rnd_data(self, data):
length = random.randint(0, len(self._rand_data)) length = random.randint(0, len(self._rand_data))
if length == 0: if length == 0:
return data return data
elif length == 1: elif length == 1:
return "\x81" + data return b"\x81" + data
elif length < 256: elif length < 256:
return "\x80" + chr(length) + self._rand_data[:length - 2] + data return b"\x80" + common.chr(length) + self._rand_data[:length - 2] + data
else: else:
return "\x82" + struct.pack(">H", length) + self._rand_data[:length - 3] + data return b"\x82" + struct.pack(">H", length) + self._rand_data[:length - 3] + data
def _pack_post_data(self, cmd, pack_id, data): def _pack_post_data(self, cmd, pack_id, data):
reqid_str = struct.pack(">H", self._request_id) reqid_str = struct.pack(">H", self._request_id)
recv_id = self._recvqueue.get_begin_id() recv_id = self._recvqueue.get_begin_id()
rsp_data = ''.join([CMD_VER_STR, chr(cmd), reqid_str, struct.pack(">I", recv_id), struct.pack(">I", pack_id), data, reqid_str]) rsp_data = b''.join([CMD_VER_STR, common.chr(cmd), reqid_str, struct.pack(">I", recv_id), struct.pack(">I", pack_id), data, reqid_str])
return rsp_data return rsp_data
def _pack_post_data_64(self, cmd, send_id, pack_id, data): def _pack_post_data_64(self, cmd, send_id, pack_id, data):
reqid_str = struct.pack(">H", self._request_id) reqid_str = struct.pack(">H", self._request_id)
recv_id = self._recvqueue.get_begin_id() recv_id = self._recvqueue.get_begin_id()
rsp_data = ''.join([CMD_VER_STR, chr(cmd), reqid_str, struct.pack(">Q", recv_id), struct.pack(">Q", pack_id), data, reqid_str]) rsp_data = b''.join([CMD_VER_STR, common.chr(cmd), reqid_str, struct.pack(">Q", recv_id), struct.pack(">Q", pack_id), data, reqid_str])
return rsp_data return rsp_data
def sweep_timeout(self): def sweep_timeout(self):
@ -619,7 +619,7 @@ class TCPRelayHandler(object):
if self._stage == STAGE_STREAM: if self._stage == STAGE_STREAM:
pack_id, missing = self._recvqueue.get_missing_id(0) pack_id, missing = self._recvqueue.get_missing_id(0)
logging.info("sweep_timeout %s %s" % (pack_id, missing)) logging.info("sweep_timeout %s %s" % (pack_id, missing))
data = '' data = b''
for pid in missing: for pid in missing:
data += struct.pack(">H", pid) data += struct.pack(">H", pid)
rsp_data = self._pack_post_data(CMD_SYN_STATUS, pack_id, data) rsp_data = self._pack_post_data(CMD_SYN_STATUS, pack_id, data)
@ -642,7 +642,7 @@ class TCPRelayHandler(object):
# post CMD_SYN_STATUS # post CMD_SYN_STATUS
send_id = self._sendingqueue.get_end_id() send_id = self._sendingqueue.get_end_id()
post_pack_id, missing = self._recvqueue.get_missing_id(0) post_pack_id, missing = self._recvqueue.get_missing_id(0)
pack_ids_data = '' pack_ids_data = b''
for pid in missing: for pid in missing:
pack_ids_data += struct.pack(">H", pid) pack_ids_data += struct.pack(">H", pid)
@ -959,9 +959,9 @@ class UDPRelay(object):
return data return data
def _pack_rsp_data(self, cmd, request_id, data): def _pack_rsp_data(self, cmd, request_id, data):
_rand_data = "123456789abcdefghijklmnopqrstuvwxyz" * 2 _rand_data = b"123456789abcdefghijklmnopqrstuvwxyz" * 2
reqid_str = struct.pack(">H", request_id) reqid_str = struct.pack(">H", request_id)
return ''.join([CMD_VER_STR, chr(cmd), reqid_str, data, _rand_data[:random.randint(0, len(_rand_data))], reqid_str]) return b''.join([CMD_VER_STR, common.chr(cmd), reqid_str, data, _rand_data[:random.randint(0, len(_rand_data))], reqid_str])
def _handle_server(self): def _handle_server(self):
server = self._server_socket server = self._server_socket

Write Preview
Loading…
Cancel
Save