vbatts/shadowsocks
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

use ssloop

Browse source
This commit is contained in:
clowwindy 2013-05-17 16:05:38 +08:00
parent b9a84f9bad
commit ef8b741182
4 changed files with 118 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.gitmodules vendored Normal file
View file

@ -0,0 +1,3 @@
[submodule "ssloop"]
path = ssloop
url = https://github.com/clowwindy/ssloop.git

6
README.md
View file

@ -2,7 +2,7 @@ shadowsocks
===========
[![Build Status](https://travis-ci.org/clowwindy/shadowsocks.png)](https://travis-ci.org/clowwindy/shadowsocks)
Current version: 1.1
Current version: 2.0
shadowsocks is a lightweight tunnel proxy which can help you get through firewalls
@ -41,10 +41,6 @@ You can use args to override settings from `config.json`.
python local.py -s server_name -p server_port -l local_port -k password
python server.py -p server_port -k password
You may want to install gevent for better performance.
$ sudo apt-get install python-gevent
Or:
$ sudo apt-get install libevent-dev python-pip

222
local.py
View file

@ -26,23 +26,14 @@ if sys.version_info < (2, 6):
import simplejson as json
else:
import json
try:
import gevent, gevent.monkey
gevent.monkey.patch_all(dns=gevent.version_info[0]>=1)
except ImportError:
gevent = None
print >>sys.stderr, 'warning: gevent not found, using threading instead'
import socket
import select
import SocketServer
import struct
import string
import hashlib
import os
import logging
import getopt
import socket
def get_table(key):
m = hashlib.md5()
@ -54,112 +45,126 @@ def get_table(key):
table.sort(lambda x, y: int(a % (ord(x) + i) - a % (ord(y) + i)))
return table
def send_all(sock, data):
bytes_sent = 0
while True:
r = sock.send(data[bytes_sent:])
if r < 0:
return r
bytes_sent += r
if bytes_sent == len(data):
return bytes_sent
class ThreadingTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
allow_reuse_address = True
def encrypt(data):
return data.translate(encrypt_table)
class Socks5Server(SocketServer.StreamRequestHandler):
def handle_tcp(self, sock, remote):
try:
fdset = [sock, remote]
while True:
r, w, e = select.select(fdset, [], [])
if sock in r:
data = sock.recv(4096)
if len(data) <= 0:
break
result = send_all(remote, self.encrypt(data))
if result < len(data):
raise Exception('failed to send all data')
def decrypt(data):
return data.translate(decrypt_table)
if remote in r:
data = remote.recv(4096)
if len(data) <= 0:
break
result = send_all(sock, self.decrypt(data))
if result < len(data):
raise Exception('failed to send all data')
finally:
sock.close()
remote.close()
def encrypt(self, data):
return data.translate(encrypt_table)
class RemoteHandler(object):
def __init__(self, conn, local_handler):
self.conn = conn
self.local_handler = local_handler
conn.on('connect', self.on_connect)
conn.on('data', self.on_data)
conn.on('close', self.on_close)
conn.on('end', self.on_end)
conn.connect((SERVER, REMOTE_PORT))
def decrypt(self, data):
return data.translate(decrypt_table)
def on_connect(self, s):
self.conn.write(encrypt(self.local_handler.addr_to_send))
for piece in self.local_handler.cached_pieces:
self.conn.write(encrypt(piece))
# TODO write cached pieces
self.local_handler.stage = 5
def send_encrypt(self, sock, data):
sock.send(self.encrypt(data))
def on_data(self, s, data):
data = decrypt(data)
self.local_handler.conn.write(data)
def handle(self):
try:
sock = self.connection
sock.recv(262)
sock.send("\x05\x00")
data = self.rfile.read(4) or '\x00' * 4
mode = ord(data[1])
if mode != 1:
logging.warn('mode != 1')
return
addrtype = ord(data[3])
addr_to_send = data[3]
if addrtype == 1:
addr_ip = self.rfile.read(4)
addr = socket.inet_ntoa(addr_ip)
addr_to_send += addr_ip
elif addrtype == 3:
addr_len = self.rfile.read(1)
addr = self.rfile.read(ord(addr_len))
addr_to_send += addr_len + addr
elif addrtype == 4:
addr_ip = self.rfile.read(16)
addr = socket.inet_ntop(socket.AF_INET6, addr_ip)
addr_to_send += addr_ip
else:
logging.warn('addr_type not support')
# not support
return
addr_port = self.rfile.read(2)
addr_to_send += addr_port
port = struct.unpack('>H', addr_port)
def on_close(self, s):
# self.local_handler.conn.end()
pass
def on_end(self, s):
self.local_handler.conn.end()
class LocalHandler(object):
def on_data(self, s, data):
if self.stage == 5:
data = encrypt(data)
self.remote_handler.conn.write(data)
return
if self.stage == 0:
self.conn.write('\x05\00')
self.stage = 1
return
if self.stage == 1:
try:
reply = "\x05\x00\x00\x01"
reply += socket.inet_aton('0.0.0.0') + struct.pack(">H", 2222)
self.wfile.write(reply)
# reply immediately
if '-6' in sys.argv[1:]:
remote = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
remote.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
remote.connect((SERVER, REMOTE_PORT, 0, 0))
cmd = ord(data[1])
addrtype = ord(data[3])
# TODO check cmd == 1
if addrtype == 1:
remote_addr = socket.inet_ntoa(data[4:8])
remote_port = data[8:10]
self.addr_to_send = data[3:10]
header_length = 10
elif addrtype == 4:
remote_addr = socket.inet_ntop(data[4:20])
remote_port = data[20:22]
self.addr_to_send = data[3:22]
header_length = 22
elif addrtype == 3:
addr_len = ord(data[4])
remote_addr = data[5:5 + addr_len]
remote_port = data[5 + addr_len:5 + addr_len + 2]
self.addr_to_send = data[3:5 + addr_len + 2]
header_length = 5 + addr_len + 2
else:
remote = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
remote.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
remote.connect((SERVER, REMOTE_PORT))
# TODO check addrtype in (1, 3, 4)
raise
remote_port = struct.unpack('>H', remote_port)[0]
logging.info('connecting %s:%d' % (remote_addr, remote_port))
self.conn.write('\x05\x00\x00\x01\x00\x00\x00\x00\x10\x10')
remote_conn = ssloop.Socket()
self.remote_handler = RemoteHandler(remote_conn, self)
self.send_encrypt(remote, addr_to_send)
logging.info('connecting %s:%d' % (addr, port[0]))
except socket.error, e:
logging.warn(e)
if len(data) > header_length:
self.cached_pieces.append(data[header_length:])
# TODO save other bytes
self.stage = 4
return
self.handle_tcp(sock, remote)
except socket.error, e:
logging.warn(e)
except:
import traceback
traceback.print_exc()
if self.stage == 4:
self.cached_pieces.append(data)
def on_end(self, s):
if self.remote_handler:
self.remote_handler.conn.end()
def on_close(self, s):
pass
# self.remote_handler.conn.end()
def __init__(self, conn):
self.stage = 0
self.remote = None
self.addr_len = 0
self.addr_to_send = ''
self.conn = conn
self.cached_pieces = []
conn.on('data', self.on_data)
conn.on('end', self.on_end)
conn.on('close', self.on_close)
def on_connection(s, conn):
LocalHandler(conn)
if __name__ == '__main__':
os.chdir(os.path.dirname(__file__) or '.')
print 'shadowsocks v1.1'
sys.path.append('./ssloop')
import ssloop
print 'shadowsocks v2.0'
with open('config.json', 'rb') as f:
config = json.load(f)
@ -183,18 +188,17 @@ if __name__ == '__main__':
elif key == '-s':
SERVER = value
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S', filemode='a+')
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S', filemode='a+')
encrypt_table = ''.join(get_table(KEY))
decrypt_table = string.maketrans(encrypt_table, string.maketrans('', ''))
try:
server = ThreadingTCPServer(('', PORT), Socks5Server)
logging.info("starting server at port %d ..." % PORT)
server.serve_forever()
except socket.error, e:
logging.error(e)
loop = ssloop.instance()
s = ssloop.Server(('0.0.0.0', PORT))
s.on('connection', on_connection)
s.listen()
loop.start()
except KeyboardInterrupt:
server.shutdown()
sys.exit(0)

1
ssloop Submodule

@ -0,0 +1 @@
Subproject commit bff37894f53ea3d4ea69aef459a37b0336e43c1b