def accept_phase(self, ip, port, nonce):
# package and encrypt data
response = marshal.dumps((nonce, self.ip, self.gui_port))
cipher = AnonCrypto.sign_with_key(self.privKey, response)
# respond with ((ip, port), encrypted_data)
AnonNet.send_to_addr(ip, int(port), marshal.dumps(("accept", cipher)))
def accept_phase(self, ip, port, nonce):
# package and encrypt data
response = marshal.dumps((nonce,self.ip,self.gui_port))
cipher = AnonCrypto.sign_with_key(self.privKey, response)
# respond with ((ip, port), encrypted_data)
AnonNet.send_to_addr(ip, int(port), marshal.dumps(("accept", cipher)))
def recv_interest_voucher(self, data):
msg, key = marshal.loads(data)
(nonce, leader_ip, leader_gui_port, leader_com_port) = marshal.loads(msg)
self.DEBUG("Start round voucher from %s:%s, communicating at port %s" % (leader_ip, leader_gui_port, leader_com_port))
# get the path to the file you want to share
self.emit(SIGNAL("getSharedFilename()"))
verified = self.verify(leader_ip, leader_gui_port, data)
""" generate temporary keys for this round so leader can aggregate """
self.gen_temp_keys()
temp1_str = AnonCrypto.pub_key_to_str(self.pubgenkey1)
temp2_str = AnonCrypto.pub_key_to_str(self.pubgenkey2)
""" default to random file of 128 bytes if you don't have anything to share """
if verified:
if os.path.exists(self.shared_filename):
self.DEBUG("You are sharing file %s" % (self.shared_filename))
else:
self.DEBUG("Not a valid file path, continuing without sharing...")
# respond with your interest
self.DEBUG("Verified leader, participating as %s:%s at port %s" % (self.ip, self.gui_port, self.com_port))
response = marshal.dumps((nonce,self.ip,self.gui_port,self.com_port,temp1_str,temp2_str))
cipher = AnonCrypto.sign_with_key(self.privKey, response)
AnonNet.send_to_addr(leader_ip, int(leader_gui_port), marshal.dumps(("interested", cipher)))
else:
self.DEBUG("Unkown leader, opting out...")
def recv_interest_voucher(self, data):
msg, key = marshal.loads(data)
(nonce, leader_ip, leader_gui_port, leader_com_port) = marshal.loads(msg)
self.DEBUG(
"Start round voucher from %s:%s, communicating at port %s" % (leader_ip, leader_gui_port, leader_com_port)
)
# get the path to the file you want to share
self.emit(SIGNAL("getSharedFilename()"))
verified = self.verify(leader_ip, leader_gui_port, data)
""" generate temporary keys for this round so leader can aggregate """
self.gen_temp_keys()
temp1_str = AnonCrypto.pub_key_to_str(self.pubgenkey1)
temp2_str = AnonCrypto.pub_key_to_str(self.pubgenkey2)
""" default to random file of 128 bytes if you don't have anything to share """
if verified:
if os.path.exists(self.shared_filename):
self.DEBUG("You are sharing file %s" % (self.shared_filename))
else:
self.DEBUG("Not a valid file path, continuing without sharing...")
# respond with your interest
self.DEBUG("Verified leader, participating as %s:%s at port %s" % (self.ip, self.gui_port, self.com_port))
response = marshal.dumps((nonce, self.ip, self.gui_port, self.com_port, temp1_str, temp2_str))
cipher = AnonCrypto.sign_with_key(self.privKey, response)
AnonNet.send_to_addr(leader_ip, int(leader_gui_port), marshal.dumps(("interested", cipher)))
else:
self.DEBUG("Unkown leader, opting out...")
def prepare_round(self):
# can't start round without 3 or more peers
if len(self.participants) < 3:
self.DEBUG("Not enough peers to start round!")
return
prepare_voucher = marshal.dumps(
(int(PREPARE_WAIT), int(1), copy.copy(self.participants), self.ip, self.gui_port, self.com_port)
)
cipher = AnonCrypto.sign_with_key(self.privKey, prepare_voucher)
for index, participant in enumerate(self.participants):
down_index = (index - 1) % len(self.participants)
up_index = (index + 1) % len(self.participants)
if (self.ip, self.gui_port, self.com_port) != (participant[1], participant[2], participant[3]):
AnonNet.send_to_addr(
participant[1],
participant[2],
marshal.dumps(("prepare:%s:%s:%s" % (index, down_index, up_index), cipher)),
)
self.DEBUG(
"Sending prepare to peer %s:%s at port %s" % (participant[1], participant[2], participant[3])
)
# after informing the participants, create your node
dn_idx = -1 % len(self.participants)
up_idx = 1
self.start_node(dn_idx, up_idx, self.participants, 0)
# start round after PREPARE_WAIT minutes
DelayTimer(PREPARE_WAIT, self.run_protocol).start()
def broadcast_to_all_nodes(self, msg, signed=True):
if not self.am_leader():
raise RuntimeError, 'Only leader can broadcast'
if signed: outmsg = AnonCrypto.sign(self.id, self.key1, msg)
else: outmsg = msg
AnonNet.broadcast_using(self.sockets, AnonNet.send_to_socket, outmsg)
def broadcast_to_all_nodes(self, msg, signed = True): if not self.am_leader(): raise RuntimeError, 'Only leader can broadcast' if signed: outmsg = AnonCrypto.sign(self.id, self.key1, msg) else: outmsg = msg AnonNet.broadcast_using(self.sockets, AnonNet.send_to_socket, outmsg)
def broadcast_to_all_peers(self, voucher):
for node in self.nodes:
ip, port = node[0], node[1]
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((ip, int(port)))
AnonNet.send_to_socket(sock, voucher)
sock.close()
except:
self.DEBUG("peer %s:%s not available" % (ip, port))
def broadcast_to_all_peers(self, voucher):
for node in self.nodes:
ip, port = node[0], node[1]
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((ip,int(port)))
AnonNet.send_to_socket(sock, voucher)
sock.close()
except:
self.DEBUG("peer %s:%s not available" % (ip, port))
def invite_phase(self, ip, port, pubkey):
# create nonce, # peers, vector containing (ip, port, pubkey) of all peers
nonce = 1
num_peers = len(self.nodes) + 1
peer_vector = [(self.ip, self.gui_port, self.public_key_string())]
for node in self.nodes:
hashkey = self.hash_peer(node[0], node[1])
if hashkey != self.hashkey:
peer_vector.append(node)
# package the text up into (nonce, N, [array of peer data])
invite = marshal.dumps((nonce, num_peers, peer_vector))
# sign it
cipher = AnonCrypto.sign_with_key(self.privKey, invite)
# send to invitee packaged with who it's coming from ((ip:port), signed(text))
AnonNet.send_to_addr(ip, int(port), marshal.dumps(("invite", cipher)))
def invite_phase(self, ip, port, pubkey):
# create nonce, # peers, vector containing (ip, port, pubkey) of all peers
nonce = 1
num_peers = len(self.nodes) + 1
peer_vector = [(self.ip,self.gui_port,self.public_key_string())]
for node in self.nodes:
hashkey = self.hash_peer(node[0], node[1])
if hashkey != self.hashkey:
peer_vector.append(node)
# package the text up into (nonce, N, [array of peer data])
invite = marshal.dumps((nonce,num_peers,peer_vector))
# sign it
cipher = AnonCrypto.sign_with_key(self.privKey, invite)
# send to invitee packaged with who it's coming from ((ip:port), signed(text))
AnonNet.send_to_addr(ip, int(port), marshal.dumps(("invite", cipher)))
def setup_sockets(self):
if self.am_leader():
self.debug("Opening leader sockets")
self.sockets = AnonNet.new_server_socket_set(self.ip, self.port, self.n_nodes - 1)
data = self.recv_from_all(False)
newsockets = [None] * (self.n_nodes - 1)
for i in xrange(0, self.n_nodes - 1):
s_id = marshal.loads(data[i])
self.debug(s_id)
newsockets[s_id - 1] = self.sockets[i]
self.sockets = newsockets
self.debug("Opened sockets to all nodes")
else:
l_ip, l_port = self.leader_addr
self.debug("Opening client socket to leader")
self.leader_socket = AnonNet.new_client_sock(l_ip, l_port)
self.sockets = [self.leader_socket]
self.send_to_leader(marshal.dumps(self.id), False)
self.debug("Opened client socket to leader")
def setup_sockets(self):
if self.am_leader():
self.debug("Opening leader sockets")
self.sockets = AnonNet.new_server_socket_set(self.ip, self.port, self.n_nodes - 1)
data = self.recv_from_all(False)
newsockets = [None] * (self.n_nodes - 1)
for i in xrange(0, self.n_nodes - 1):
s_id = marshal.loads(data[i])
self.debug(s_id)
newsockets[s_id - 1] = self.sockets[i]
self.sockets = newsockets
self.debug("Opened sockets to all nodes")
else:
l_ip, l_port = self.leader_addr
self.debug("Opening client socket to leader")
self.leader_socket = AnonNet.new_client_sock(l_ip, l_port)
self.sockets = [self.leader_socket]
self.send_to_leader(marshal.dumps(self.id), False)
self.debug("Opened client socket to leader")
def recv_from_all(self, verify=True):
if not self.am_leader():
raise RuntimeError, "Only leader can broadcast"
indata = AnonNet.recv_from_n(self.sockets)
if verify:
outdata = []
for d in indata:
outdata.append(AnonCrypto.verify(self.pub_keys, d))
return outdata
else:
return indata
def recv_from_all(self, verify=True):
if not self.am_leader():
raise RuntimeError, 'Only leader can broadcast'
indata = AnonNet.recv_from_n(self.sockets)
if verify:
outdata = []
for d in indata:
outdata.append(AnonCrypto.verify(self.pub_keys, d))
return outdata
else:
return indata
def prepare_round(self):
# can't start round without 3 or more peers
if len(self.participants) < 3:
self.DEBUG("Not enough peers to start round!")
return
prepare_voucher = marshal.dumps((int(PREPARE_WAIT),int(1),copy.copy(self.participants), self.ip, self.gui_port, self.com_port))
cipher = AnonCrypto.sign_with_key(self.privKey, prepare_voucher)
for index, participant in enumerate(self.participants):
down_index = (index - 1) % len(self.participants)
up_index = (index + 1) % len(self.participants)
if (self.ip, self.gui_port, self.com_port) != (participant[1], participant[2], participant[3]):
AnonNet.send_to_addr(participant[1], participant[2], \
marshal.dumps(("prepare:%s:%s:%s"%(index, down_index, up_index),cipher)))
self.DEBUG("Sending prepare to peer %s:%s at port %s" % (participant[1], participant[2], participant[3]))
# after informing the participants, create your node
dn_idx = -1 % len(self.participants)
up_idx = 1
self.start_node(dn_idx, up_idx, self.participants, 0)
# start round after PREPARE_WAIT minutes
DelayTimer(PREPARE_WAIT, self.run_protocol).start()
def handle(self):
data = AnonNet.recv_from_socket(self.request)
(function, msg) = marshal.loads(data)
if function == "invite":
self.parent.recv_invite(msg)
elif function == "accept":
self.parent.inform_phase(msg)
elif function == "inform":
self.parent.recv_voucher(msg)
elif function == "quit":
self.parent.recv_quit_voucher(msg)
elif function == "expel":
self.parent.recv_expel_voucher(msg)
elif function == "interested?":
self.parent.recv_interest_voucher(msg)
elif function == "interested":
self.parent.recv_interested(msg)
elif function[:7] == "prepare":
self.parent.recv_prepare(msg, function)
else:
self.parent.emit(SIGNAL("messageReceived(QString)"), QString("not sure what to do with: " + str(function)))
def handle(self):
data = AnonNet.recv_from_socket(self.request)
(function, msg) = marshal.loads(data)
if function == "invite":
self.parent.recv_invite(msg)
elif function == "accept":
self.parent.inform_phase(msg)
elif function == "inform":
self.parent.recv_voucher(msg)
elif function == "quit":
self.parent.recv_quit_voucher(msg)
elif function == "expel":
self.parent.recv_expel_voucher(msg)
elif function == "interested?":
self.parent.recv_interest_voucher(msg)
elif function == "interested":
self.parent.recv_interested(msg)
elif function[:7] == "prepare":
self.parent.recv_prepare(msg, function)
else:
self.parent.emit(SIGNAL("messageReceived(QString)"), QString("not sure what to do with: " + str(function)))
def send_to_addr(self, ip, port, msg, signed=True):
if signed: outmsg = AnonCrypto.sign(self.id, self.key1, msg)
else: outmsg = msg
AnonNet.send_to_addr(ip, port, outmsg)
def send_to_addr(self, ip, port, msg, signed = True): if signed: outmsg = AnonCrypto.sign(self.id, self.key1, msg) else: outmsg = msg AnonNet.send_to_addr(ip, port, outmsg)
def recv_from_socket(self, sock, verify=True):
d = AnonNet.recv_from_socket(sock)
if verify:
d = AnonCrypto.verify(self.pub_keys, d)
return d
def recv_once(self, verify=True):
d = AnonNet.recv_once(self.ip, self.port)
if verify:
d = AnonCrypto.verify(self.pub_keys, d)
return d
def run_phase3(self):
self.advance_phase()
self.info("Starting data transmission phase")
self.responses = []
self.go_flag = False
"""
We put all of the pseudo-random strings in a tar file
for transmission.
"""
handle, self.tar_filename = tempfile.mkstemp()
tar = tarfile.open(name=self.tar_filename, mode="w") # Create new archive
# dereference = True)
""" For each transmission slot... """
for i in xrange(0, self.n_nodes):
debug("Processing data for msg slot %d" % i)
slot_data = self.msg_data[i]
msg_len = slot_data[0]
enc_seeds = slot_data[1]
hashes = slot_data[2]
if enc_seeds[self.id] == self.my_seed:
""" If this is my seed, use the cheating message. """
self.go_flag = True
self.responses.append(self.dfilename)
tar.add(self.cip_file, "%d" % (self.id))
else:
""" If this is not my msg slot, decrypt seed assigned to me. """
seed = AnonCrypto.decrypt_with_rsa(self.key1, enc_seeds[self.id])
h_val, fname = self.generate_prng_file(seed, msg_len)
if h_val != hashes[self.id]:
for q in xrange(0, len(hashes)):
self.debug("> %d - %s" % (q, hashes[q]))
raise RuntimeError, "Mismatched hash values"
"""
Label each file in the tar with this node's id so that nodes can
match the files to the message hashes.
"""
tar.add(fname, "%d" % (self.id))
tar.close()
if not self.go_flag:
raise RuntimeError, "My ciphertext is missing"
if self.am_leader():
fnames = AnonNet.recv_file_from_n(self.sockets)
fnames.append(self.tar_filename)
self.message_tar = self.generate_msg_tar(fnames)
""" Broadcast final messages """
self.debug("Broadcasting msg tar")
self.broadcast_file_to_all_nodes(self.message_tar)
self.debug("Sent msg tar")
else:
AnonNet.send_file_to_sock(self.leader_socket, self.tar_filename)
self.debug("Waiting for msg tar")
self.message_tar = AnonNet.recv_file_from_sock(self.leader_socket)
self.debug("Got for msg tar")
def broadcast_file_to_all_nodes(self, filename):
AnonNet.broadcast_using(self.sockets, AnonNet.send_file_to_sock, filename)
def send_to_socket(self, sock, msg, signed=True):
if signed: outmsg = AnonCrypto.sign(self.id, self.key1, msg)
else: outmsg = msg
AnonNet.send_to_socket(sock, outmsg)
def send_to_socket(self, sock, msg, signed=True):
if signed:
outmsg = AnonCrypto.sign(self.id, self.key1, msg)
else:
outmsg = msg
AnonNet.send_to_socket(sock, outmsg)
def recv_from_socket(self, sock, verify=True):
d = AnonNet.recv_from_socket(sock)
if verify:
d = AnonCrypto.verify(self.pub_keys, d)
return d
def broadcast_file_to_all_nodes(self, filename): AnonNet.broadcast_using(self.sockets, AnonNet.send_file_to_sock, filename)
def recv_once(self, verify=True):
d = AnonNet.recv_once(self.ip, self.port)
if verify:
d = AnonCrypto.verify(self.pub_keys, d)
return d
def run_phase3(self):
self.advance_phase()
self.info("Starting data transmission phase")
self.responses = []
self.go_flag = False
"""
We put all of the pseudo-random strings in a tar file
for transmission.
"""
handle, self.tar_filename = tempfile.mkstemp()
tar = tarfile.open(
name = self.tar_filename,
mode = 'w') # Create new archive
#dereference = True)
""" For each transmission slot... """
for i in xrange(0, self.n_nodes):
debug("Processing data for msg slot %d" % i)
slot_data = self.msg_data[i]
msg_len = slot_data[0]
enc_seeds = slot_data[1]
hashes = slot_data[2]
if enc_seeds[self.id] == self.my_seed:
""" If this is my seed, use the cheating message. """
self.go_flag = True
self.responses.append(self.dfilename)
tar.add(self.cip_file, "%d" % (self.id))
else:
""" If this is not my msg slot, decrypt seed assigned to me. """
seed = AnonCrypto.decrypt_with_rsa(self.key1, enc_seeds[self.id])
h_val, fname = self.generate_prng_file(seed, msg_len)
if h_val != hashes[self.id]:
for q in xrange(0, len(hashes)):
self.debug("> %d - %s" % (q, hashes[q]))
raise RuntimeError, 'Mismatched hash values'
"""
Label each file in the tar with this node's id so that nodes can
match the files to the message hashes.
"""
tar.add(fname, "%d" % (self.id))
tar.close()
if not self.go_flag:
raise RuntimeError, 'My ciphertext is missing'
if self.am_leader():
fnames = AnonNet.recv_file_from_n(self.sockets)
fnames.append(self.tar_filename)
self.message_tar = self.generate_msg_tar(fnames)
""" Broadcast final messages """
self.debug("Broadcasting msg tar")
self.broadcast_file_to_all_nodes(self.message_tar)
self.debug("Sent msg tar")
else:
AnonNet.send_file_to_sock(self.leader_socket, self.tar_filename)
self.debug("Waiting for msg tar")
self.message_tar = AnonNet.recv_file_from_sock(self.leader_socket)
self.debug("Got for msg tar")
