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 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 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 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")