def handle(self, sock, addr):
print 'connection from %s:%s' % addr
src = XSocket(socket = sock, secure = True)
#socks5 negotiation step2: specify command and destination
ver, cmd, rsv, atype = src.unpack('BBBB', 4)
if cmd != 0x01:
src.pack('BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
if atype == 0x01: #ipv4
host, port = src.unpack('!IH', 6)
hostip = socket.inet_ntoa(struct.pack('!I', host))
elif atype == 0x03: #domain name
length = src.unpack('B', 1)[0]
hostname, port = src.unpack("!%dsH" % length, length + 2)
hostip = gethostbyname(hostname)
host = struct.unpack("!I", socket.inet_aton(hostip))[0]
elif atype == 0x04: #ipv6: TODO
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
else:
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
try:
dest = XSocket(addr = (hostip, port))
except IOError, ex:
print "%s:%d" % addr, "failed to connect to %s:%d" % (hostip, port)
src.pack('!BBBBIH', 0x05, 0x03, 0x00, 0x01, host, port)
return
def socks4Handle(self):
cd,port,dstip = self.sock.unpack('!BHI')
if cd != 1:
# 1 == 连接， 2 == 绑定
self.sock.pack('!BBHI',0,91,port,dstip)
self.sock.close()
userid = self.sock.readline(end='\0')[:-1]
hostname = _socket.inet_ntoa(struct.pack('!I', dstip))
if hostname.startswith('0.0.0.'):
# SOCKS4a 支持 ，chrome 不支持 socks4a 扩展。
hostname = self.sock.readline(end='\0')[:-1]
# 对外发起请求
try:
remote_sock = self.server.upstream.create_connection((hostname,port),)
except:
logging.exception(u'所有线路连接 tcp host:%s port:%s 失败。'%(hostname,port))
# 按照socks4协议，这里返回和请求相同的ip和端口
# https://zh.wikipedia.org/wiki/SOCKS
self.sock.pack('!BBHI',0,91,port,dstip)
self.sock.close()
return
# 按照socks4协议，这里返回和请求相同的ip和端口
# https://zh.wikipedia.org/wiki/SOCKS
self.sock.pack('!BBHI',0,90,port,dstip)
self.forward(self.sock,remote_sock,5*60)
def socks5Handle(self):
# 鉴定
(nmethods,) = self.sock.unpack('B')
if nmethods > 0:
(methods,) = self.sock.unpack('B' * nmethods)
# TODO: 未检查客户端支持的鉴定方式
self.sock.pack('BB', 0x05, 0x00)
logging.debug(u'[Socks5Handler]client login')
# 接收代理请求
ver, cmd, rsv, atyp = self.sock.unpack('BBBB')
if ver != 0x05 or cmd != 0x01:
logging.warn(u'[Socks5Handler]收到未知类型的请求，关闭连接。 ver=%s ,cmd=%s' % (ver, cmd))
self.sock.pack('BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
self.sock.close()
return
if atyp == 0x01:
# ipv4
host, port = self.sock.unpack('!IH')
hostname = _socket.inet_ntoa(struct.pack('!I', host))
elif atyp == 0x03:
# 域名
length = self.sock.unpack('B')[0]
hostname, port = self.sock.unpack("!%dsH" % length)
elif atyp == 0x04:
# ipv6
ipv61, ipv62, port = self.sock.unpack('!2QH')
hostname = _socket.inet_ntop(_socket.AF_INET6, struct.pack('!2Q', ipv61, ipv62))
else:
logging.warn(u'[SClient]收到未知的目的地址类型，关闭连接。 atyp=%s ' % (atyp))
self.sock.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
self.sock.close()
return
logging.debug(u'[SClient] host:%s prot:%s' % (hostname, port))
# 对外发起请求
try:
remote_sock = self.server.upstream.create_connection((hostname,port),)
except:
logging.exception(u'所有线路连接 tcp host:%s port:%s 失败。'%(hostname,port))
# TODO: 按照socks5协议，这里应该返回服务器绑定的地址及端口
# http://blog.csdn.net/testcs_dn/article/details/7915505
self.sock.pack('!BBBBIH', 0x05, 0x03, 0x00, 0x01, 0, 0)
self.sock.close()
return
if hasattr(remote_sock,'display_name'):
remote_sock_display_name = remote_sock.display_name
else:
remote_sock_display_name = str(remote_sock)
logging.info(u'连接 tcp目标 host:%s port:%s 通过 %s 建立成功。'%(hostname,port,remote_sock_display_name))
# TODO: 按照socks5协议，这里应该返回服务器绑定的地址及端口
# http://blog.csdn.net/testcs_dn/article/details/7915505
self.sock.pack('!BBBBIH', 0x05, 0x00, 0x00, 0x01, 0, 0)
self.forward(self.sock,remote_sock,5*60)
def unpackRR(self, s):
n = self.unpackname(s)
r = struct.unpack('>HHIH', s.read(10))
if r[0] == TYPE.A:
return n, r[0], r[1], r[2], socket.inet_ntoa(s.read(r[3]))
elif r[0] == TYPE.CNAME:
return n, r[0], r[1], r[2], self.unpackname(s)
else: raise Exception("don't know howto handle type")
def ipAddress(self, Address):
"""returns self.Address in ip address format"""
if Address == "":
return ""
try:
return socket.inet_ntoa(struct.pack("!I", Address))
except:
return Address
def ipAddress(self,Address):
'''returns self.Address in ip address format'''
if Address == '':
return ''
try:
return socket.inet_ntoa(struct.pack("!I", Address))
except:
return Address
def socks5Handle(self):
# 鉴定
(nmethods,) = self.sock.unpack('B')
if nmethods > 0:
(methods,) = self.sock.unpack('B' * nmethods)
# TODO: 未检查客户端支持的鉴定方式
self.sock.pack('BB', 0x05, 0x00)
logging.debug(u'[Socks5Handler]client login')
# 接收代理请求
ver, cmd, rsv, atyp = self.sock.unpack('BBBB')
if ver != 0x05 or cmd != 0x01:
logging.warn(u'[Socks5Handler]收到未知类型的请求，关闭连接。 ver=%s ,cmd=%s' % (ver, cmd))
self.sock.pack('BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
self.sock.close()
return
if atyp == 0x01:
# ipv4
host, port = self.sock.unpack('!IH')
hostname = _socket.inet_ntoa(struct.pack('!I', host))
elif atyp == 0x03:
# 域名
length = self.sock.unpack('B')[0]
hostname, port = self.sock.unpack("!%dsH" % length)
elif atyp == 0x04:
# ipv6
ipv61, ipv62, port = self.sock.unpack('!2QH')
hostname = _socket.inet_ntop(_socket.AF_INET6, struct.pack('!2Q', ipv61, ipv62))
else:
logging.warn(u'[SClient]收到未知的目的地址类型，关闭连接。 atyp=%s ' % (atyp))
self.sock.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
self.sock.close()
return
logging.debug(u'[SClient] host:%s prot:%s' % (hostname, port))
# 对外发起请求
try:
remote_sock = self.server.upstream.create_connection((hostname,port),)
except:
logging.exception(u'所有线路连接 tcp host:%s port:%s 失败。'%(hostname,port))
# TODO: 按照socks5协议，这里应该返回服务器绑定的地址及端口
# http://blog.csdn.net/testcs_dn/article/details/7915505
self.sock.pack('!BBBBIH', 0x05, 0x03, 0x00, 0x01, 0, 0)
self.sock.close()
return
# TODO: 按照socks5协议，这里应该返回服务器绑定的地址及端口
# http://blog.csdn.net/testcs_dn/article/details/7915505
self.sock.pack('!BBBBIH', 0x05, 0x00, 0x00, 0x01, 0, 0)
self.forward(self.sock,remote_sock,5*60)
def _read_SOCKS5_address(self, file):
atyp = self._readall(file, 1)
if atyp == b"\x01":
addr = socket.inet_ntoa(self._readall(file, 4))
elif atyp == b"\x03":
length = self._readall(file, 1)
addr = self._readall(file, ord(length))
else:
raise GeneralProxyError("SOCKS5 proxy server sent invalid data")
port = struct.unpack(">H", self._readall(file, 2))[0]
return addr, port
def socks5_connect(target, proxy, username=None, password=None, rdns=True):
sock = socket.socket()
sock.connect(proxy)
stream = sock.makefile()
# hand shake request
if username is None or password is None:
stream.write("\x05\x01\x00")
else: stream.write("\x05\x02\x00\x02")
stream.flush()
# hand shake response
chosenauth = stream.read(2)
if chosenauth[0] != "\x05": raise GeneralProxyError(1)
if chosenauth[1] == "\x00": pass
elif chosenauth[1] == "\x02":
stream.write('\x01' + fmt_string(username) + fmt_string(password))
stream.flush()
authstat = stream.read(2)
if authstat[0] != "\x01": raise GeneralProxyError(1)
if authstat[1] != "\x00": raise Socks5AuthError(3)
logger.debug('authenticated with password')
elif chosenauth[1] == "\xFF": raise Socks5AuthError(2)
else: raise GeneralProxyError(1)
# connect request
try: reqaddr = "\x01" + socket.inet_aton(target[0])
except socket.error:
if rdns: reqaddr = '\x03' + fmt_string(target[0])
else: reqaddr = "\x01" + socket.inet_aton(socket.gethostbyname(target[0]))
s = "\x05\x01\x00" + reqaddr + struct.pack(">H", target[1])
stream.write(s)
stream.flush()
# connect response
resp = stream.read(4)
if not resp: raise EOFError()
if resp[0] != "\x05": raise GeneralProxyError(1)
if resp[1] != "\x00":
if ord(resp[1]) <= 8: raise Socks5Error(ord(resp[1]))
else: raise Socks5Error(9)
if resp[3] == "\x03": boundaddr = stream.read(stream.read(1))
elif resp[3] == "\x01": boundaddr = socket.inet_ntoa(stream.read(4))
else: raise GeneralProxyError(1)
boundport = struct.unpack(">H", stream.read(2))[0]
logger.debug('connected with %s:%s, bind in %s:%d' % (
target[0], target[1], boundaddr, boundport))
return sock, (boundaddr, boundport)
def handle(self, sock, addr):
print 'connection from %s:%s' % addr
src = XSocket(socket = sock)
#socks5 negotiation step1: choose an authentication method
ver, n_method = src.unpack('BB', 2)
if ver != 0x05:
src.pack('BB', 0x05, 0xff)
return
if n_method > 0:
src.recv(n_method)
src.pack('!BB', 0x05, 0x00) #0x00 means no authentication needed
#socks5 negotiation step2: specify command and destination
ver, cmd, rsv, atype = src.unpack('BBBB', 4)
if cmd != 0x01:
src.pack('BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
if atype == 0x01: #ipv4
host, port = src.unpack('!IH', 6)
hostip = socket.inet_ntoa(struct.pack('!I', host))
elif atype == 0x03: #domain name
length = src.unpack('B', 1)[0]
hostname, port = src.unpack("!%dsH" % length, length + 2)
hostip = gethostbyname(hostname)
host = struct.unpack("!I", socket.inet_aton(hostip))[0]
elif atype == 0x04: #ipv6: TODO
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
else:
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
try:
print "call proxy, host:", hostip, port
dest = SmartSocket(addr = (hostip, port))
except IOError, ex:
print "%s:%d" % addr, "failed to connect to %s:%d" % (hostip, port)
src.pack('!BBBBIH', 0x05, 0x03, 0x00, 0x01, host, port)
return
def unpackRR(self, s):
n = self.unpackname(s)
r = struct.unpack('>HHIH', s.read(10))
if r[0] == TYPE.A:
return n, r[0], r[1], r[2], socket.inet_ntoa(s.read(r[3]))
elif r[0] == TYPE.CNAME:
return n, r[0], r[1], r[2], self.unpackname(s)
elif r[0] == TYPE.MX:
return n, r[0], r[1], r[2], \
struct.unpack('>H', s.read(2))[0], self.unpackname(s)
elif r[0] == TYPE.PTR:
return n, r[0], r[1], r[2], self.unpackname(s)
elif r[0] == TYPE.SOA:
rr = [n, r[0], r[1], r[2], self.unpackname(s), self.unpackname(s)]
rr.extend(struct.unpack('>IIIII', s.read(20)))
return tuple(rr)
else: raise Exception("don't know howto handle type, %s." % str(r))
def handle(self, sock, addr):
print 'connection from %s:%s' % addr
src = XSocket(socket = sock)
#socks5 negotiation step1: choose an authentication method
ver, n_method = src.unpack('BB', 2)
if ver != 0x05:
src.pack('BB', 0x05, 0xff)
return
if n_method > 0:
src.recv(n_method)
src.pack('!BB', 0x05, 0x00) #0x00 means no authentication needed
#socks5 negotiation step2: specify command and destination
ver, cmd, rsv, atype = src.unpack('BBBB', 4)
if cmd != 0x01:
src.pack('BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
if atype == 0x01: #ipv4
host, port = src.unpack('!IH', 6)
hostip = socket.inet_ntoa(struct.pack('!I', host))
elif atype == 0x03: #domain name
length = src.unpack('B', 1)[0]
hostname, port = src.unpack("!%dsH" % length, length + 2)
hostip = gethostbyname(hostname)
host = struct.unpack("!I", socket.inet_aton(hostip))[0]
elif atype == 0x04: #ipv6: TODO
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
else:
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
try:
dest = XSocket(addr = (hostip, port))
except IOError, ex:
print "%s:%d" % addr, "failed to connect to %s:%d" % (hostip, port)
src.pack('!BBBBIH', 0x05, 0x03, 0x00, 0x01, host, port)
return
def unpackRR(self, s):
n = self.unpackname(s)
r = struct.unpack('>HHIH', s.read(10))
if r[0] == TYPE.A:
return n, r[0], r[1], r[2], socket.inet_ntoa(s.read(r[3]))
elif r[0] == TYPE.CNAME:
return n, r[0], r[1], r[2], self.unpackname(s)
elif r[0] == TYPE.MX:
return n, r[0], r[1], r[2], \
struct.unpack('>H', s.read(2))[0], self.unpackname(s)
elif r[0] == TYPE.PTR:
return n, r[0], r[1], r[2], self.unpackname(s)
elif r[0] == TYPE.SOA:
rr = [n, r[0], r[1], r[2], self.unpackname(s), self.unpackname(s)]
rr.extend(struct.unpack('>IIIII', s.read(20)))
return tuple(rr)
else:
raise Exception("don't know howto handle type, %s." % str(r))
def msgfill_parsed_record_v9(dd):
log.info("parsing v9 records")
global FIELDS
global PROTO_DIC
d = {}
e = {}
for (k, v) in dd.iteritems():
#log.debug("********** %s ******* %s", k, v)
if k in _filter_ipv4:
#log.debug("#pack the ipv4")
msgfilling.add_types(e, '_type_ip', FIELDS[k])
msgfilling.add_types(e, '_type_str', FIELDS[k])
d[k] = socket.inet_ntoa(struct.pack('!I', dd[k]))
elif k in _filter_ipv6:
#log.debug("#pace the ipv6")
msgfilling.add_types(e, '_type_ip', FIELDS[k])
msgfilling.add_types(e, '_type_str', FIELDS[k])
d[k] = dd[k]
else:
#log.debug("leave as it is")
d[k] = dd[k]
if (k == 4):
try:
e['protocol_name'] = PROTO_DIC[d[k]]
except:
log.info("Protocol Name not found in PROTO_DIC")
e['protocol_name'] = "Unknown"
msgfilling.add_types(e, '_type_str', "protocol_name")
try:
msgfilling.add_types(e, '_type_num', FIELDS[k])
except:
log.info(
"Fields not found in netflow_v9 field_type; Not filling msg_type"
)
#msgfilling.add_types(e, '_type_num', "Unknown_field_"+str(k))
try:
e[FIELDS[k]] = d[k]
except:
log.info(
"Fields not found in netflow_v9 field_type; Not assigining values."
)
#e["Unknown_field_"+str(k)] = d[k]
log.debug("this is v9 parsed result %s", e)
return e
def msgfill_parsed_record(self, ev):
#log.info("parsing v9 records")
temp_ev = {}
filled_ev = {}
for (k, v) in ev.iteritems():
#log.debug("********** %s ******* %s", k, v)
if k in self._filter_ipv4:
# log.debug("#pack the ipv4")
self.prepare_msgfilling(filled_ev, TYPE_IP, FIELDS[k])
self.prepare_msgfilling(filled_ev, TYPE_STR, FIELDS[k])
temp_ev[k] = socket.inet_ntoa(struct.pack('!I', ev[k]))
elif k in self._filter_ipv6:
# log.debug("#pace the ipv6")
self.prepare_msgfilling(filled_ev, TYPE_IP, FIELDS[k])
self.prepare_msgfilling(filled_ev, TYPE_STR, FIELDS[k])
temp_ev[k] = ev[k]
else:
#log.debug("leave as it is")
temp_ev[k] = ev[k]
if (k == 4):
filled_ev['protocol_name'] = PROTO_DIC.get(
temp_ev[k], "Unknown")
self.prepare_msgfilling(filled_ev, TYPE_STR,
"protocol_name")
try:
self.prepare_msgfilling(filled_ev, TYPE_NUM, FIELDS[k])
except:
log.info(
"Fields not found in netflow_v9 field_type; Not filling msg_type"
)
#msgfilling.add_types(e, TYPE_NUM, "Unknown_field_"+str(k))
try:
filled_ev[FIELDS[k]] = temp_ev[k]
except:
log.info(
"Fields not found in netflow_v9 field_type; Not assigining values."
)
#e["Unknown_field_"+str(k)] = d[k]
#log.debug("this is v9 parsed result %s", e)
return filled_ev
def handshake(ws):
try:
recv = ws.receive()
if recv[0] != 5:
return False
send_msg = (b'\x05\x00')
ws.send(send_msg)
gevent.sleep(2)
recv = ws.receive()
if recv != None:
# print(recv)
if recv[0] != 5 or recv[2] != 0:
return False
else:
return False
addr_type = recv[3]
if addr_type == 1:
addr = socket.inet_ntoa(recv[4:8])
elif addr_type == 3:
addr_len = recv[4]
addr = socket.gethostbyname(recv[5:5 + addr_len])
else:
# only ipv4 addr or domain name is supported.
return False
port = recv[-2] * 256 + recv[-1]
if recv[1] == 1:
server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
r = server_sock.connect_ex((addr,port))
if r == 0:
return server_sock
else:
return False
except Exception as e:
return False
def socks5_connect(sock, target, rdns=True):
stream = sock.makefile()
# connect request
try: reqaddr = "\x01" + socket.inet_aton(target[0])
except socket.error:
if rdns: reqaddr = '\x03' + fmt_string(target[0])
else: reqaddr = "\x01" + socket.inet_aton(socket.gethostbyname(target[0]))
s = "\x05\x01\x00" + reqaddr + struct.pack(">H", target[1])
stream.write(s)
stream.flush()
# connect response
resp = stream.read(4)
if not resp: raise EOFError()
if resp[0] != "\x05": raise GeneralProxyError(1)
if resp[1] != "\x00":
if ord(resp[1]) <= 8: raise Socks5Error(ord(resp[1]))
else: raise Socks5Error(9)
if resp[3] == "\x03": boundaddr = stream.read(stream.read(1))
elif resp[3] == "\x01": boundaddr = socket.inet_ntoa(stream.read(4))
else: raise GeneralProxyError(1)
boundport = struct.unpack(">H", stream.read(2))[0]
logger.debug('socks connected with %s:%s' % target)
return boundaddr, boundport
def getLocalIp(self):
import socket, fcntl, struct
f = open('/proc/net/dev')
if_list = []
while True:
line = f.readline()
if line:
dev_info = line.split(":")
if len(dev_info) < 2:
continue
if_list.append(dev_info[0].strip())
else:
break
ip_list = []
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for eth in if_list:
try:
inet = fcntl.ioctl(s.fileno(), 0x8915,
struct.pack('256s', eth[:15]))
ip = socket.inet_ntoa(inet[20:24])
except Exception, e:
continue
ip_list.append(ip)
def handle_connection(self, client_socket):
try:
data = client_socket.recv(1024)
addrtype = ord(data[0])
if addrtype == 1:
remote_ip = socket.inet_ntoa(data[1:5])
remote_port = struct.unpack('>H', data[5:7])[0]
remote_addr = (remote_ip, remote_port)
elif addrtype == 3:
domain_length = ord(data[1])
remote_domain = data[2:2+domain_length]
remote_port = struct.unpack(
'>H', data[2+domain_length:4+domain_length])[0]
remote_addr = (remote_domain, remote_port)
remote_socket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM, socket.SOL_TCP)
remote_socket.connect(remote_addr)
gevent.spawn(self.handle_client_connection, client_socket,
remote_socket)
gevent.spawn(self.handle_remote_connection, remote_socket,
client_socket)
except socket.error as error:
print error
return
def socks5_connect(sock, target, rdns=True):
stream = sock.makefile()
# connect request
try: reqaddr = "\x01" + socket.inet_aton(target[0])
except socket.error:
if rdns: reqaddr = '\x03' + fmt_string(target[0])
else: reqaddr = "\x01" + socket.inet_aton(socket.gethostbyname(target[0]))
s = "\x05\x01\x00" + reqaddr + struct.pack(">H", target[1])
stream.write(s)
stream.flush()
# connect response
resp = stream.read(4)
if not resp: raise EOFError()
if resp[0] != "\x05": raise GeneralProxyError(1)
if resp[1] != "\x00":
if ord(resp[1]) <= 8: raise Socks5Error(ord(resp[1]))
else: raise Socks5Error(9)
if resp[3] == "\x03": boundaddr = stream.read(stream.read(1))
elif resp[3] == "\x01": boundaddr = socket.inet_ntoa(stream.read(4))
else: raise GeneralProxyError(1)
boundport = struct.unpack(">H", stream.read(2))[0]
logger.debug('socks connected with %s:%s' % target)
return boundaddr, boundport
def _negotiate_SOCKS4(self, dest_addr, dest_port):
"""
Negotiates a connection through a SOCKS4 server.
"""
proxy_type, addr, port, rdns, username, password = self.proxy
writer = self.makefile("wb")
reader = self.makefile("rb", 0) # buffering=0 renamed in Python 3
try:
# Check if the destination address provided is an IP address
remote_resolve = False
try:
addr_bytes = socket.inet_aton(dest_addr)
except socket.error:
# It's a DNS name. Check where it should be resolved.
if rdns:
addr_bytes = b"\x00\x00\x00\x01"
remote_resolve = True
else:
addr_bytes = socket.inet_aton(
socket.gethostbyname(dest_addr))
# Construct the request packet
writer.write(struct.pack(">BBH", 0x04, 0x01, dest_port))
writer.write(addr_bytes)
# The username parameter is considered userid for SOCKS4
if username:
writer.write(username)
writer.write(b"\x00")
# DNS name if remote resolving is required
# NOTE: This is actually an extension to the SOCKS4 protocol
# called SOCKS4A and may not be supported in all cases.
if remote_resolve:
writer.write(dest_addr.encode('idna') + b"\x00")
writer.flush()
# Get the response from the server
resp = self._readall(reader, 8)
if resp[0:1] != b"\x00":
# Bad data
raise GeneralProxyError(
"SOCKS4 proxy server sent invalid data")
status = ord(resp[1:2])
if status != 0x5A:
# Connection failed: server returned an error
error = SOCKS4_ERRORS.get(status, "Unknown error")
raise SOCKS4Error("{0:#04x}: {1}".format(status, error))
# Get the bound address/port
self.proxy_sockname = (socket.inet_ntoa(resp[4:]),
struct.unpack(">H", resp[2:4])[0])
if remote_resolve:
self.proxy_peername = socket.inet_ntoa(addr_bytes), dest_port
else:
self.proxy_peername = dest_addr, dest_port
finally:
reader.close()
writer.close()
def save(self, stream):
r = []
for mask, addrs in self.nets.iteritems():
r.extend([(addr, mask) for addr in list(addrs)])
for addr, mask in sorted(r, key=lambda x: x[0]):
stream.write('%s %s\n' % (socket.inet_ntoa(addr), socket.inet_ntoa(mask)))
def handle(self, source, address):
'''
1. parse browser socks5 message
2. establishes WebSocket connection to a remote server
3. encrypt data using RC4
4. forward with both the local and remote server
'''
log('New connection from %s:%s' % address)
log('greenlet is %r', gevent.getcurrent())
rfile = source.makefile('rb', -1)
try:
recvcount = source.recv(262)
log("recv count: %r: %r " % (recvcount, type(recvcount)))
source.send(b'\x05\x00')
wsdata = ''
data = rfile.read(4)
log('second pack %r: %r' % (type(data), data))
cmd = ord(data[1]) # CMD
addrtype = ord(data[3]) # ADDR type 0x01 Ipv4 address
wsdata = data[3] # append type of address
if addrtype == 1: # IPv4
addrStr = rfile.read(4)
addr = socket.inet_ntoa(addrStr)
wsdata += addrStr
elif addrtype == 3: # Domain name
domainlen = ord(rfile.read(1)[0])
domain = rfile.read(domainlen)
log('domain len and name: %d %s' % (domainlen, domain))
# addr = handle_dns(domain)
addr = socket.inet_ntoa('\x00\x00\x00\x00') # 16777343
wsdata += chr(domainlen)
wsdata += domain
portstr = rfile.read(2)
port = struct.unpack('>H', portstr)
wsdata += portstr # append port
if cmd == 1:
reply = b"\x05\x00\x00\x01" + socket.inet_aton(
addr) + struct.pack(">H", port[0])
log("send replay %r" % reply)
source.send(reply)
log('Begin data, %s:%s' % (addr, port[0]))
ws = WebSocketClient(self.remotehost, protocols=['binary'])
try:
# gevent.monkey 阻塞
ws.connect()
log("connect remote websocket server!")
log('send data %r:%r:%r' %
(wsdata, type(wsdata), len(wsdata)))
encryptor = RC4(self.key)
generator = encryptor.encrypter()
out = ''
for wc in wsdata:
out += chr((ord(wc) ^ generator.next()))
# send socks5 message
ws.send(out, True)
l1 = gevent.spawn(self.forward, source, ws, generator)
l2 = gevent.spawn(self.incoming, ws, source)
gevent.joinall([l1, l2])
except socket.error as e:
log('Conn refused, %s:%s:%s' % (addr, port[0], e.message))
# Connection refused
reply = b'\x05\x05\x00\x01\x00\x00\x00\x00\x00\x00'
source.send(reply)
raise e
finally:
log('close websocket: ---------------------------')
ws.close()
else:
log('Unsupported cmd: %r' % cmd)
reply = b"\x05\0x07\0x00\0x01"
source.send(reply)
except socket.error, (value, message):
log('socks_handle socket error, %s' % (message))
def get_data32_addr(raw_data):
global data
data = raw_data[4:]
#return socket.ntohl(struct.unpack('!L',raw_data[0:4])[0])
return socket.inet_ntoa(raw_data[0:4]) #struct.pack('!L',raw_data[0:4]))
def int_to_ip(self, int_ip):
return socket.inet_ntoa(struct.pack('I', socket.htonl(int_ip)))
def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
self.server_address = socket.inet_ntoa(info.address)
self.port = info.port
log.debug('Service %s added, service info: %s' % (name, info))
def int2ip(addr):
return socket.inet_ntoa(struct.pack("!I", addr))
def get_data32_addr(self):
raw_data = self.data
self.data = raw_data[4:]
return socket.inet_ntoa(raw_data[0:4]) #struct.pack('!L',raw_data[0:4]))
def save(self, stream):
r = []
for mask, addrs in self.nets.iteritems():
r.extend([(addr, mask) for addr in list(addrs)])
for addr, mask in sorted(r, key=lambda x: x[0]):
stream.write('%s %s\n' % (socket.inet_ntoa(addr), socket.inet_ntoa(mask)))
def get_ip(ifname):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(s.fileno(), 0x8915, pack('256s', ifname[:15]))[20:24])
