Before Identity restructure

.gitignore

@@ -1 +1,2 @@
+.DS_Store
 *.pyc

FPE/Destination.py

@@ -1,4 +1,6 @@
 import base64
+import math
+from Identity import Identity
 from Transport import Transport
 from cryptography.fernet import Fernet
 from cryptography.hazmat.primitives import hashes
@@ -8,6 +10,10 @@ from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives.asymmetric import padding
 
 class Destination:
+	KEYSIZE    = Identity.KEYSIZE;
+	PADDINGSIZE= Identity.PADDINGSIZE;
+
+	# Constants
 	SINGLE     = 0x01;
 	GROUP      = 0x02;
 	PLAIN      = 0x03;
@@ -86,7 +92,7 @@ class Destination:
 		if self.type == Destination.SINGLE:
 			self.prv = rsa.generate_private_key(
 				public_exponent=65337,
-				key_size=2048,
+				key_size=Destination.KEYSIZE,
 				backend=default_backend()
 			)
 			self.prv_bytes = self.prv.private_bytes(
@@ -99,6 +105,9 @@ class Destination:
 				encoding=serialization.Encoding.DER,
 				format=serialization.PublicFormat.SubjectPublicKeyInfo
 			)
+			print("Keys created, private length is "+str(len(self.prv_bytes)))
+			print("Keys created, public length is "+str(len(self.pub_bytes)))
+			#+", public length is "+str(len(self.pub_bytes))))
 
 		if self.type == Destination.GROUP:
 			self.prv_bytes = Fernet.generate_key()
@@ -142,14 +151,28 @@ class Destination:
 			return plaintext
 
 		if self.type == Destination.SINGLE and self.prv != None:
-			ciphertext = self.pub.encrypt(
+			chunksize = (Destination.KEYSIZE-Destination.PADDINGSIZE)/8
-				plaintext,
+			chunks = int(math.ceil(len(plaintext)/(float(chunksize))))
-				padding.OAEP(
+			print("Plaintext size is "+str(len(plaintext))+", with "+str(chunks)+" chunks")
-					mgf=padding.MGF1(algorithm=hashes.SHA1()),
+
-					algorithm=hashes.SHA1(),
+			ciphertext = "";
-					label=None
+			for chunk in range(chunks):
+				start = chunk*chunksize
+				end = (chunk+1)*chunksize
+				if (chunk+1)*chunksize > len(plaintext):
+					end = len(plaintext)
+
+				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],
+					padding.OAEP(
+						mgf=padding.MGF1(algorithm=hashes.SHA1()),
+						algorithm=hashes.SHA1(),
+						label=None
+					)
 				)
-			)
+			print("Plaintext encrypted, ciphertext length is "+str(len(ciphertext))+" bytes.")
 			return ciphertext
 
 		if self.type == Destination.GROUP and self.prv != None:
@@ -164,14 +187,27 @@ class Destination:
 			return ciphertext
 
 		if self.type == Destination.SINGLE and self.prv != None:
-			plaintext = self.prv.decrypt(
+			print("Ciphertext length is "+str(len(ciphertext))+". ")
-				ciphertext,
+			chunksize = (Destination.KEYSIZE)/8
-				padding.OAEP(
+			chunks = int(math.ceil(len(ciphertext)/(float(chunksize))))
-					mgf=padding.MGF1(algorithm=hashes.SHA1()),
+
-					algorithm=hashes.SHA1(),
+			plaintext = "";
-					label=None
+			for chunk in range(chunks):
+				start = chunk*chunksize
+				end = (chunk+1)*chunksize
+				if (chunk+1)*chunksize > len(ciphertext):
+					end = len(ciphertext)
+
+				print("Processing chunk "+str(chunk+1)+" of "+str(chunks)+". Starting at "+str(start)+" and stopping at "+str(end)+". The length is "+str(len(ciphertext[start:end])))
+
+				plaintext += self.prv.decrypt(
+					ciphertext[start:end],
+					padding.OAEP(
+						mgf=padding.MGF1(algorithm=hashes.SHA1()),
+						algorithm=hashes.SHA1(),
+						label=None
+					)
 				)
-			)
 			return plaintext;
 
 		if self.type == Destination.GROUP:

FPE/FlexPE.py

@@ -8,7 +8,7 @@ import os.path
 import os
 
 class FlexPE:
-	MTU          = 700
+	MTU          = 600
 	router       = None
 	config       = None
 	destinations = []
@@ -25,8 +25,6 @@ class FlexPE:
 			self.createDefaultConfig()
 
 		self.applyConfig()
-		print FlexPE.interfaces
-
 		FlexPE.router = self
 
 	@staticmethod

FPE/Identity.py

@@ -0,0 +1,7 @@
+
+class Identity:
+	# Configure key size
+	KEYSIZE    = 1536;
+
+	# Padding size, not configurable
+	PADDINGSIZE= 336;

FPE/Packet.py

@@ -21,8 +21,9 @@ class Packet:
 			self.raw = self.header + self.ciphertext
 
 			if len(self.raw) > self.MTU:
-				raise IOError("Packet size exceeds MTU of "+Packet.MTU+" bytes")
+				raise IOError("Packet size of "+str(len(self.raw))+" exceeds MTU of "+str(self.MTU)+" bytes")
 
+			print("Size: "+str(len(self.raw)))
 			Transport.outbound(self.raw)
 			self.sent = True
 		else:

FPE/__init__.py

@@ -1,5 +1,11 @@
 import os
 import glob
 
+from .Destination import Destination
+from .FlexPE import FlexPE
+from .Identity import Identity
+from .Packet import Packet
+from .Transport import Transport
+
 modules = glob.glob(os.path.dirname(__file__)+"/*.py")
 __all__ = [ os.path.basename(f)[:-3] for f in modules if not f.endswith('__init__.py')]

TODO

@@ -0,0 +1,12 @@
+To do:
+
+	- Transport
+	- SerialKISS interface
+	- MicroModemGP interface (Packet queue)
+	- Forwarding to other interfaces
+	
+	- Shared instance
+	- JSON api
+
+
+	- Resource storage

t.py

@@ -0,0 +1,47 @@
+# from FPE.Destination import *
+# from FPE.Packet import *
+# from FPE import FlexPE
+from FPE import *
+# from FPE import Destination
+import time
+
+def testCallback(message, receiver):
+  print("Got message from "+str(receiver)+": ")
+  print(message)
+  print("----------")
+
+
+fpe = FlexPE()
+d1=Destination(Destination.IN, Destination.SINGLE, "messenger", "markqvist")
+d1.createKey()
+d1.setCallback(testCallback)
+
+d2=Destination(Destination.IN, Destination.PLAIN, "plainchat", "markqvist")
+d2.setCallback(testCallback)
+
+print d1.name
+print d1.hexhash
+print d1.pub
+print "---"
+print
+
+# p1=Packet(d1, "testmessage")
+# p1.send()
+msg=""
+for x in range(300):
+	msg += "a"
+signed = d1.sign(msg)
+sl = len(signed)
+pl = len(d1.pub_bytes)
+print("Signature length is "+str(sl))
+print("Minimum announce is "+str(pl+sl+8))
+
+
+p2=Packet(d1, msg)
+p2.send()
+
+# p2=Packet(d2, "something else")
+# p2.send()
+
+raw_input()
+