def on_data(self, data):
messages, self.buffer = Message.parse_stream(data)
for message in messages:
if message.msg_type == 'pong':
self.handle_PONG()
elif message.msg_type == 'recv':
self.handle_RECV(message)
def handle_TRANSMISSION(self, data):
""" Send packed data to server """
data_send = Message(self.cir_id, 'data', data).to_bytes()
if self.remote_protocol is not None:
self.remote_protocol.write(data_send)
else:
self.buffer += data_send
def dataReceived(self, data):
messages, _ = Message.parse_stream(data)
for m in messages:
if m.msg_type == 'addr':
self.handle_REQUEST(m)
if m.msg_type == 'data':
self.handle_TRANSMISSION(m)
def send_address(self, addr_to_send):
# use tcp endpoint
remote_factory = RemoteFactory(self)
host, port = self.socks5_factory.circuit_peers.values()[0]
self.cir_id = self.socks5_factory.circuit_peers.keys()[0] # circuit_id
self.buffer = Message(self.cir_id, 'addr', addr_to_send).to_bytes()
reactor.connectTCP(host, port, remote_factory)
logging.info("Connected to {}:{}".format(host, port))
def on_data(self, data):
try:
message, _ = Message.parse_stream(data)
if message.data_type == 'pong':
self.handle_PONG()
except:
logging.debug("receive data from target server, send remote data back to forwarder.")
self.handle_RECV(data)
def handle_TRANSMISSION(self, message):
from_cir_id, msg_type, data = message.cir_id, message.msg_type, message.data
to_cir_id = self.forward_factory.circuit_id[from_cir_id]
data_to_send = Message(to_cir_id, msg_type, data).to_bytes()
if self.remote_protocol is not None:
self.remote_protocol.write(data_to_send)
else:
self.buffer += data_to_send
def handle_REQUEST(self, message):
from_cir_id, msg_type, data = message.cir_id, message.msg_type, message.data
to_cir_id = self.forward_factory.circuit_id[from_cir_id]
host, port = self.forward_factory.circuit_peers[from_cir_id]
logging.debug("connect to {}:{}, to_circuit id is:{}".format(
host, port, to_cir_id))
remote_factory = RemoteFactory(self)
reactor.connectTCP(host, port, remote_factory)
self.buffer = Message(to_cir_id, msg_type, data).to_bytes()
def handle_TRANSMISSION(self, data):
""" Send packed data to server """
# print "send data", repr(data)
data_send = Message(self.cir_id, 'data', data).to_bytes()
# data_send = self.encrypt(self.cir_id, Message(self.cir_id, 'data', data).to_bytes())
if self.remote_protocol is not None:
self.remote_protocol.write(data_send)
else:
self.buffer += data_send
def dataReceived(self, data):
messages, _ = Message.parse_stream(data)
for m in messages:
if self.state == 'REQUEST':
self.handle_REQUEST(m)
self.state = 'TRANSMISSION'
elif self.state == 'TRANSMISSION':
self.handle_TRANSMISSION(m)
def handle_REQUEST(self, message):
from_cir_id, msg_type, data = message.cir_id, message.msg_type, message.data
to_cir_id = self.forward_factory.circuit_id[from_cir_id]
host, port = self.forward_factory.circuit_peers[from_cir_id]
logging.debug("forwarder address {}:{}, {}, Connect to {}:{}, to_circuit id is:{}"
.format(self.host_address.host, self.host_address.port,
self.__class__.__name__, host, port, to_cir_id))
remote_factory = RemoteFactory(self, 'f')
reactor.connectTCP(host, port, remote_factory)
self.buffer = Message(to_cir_id, msg_type, data).to_bytes()
def dataReceived(self, data):
# parse data here
messages, _ = Message.parse_stream(data)
for m in messages:
msg_type = m.msg_type
if msg_type == 'addr':
self.handle_REMOTEADDR(m)
elif msg_type == 'data':
self.handle_REQUEST(m)
def handle_TRANSMISSION(self, message):
from_cir_id, msg_type, data = message.cir_id, message.msg_type, message.data
# print "to_cir_id", from_cir_id, self.forward_factory.circuit_peers
to_cir_id = self.forward_factory.circuit_id[from_cir_id]
data_to_send = Message(to_cir_id, msg_type, data).to_bytes()
if self.remote_protocol is not None:
logging.debug("sent in forwarder protocol: {}, {} : {}".format(self.host_address, repr(msg_type), repr(data)))
self.remote_protocol.write(data_to_send)
else:
self.buffer += data_to_send
def dataReceived(self, data):
print "data received from forwarder", repr(data)[:50]
# parse data here
messages, _ = Message.parse_stream(data)
for m in messages:
msg_type = m.msg_type
if msg_type == 'addr':
self.handle_REMOTEADDR(m)
elif msg_type == 'data':
self.handle_REQUEST(m)
def send_address(self, addr_to_send):
# use tcp endpoint
remote_factory = RemoteFactory(self, 'c')
circuit = self.socks5_factory.circuit_peers.values()[0]
# print "circuit.hs_session_keys", repr(circuit.hs_session_keys), circuit.hops
host, port = circuit.peer.address
self.cir_id = self.socks5_factory.circuit_peers.keys()[0] # circuit_id
self.buffer = Message(self.cir_id, 'addr', addr_to_send).to_bytes()
reactor.connectTCP(host, port, remote_factory)
logging.info("{}:{}, {}, Connected to {}:{}"
.format(self.host_address.host, self.host_address.port, self.__class__.__name__, host, port))
def dataReceived(self, data):
data_to_parse = self.message_buffer + data
messages, self.message_buffer = Message.parse_stream(data_to_parse)
for m in messages:
msg_type = m.msg_type
if msg_type == 'addr':
self.handle_REMOTEADDR(m)
elif msg_type == 'data':
self.handle_REQUEST(m)
elif msg_type == 'ping':
self.handle_PING(m)
def dataReceived(self, data):
data_to_parse = self.message_buffer + data
messages, self.message_buffer = Message.parse_stream(data_to_parse)
for m in messages:
if m.msg_type == 'ping':
self.handle_PING()
elif m.msg_type == 'addr':
self.handle_REQUEST(m)
elif m.msg_type == 'data':
self.handle_TRANSMISSION(m)
def dataReceived(self, data):
data_to_parse = self.message_buffer + data
messages, self.message_buffer = Message.parse_stream(data_to_parse)
for m in messages:
logging.debug("forwarder messages!!!!!{} : {}".format(m.msg_type, repr(m.data)))
if m.msg_type == 'ping':
self.handle_PING()
elif m.msg_type == 'addr':
self.handle_REQUEST(m)
elif m.msg_type == 'data':
self.handle_TRANSMISSION(m)
def handle_REQUEST(self, message):
from_cir_id = message.cir_id
to_cir_id = self.forward_factory.circuit_id[from_cir_id]
idx, msg_type, data = message.idx, message.msg_type, message.data
# build TCP connection with server
remote_factory = RemoteFactory(self)
host, port = self.forward_factory.circuit_peers[from_cir_id]
print "connected to ", host, port
reactor.connectTCP(host, port, remote_factory)
data_to_send = Message(to_cir_id, msg_type, data).to_bytes()
if self.remote_protocol is not None:
self.remote_protocol.write(data_to_send)
else:
self.buffer += data_to_send
def send_address(self, addr_to_send):
# use tcp endpoint
remote_factory = RemoteFactory(self, 'c')
if not self.socks5_factory.circuit_peers:
return
# random choose forwarder's addresses
circuit_item = random.choice(self.socks5_factory.circuit_peers.items())
circuit = circuit_item[1]
host, port = circuit.peer.address
# print "circuit_item", circuit_item, host, port
self.cir_id = circuit_item[0] # circuit_id
self.buffer = Message(self.cir_id, 'addr', addr_to_send).to_bytes()
reactor.connectTCP(host, port, remote_factory)
logging.info("{}:{}, {}, Connected to {}:{}".format(
self.host_address.host, self.host_address.port,
self.__class__.__name__, host, port))
def send_address(self, addr_to_send):
if not self.socks5_factory.circuit_peers:
return
self.remote_factory = RemoteFactory(self, 'c')
circuit_item = random.choice(self.socks5_factory.circuit_peers.items())
circuit = circuit_item[1]
# print "circuit.hs_session_keys", repr(circuit.hs_session_keys), circuit.hops
host, port = circuit.peer.address
key = circuit.hops
print "keyyy", [i.session_keys for i in key]
self.cir_id = circuit_item[0]
self.buffer = Message(self.cir_id, 'addr', addr_to_send).to_bytes()
self.encrypt(self.cir_id, self.buffer)
reactor.connectTCP(host, port, self.remote_factory)
logging.info("{}:{}, {}, Connected to {}:{}".format(
self.host_address.host, self.host_address.port,
self.__class__.__name__, host, port))
self.socks5_factory.remote_factories[self] = self.remote_factory
def handle_RECV(self, data):
data_to_send = Message(0, 'recv', data).to_bytes()
self.remote_factory.local_protocol.write(data_to_send)
def send_ping(self):
ping = Message(0, 'ping', '').to_bytes()
self.send_time = time.time()
self.write(ping)
def handle_PING(self, message):
pong = Message(0, 'pong', '').to_bytes()
self.write(pong)
def handle_PING(self):
# send pong back to client
pong = Message(0, 'pong', '').to_bytes()
self.write(pong)
def dataReceived(self, data):
messages, _ = Message.parse_stream(data)
for m in messages:
self.handle_REQUEST(m)
