def setup_local_encryption(self):
if self.local_recvall(PACKET_INIT_LENGTH) != PACKET_INIT:
raise ValueError("packet != PACKET_INIT")
generator = self.generator
prime = self.prime
prime_bytes = int_to_bytes(prime)
self.log("local encryption: generator: %s prime: %s"%(generator, prime))
server_private_key = get_private_key()
server_public_key = get_public_key(generator, server_private_key, prime)
server_public_key_bytes = int_to_bytes(server_public_key)
self.log("local encryption: server_private_key: %s, server_public_key %s"%(
server_private_key, server_public_key,
))
packet_key_exchange = "".join((
pack_unsigned_int(0),
pack_unsigned_int(len(str(generator)))+str(generator),
pack_unsigned_int(len(prime_bytes))+prime_bytes,
pack_unsigned_int(len(server_public_key_bytes))+server_public_key_bytes,
))
self.local_sendall(packet_key_exchange)
client_public_key_length = unpack_unsigned_int(self.local_recvall(4))
client_public_key = bytes_to_int(self.local_recvall(client_public_key_length))
share_key = get_share_key_bytes(client_public_key, server_private_key, prime)
rijndael_key = get_rijndael_key(share_key)
self.log("local encryption: share_key: %s, rijndael_key: %s"%(
share_key, rijndael_key.encode("hex"),
))
self.local_rijndael_obj = rijndael.rijndael(rijndael_key, block_size=16)
self.local_rijndael_obj.lock = threading.RLock()
def setup_remote_encryption(self):
self.remote_sendall(PACKET_INIT)
head = self.remote_recvall(4)
generator_length = unpack_unsigned_int(self.remote_recvall(4))
generator = int(self.remote_recvall(generator_length))
prime_length = unpack_unsigned_int(self.remote_recvall(4))
prime = bytes_to_int(self.remote_recvall(prime_length))
server_public_key_length = unpack_unsigned_int(self.remote_recvall(4))
server_public_key = bytes_to_int(self.remote_recvall(prime_length))
self.log("remote encryption: generator: %s, prime: %s, server_public_key: %s"%(
generator, prime, server_public_key,
))
client_private_key = get_private_key()
client_public_key = get_public_key(generator, client_private_key, prime)
client_public_key_bytes = int_to_bytes(client_public_key)
self.remote_sendall(pack_unsigned_int(len(client_public_key_bytes)))
self.remote_sendall(client_public_key_bytes)
self.log("remote encryption: client_private_key: %s, client_public_key: %s"%(
client_private_key, client_public_key,
))
share_key = get_share_key_bytes(server_public_key, client_private_key, prime)
rijndael_key = get_rijndael_key(share_key)
self.log("remote encryption: share_key: %s, rijndael_key: %s"%(
share_key, rijndael_key.encode("hex"),
))
self.remote_rijndael_obj = rijndael.rijndael(rijndael_key, block_size=16)
self.remote_rijndael_obj.lock = threading.RLock()
self.generator = generator
self.prime = prime