class Connection(object):
def __init__(self, server_ip, server_port, private_key, server_pubkey=None):
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect((server_ip, server_port))
if server_pubkey:
self._crypt = Crypt(private_key, server_pubkey)
else:
self._crypt = Crypt(private_key, get_server_public_key())
self._sendPublicKey(private_key)
def __del__(self):
self.close()
def _sendPublicKey(self, private_key):
self._socket.sendall(private_key.publickey().exportKey(format='DER'))
def send(self, data):
data = self._crypt.sign_and_encrypt(data)
self._socket.sendall(data)
def receive(self, size=1024):
data = self._crypt.decrypt_and_auth(self._socket.recv(size))
return data
def close(self):
if not self._socket is None:
self.send(MSG_TYPES.CLOSE)
self._socket.close()
self._socket = None
def get_route(self):
route = []
# print self.routers
for r in self.routers[:3]:
ip, port, pk = r
c = Crypt(public_key=pk, private_key=self.private_key)
sid = urandom(8)
sym_key = urandom(16)
enc_pkt = c.sign_and_encrypt("ESTB" + self.rid + sid + sym_key)
route.append((enc_pkt, ip, port, pk, sid, sym_key))
return route
def _test_connection(self, request):
router_id = request
to_router_id = self._determine_test_router(router_id)
if to_router_id is None:
self._send("NONE")
return
to_router = self.server.tor_routers[to_router_id]
c = Crypt(public_key=self.server.private_key.publickey(),
private_key=self.server.private_key)
now = now_as_str()
payload = c.sign_and_encrypt(now + router_id + to_router_id)
self._send(
struct.pack("!4sI", socket.inet_aton(to_router["ip_addr"]),
to_router["daemon_port"]) + payload)
def _create_route(self):
route = ""
shuffled_keys = self.server.tor_routers.keys()
shuffle(shuffled_keys)
for i in range(min(len(shuffled_keys), MAX_PATH_LENGTH)):
details = self.server.tor_routers[shuffled_keys[i]]
c = Crypt(public_key=RSA.import_key(details["pub_key"]),
private_key=self.server.private_key)
sid = get_random_bytes(8)
sym_key = get_random_bytes(16)
enc_pkt = c.sign_and_encrypt("ESTB" + self.server.rid + sid +
sym_key)
route += struct.pack(ROUTE_STRUCT_FMT, enc_pkt,
socket.inet_aton(details["ip_addr"]),
details["port"], details["pub_key"], sid,
sym_key)
self._send(route)
def append_current_time(payload, private_key, server_pubey=None):
if server_pubey:
c = Crypt(public_key=server_pubey, private_key=private_key)
else:
c = Crypt(public_key=get_server_public_key(), private_key=private_key)
return payload + c.sign_and_encrypt(now_as_str())
cid = circ.cid.encode("hex")
if circ.is_pf:
self.cur.execute("DELETE FROM pfs WHERE id = (?);", (cid, ))
else:
self.cur.execute("DELETE FROM circuits WHERE id = (?);", (cid, ))
cdb_logger.debug("Removed circuit " + repr(circ.name))
if __name__ == "__main__":
cid = urandom(8)
symkey = Crypt().generate_key()
k1 = Crypt().generate_key()
k2 = Crypt().generate_key()
c_client = Crypt(public_key=k1.publickey(), private_key=k2)
c_router = Crypt(public_key=k2.publickey(), private_key=k1)
pkt = c_client.sign_and_encrypt("CLNT" + cid + symkey)
data, hash = c_router.decrypt(pkt)
cd = CircuitDatabase(db_path="circuitdb_1234.db")
c = ClientCircuit(cid, cid, c_router)
cd.add(c)
# cd.get(data, hash, c_router)
# cd.remove(c)
# cd.remove(c)
# try:
# cd.get('ABCD')
# print "BAD"
# except:
# print "GOOD"
# cd.add(c)
