From cfb1ed84d2f4c0b5accf94016d78e7601c0d0bd1 Mon Sep 17 00:00:00 2001 From: Mark Qvist Date: Wed, 4 Apr 2018 10:35:21 +0200 Subject: [PATCH] Cleanup and echo example --- FPE/Identity.py | 4 --- FPE/Interfaces/SerialInterface.py | 1 - FPE/Interfaces/UdpInterface.py | 6 ---- FPE/Utilities/Echo.py | 58 ++++++++++++++++++++++--------- 4 files changed, 41 insertions(+), 28 deletions(-) diff --git a/FPE/Identity.py b/FPE/Identity.py index 26cc58b..dfad666 100644 --- a/FPE/Identity.py +++ b/FPE/Identity.py @@ -179,7 +179,6 @@ class Identity: if self.pub != None: chunksize = (Identity.KEYSIZE-Identity.PADDINGSIZE)/8 chunks = int(math.ceil(len(plaintext)/(float(chunksize)))) - # TODO: Remove debug output print("Plaintext size is "+str(len(plaintext))+", with "+str(chunks)+" chunks") ciphertext = ""; for chunk in range(chunks): @@ -187,8 +186,6 @@ class Identity: end = (chunk+1)*chunksize if (chunk+1)*chunksize > len(plaintext): end = len(plaintext) - - # TODO: Remove debug output print("Processing chunk "+str(chunk+1)+" of "+str(chunks)+". Starting at "+str(start)+" and stopping at "+str(end)+". The length is "+str(len(plaintext[start:end]))) ciphertext += self.pub.encrypt( plaintext[start:end], @@ -198,7 +195,6 @@ class Identity: label=None ) ) - # TODO: Remove debug output print("Plaintext encrypted, ciphertext length is "+str(len(ciphertext))+" bytes.") return ciphertext else: raise KeyError("Encryption failed because identity does not hold a public key") diff --git a/FPE/Interfaces/SerialInterface.py b/FPE/Interfaces/SerialInterface.py index dfe2699..cc488ae 100755 --- a/FPE/Interfaces/SerialInterface.py +++ b/FPE/Interfaces/SerialInterface.py @@ -9,7 +9,6 @@ import FPE class SerialInterface(Interface): MAX_CHUNK = 32768 - TIMEOUT_SECONDS = 1.0 owner = None port = None diff --git a/FPE/Interfaces/UdpInterface.py b/FPE/Interfaces/UdpInterface.py index 52472d2..d0359bb 100755 --- a/FPE/Interfaces/UdpInterface.py +++ b/FPE/Interfaces/UdpInterface.py @@ -37,13 +37,9 @@ class UdpInterface(Interface): def processIncoming(self, data): - # TODO: remove - #FPE.log("IN: "+FPE.prettyhexrep(data)) self.owner.inbound(data) def processOutgoing(self,data): - # TODO: remove - #FPE.log("OUT: "+FPE.prettyhexrep(" "+data)) udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) udp_socket.sendto(data, (self.forward_ip, self.forward_port)) @@ -57,7 +53,5 @@ class UdpInterfaceHandler(SocketServer.BaseRequestHandler): def handle(self): if (UdpInterfaceHandler.interface != None): - # TODO: remove - #FPE.log("Datagram contents: "+FPE.prettyhexrep(self.request[0])) data = self.request[0] UdpInterfaceHandler.interface.processIncoming(data) \ No newline at end of file diff --git a/FPE/Utilities/Echo.py b/FPE/Utilities/Echo.py index 2d662e8..2f6a192 100644 --- a/FPE/Utilities/Echo.py +++ b/FPE/Utilities/Echo.py @@ -179,31 +179,55 @@ def client(destination_hexhash, configpath): # user to wait for an announce to arrive. FPE.log("Destination is not yet known. Wait for an announce to arrive.") +# This method is called when our reply destination +# receives a proof packet. def clientProofCallback(proof_packet): + # We save the current time so we can calculate + # round-trip time for the packet now = time.time() + + # Let's look through our list of sent requests, + # and see if we can find one that matches the + # proof we just received. for unproven_packet in sent_requests: - if unproven_packet.packet_hash == proof_packet.data[:32]: - if unproven_packet.validateProofPacket(proof_packet): - rtt = now - unproven_packet.sent_at - if (rtt >= 1): - rtt = round(rtt, 3) - rttstring = str(rtt)+" seconds" + try: + # Check that the proof hash matches the + # hash of the packet we sent earlier + if unproven_packet.packet_hash == proof_packet.data[:32]: + # We need to actually calidate the proof. + # This is simply done by calling the + # validateProofPacket method on the packet + # we sent earlier. + if unproven_packet.validateProofPacket(proof_packet): + # If the proof is valid, we will calculate + # the round-trip time, and inform the user. + rtt = now - unproven_packet.sent_at + if (rtt >= 1): + rtt = round(rtt, 3) + rttstring = str(rtt)+" seconds" + else: + rtt = round(rtt*1000, 3) + rttstring = str(rtt)+" milliseconds" + + FPE.log( + "Valid echo reply, proved by "+FPE.prettyhexrep(unproven_packet.destination.hash)+ + ", round-trip time was "+rttstring + ) + # Perform some cleanup + sent_requests.remove(unproven_packet) + del unproven_packet else: - rtt = round(rtt*1000, 3) - rttstring = str(rtt)+" milliseconds" - - FPE.log( - "Valid echo reply, proved by "+FPE.prettyhexrep(unproven_packet.destination.hash)+ - ", round-trip time was "+rttstring - ) - sent_requests.remove(unproven_packet) - del unproven_packet - else: - FPE.log("Proof invalid") + # If the proof was invalid, we inform + # the user of this. + FPE.log("Echo reply received, but proof was invalid") + except: + FPE.log("Proof packet received, but packet contained invalid or unparsable data") if __name__ == "__main__": + # Set up command line arguments and start + # the selected program mode. try: parser = argparse.ArgumentParser(description="Simple echo server and client utility") parser.add_argument("-s", "--server", action="store_true", help="wait for incoming packets from clients")