def encryptForDB(self, msg, key, session_name):
getGlobalSphinxParams().group
g_x, iv, ciphertext, tag = self.encryptor.encrypt_aes_gcm(
msg, key, session_name)
e_message = {
'pk': g_x.export(),
'iv': iv,
'text': ciphertext,
'tag': tag
}
json_msg = dumps(e_message)
return (json_msg)
def test_listener():
portEnum = PortEnumDebug
thing = Client({'ip': '0.0.0.0', 'port': portEnum.broker.value})
group = getGlobalSphinxParams().group.G
dummy_key = group.generator().export()
SecurityParameters.NUMBER_OF_REQUESTS = 3
thing.db_list = [(0, dummy_key), (1, dummy_key), (2, dummy_key)]
thing.mixnode_list = {
'0.0.0.0': dummy_key,
'0.0.0.0': dummy_key,
'0.0.0.0': dummy_key
}
msgCreator = MessageCreator(thing)
requested_index = 5
record_size = 100
requested_db = 2
messages = msgCreator.generate_messages(requested_index,
requested_db,
record_size,
portEnum,
pir_xor=False)
host = '0.0.0.0'
port = portEnum.mix.value
mix = MixNode(None)
mix.process = MagicMock(return_value=(Relay_flag, None, None, None))
listener = MixNodeListener(host, port, mix, (Lock(), Lock()), port) #
network_sender = NetworkSender()
json, dest = messages[0][0]
network_sender.send_data(json, dest)
asyncore.loop(count=2)
assert (len(mix.mix_pool.getContents()) == 1)
def prepare_forward_message(mixnodes_dict, message, dest, key,
portEnum):
params = getGlobalSphinxParams()
group = params.group.G
use_nodes_forward = rand_subset(mixnodes_dict.keys(),
SecurityParameters.NUMBER_OF_MIXES)
use_nodes_backward = rand_subset(
mixnodes_dict.keys(), SecurityParameters.NUMBER_OF_MIXES)
nodes_routing_forward = list(map(Nenc, use_nodes_forward))
nodes_routing_backward = list(map(Nenc, use_nodes_backward))
pks_chosen_nodes_forward = [
EcPt.from_binary(mixnodes_dict[key], group)
for key in use_nodes_forward
]
pks_chosen_nodes_backward = [
EcPt.from_binary(mixnodes_dict[key], group)
for key in use_nodes_backward
]
surbid, surbkeytuple, nymtuple = create_surb(
params, nodes_routing_backward, pks_chosen_nodes_backward,
self.ip)
self.surbDict[surbid] = {'surbkeytuple': surbkeytuple}
message['nymtuple'] = nymtuple
message = encode(message)
json_msg = self.encryptForDB(message, key, self.session_name)
print(json_msg, len(json_msg))
header, delta = create_forward_message(params,
nodes_routing_forward,
pks_chosen_nodes_forward,
dest, json_msg)
return (header, delta, use_nodes_forward[0], surbid,
use_nodes_backward[-1])
def handle_PIR(self, decrypted_msg, client_pk):
time_queued = time.perf_counter() - self.t_accepted
log_info(">>>>> TIME QUEUED: {}".format(time_queued))
t1 = time.perf_counter()
print("TRYING TO FETCH")
answer = self.dbnode.fetch_answer(decrypted_msg)
print("ANSWER:", answer)
reply = encode(answer)
encrypted_reply = encode(self.dbnode.encrypt(reply, client_pk))
nymtuple = decrypted_msg['nymtuple']
first_node = decode(nymtuple[0])
header, delta = package_surb(getGlobalSphinxParams(), nymtuple,
encrypted_reply)
self.dbnode.get_mixnode_list()
json_data, dest = RequestCreator().post_msg_to_mix(
{
'ip': first_node[1],
'port': self.mixport
}, {
'header': header,
'delta': delta
})
t2 = time.perf_counter()
elapsed_time = (t2 - t1)
log_info("TIME ELAPSED: {}".format(elapsed_time))
self.network_sender.send_data(json_data, dest)
def __init__(self, public_key_server):
self.broker_comm = BrokerCommunicator()
self.public_key_server = public_key_server
self.db_list = None
self.mixnode_list = None
self.ip = getPublicIp()
self.encryptor = Encryptor(getGlobalSphinxParams().group)
self.surbDict = {}
def create_db_destination(self, destination, port):
try:
destination = self.db_list[destination]
destination = (destination[0], destination[1], port)
key = EcPt.from_binary(destination[1],
getGlobalSphinxParams().group.G)
return (destination, key)
except Exception as e:
raise Exception(
'Requested database not present or named incorrectly. {} not found. Error {}'
.format(destination, e))
def __init__(self, broker_config):
self.private_key = None
self.public_key = None
self.ip = None
self.params = getGlobalSphinxParams()
self.network_sender = NetworkSender()
self.broker_config = broker_config
self.encryptor = Encryptor(self.params.group)
self.mixnodes_list = None
self.broker_comm = BrokerCommunicator()
self.records = {}
self.loadRecords()
self.decoder = BinaryEncoderDecoder()
def __init__(self, broker_config, pool_size=3):
self.private_key = None
self.public_key = None
self.ip = None
self.params = getGlobalSphinxParams()
self.network_sender = NetworkSender()
self.broker_config = broker_config
self.encryptor = Encryptor(self.params.group)
self.db_list = None
self.broker_comm = BrokerCommunicator()
self.client_cache = {}
self.mix_pool = MixPool(pool_size)
self.client_backlog = set()
def test_generateMessages():
portEnum = PortEnumDebug
thing = Client({'ip': '0.0.0.0', 'port': portEnum.broker.value})
group = getGlobalSphinxParams().group.G
dummy_key = group.generator().export()
SecurityParameters.NUMBER_OF_REQUESTS = 12
thing.db_list = [(0, dummy_key), (1, dummy_key), (2, dummy_key)]
thing.mixnode_list = {'a': dummy_key, 'b': dummy_key, 'c': dummy_key}
msgCreator = MessageCreator(thing)
requested_index = 5
record_size = 100
requested_db = 2
for i in range(0, 20):
random_indexes = msgCreator._generate_random_indexes(5, record_size)
print(random_indexes)
assert (len(random_indexes) == SecurityParameters.NUMBER_OF_REQUESTS -
1)
assert (requested_index not in random_indexes)
messages = msgCreator.generate_messages(requested_index,
requested_db,
record_size,
portEnum,
pir_xor=False)
len_0 = len(messages[0])
for key, value in messages.items():
assert (len(value) == len_0)
messages = msgCreator.generate_messages(requested_index,
requested_db,
record_size,
portEnum,
pir_xor=True)
assert (len(messages) == len(thing.db_list))
first_message = messages[0]
for key, value in messages.items():
assert (len(value) == len(first_message))
def handle_read(self):
data = super().handle_read()
if data:
data = pickle.loads(data)
iv = data["iv"]
text = data["text"]
pk = EcPt.from_binary(data["pk"], getGlobalSphinxParams().group.G)
tag = data["tag"]
decrypted_msg = decode(self.dbnode.decrypt(iv, text, pk, tag))
request_type = decrypted_msg['request_type']
client_pk = decrypted_msg['pk'][2]
if request_type == RequestType.get_db_size.value:
record_size = self.dbnode.getRecordsSize()
reply = encode(record_size)
self.socket.sendall(reply)
elif request_type == RequestType.push_to_db.value:
pir_handler = threading.Thread(target=self.handle_PIR,
args=(
decrypted_msg,
client_pk,
),
name="PIR handler")
pir_handler.daemon = True
pir_handler.start()
def recoverMessage(self, msg, myid):
surbkeytuple = self.surbDict[myid]['surbkeytuple']
index = self.surbDict[myid]['index']
return (index,
decode(receive_surb(getGlobalSphinxParams(), surbkeytuple,
msg)))
