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)