move files

classes/AffineTransformation.py → classes/helpers/AffineTransformation.py

@@ -3,20 +3,33 @@ from sage.all import *
 
 
 class AffineTransformation():
-
     def __init__(self, M, y):
+        """
+        Eine affine Transformation wird mit einer invertierbaren
+        Matrix und einem beliebigen Vektor initialisiert
+        """
+
+        # Abbruchbedingung für nicht invertierbare Matrizen
         if not M.is_invertible():
             exit(1)
-        self.M = M  # invertable Matrix
-        self.y = y  # vector
+
+        self.M = M  # invertierbare Matrix
+        self.y = y  # Vektor
 
     def __call__(self, vector):
-        """Transform a given vector with initialized affine transformation"""
+        """Anwenden der Transformation auf den gegebenen Vektor"""
+
+        # Sollte `vector` eine Liste sein -> Typecast
         if not isinstance(vector, sage.structure.element.Vector):
             vector = vector(vector)
 
         return (self.M * vector) + self.y
 
     def inverse(self, vector):
-        """Transform a given vector with inverted affine transformation"""
+        """Anwenden der inversen Transformation auf den gegebenen Vektor"""
+
+        # Sollte `vector` eine Liste sein -> Typecast
+        if not isinstance(vector, sage.structure.element.Vector):
+            vector = vector(vector)
+
         return self.M.inverse() * (vector - self.y)

classes/PublicKey.py → classes/helpers/PublicKey.py

@@ -4,9 +4,11 @@ import cPickle as pickle
 
 class PublicKey(object):
     def __init__(self, public_polynomial=None, path=None):
+        # wird ein Schlüssel als Datei übergeben, so wird dieser geladen
         if public_polynomial is None and path is not None:
             self.P = self.load(path)
         else:
+            # speichere das Polynomsystem:
             self.P = public_polynomial
 
     def __call__(self, vector):
@@ -15,11 +17,17 @@ class PublicKey(object):
     def __repr__(self):
         return "PublicKey: {}".format(list(self.P))
 
-    def encrypt(self, vector):
-        return self.P(list(vector))
+    def encrypt(self, msg):
+        # der Vektor `msg` muss als Liste an Sage übergeben werden
+        # Sage kann dann eigenständig das Polynomsystem ausrechen
+        return self.P(list(msg))
 
-    def verify(self, vector, signature):
-        return signature == self.encrypt(vector)
+    def verify(self, msg, signature):
+        # Vergleiche gegebene Singatur mit generierter Signatur
+        return signature == self.encrypt(msg)
+
+    """ Es folgt eine sehr einfache Möglichkeit den Schlüssel zu
+    speichern und entsprechend auch wieder zu laden """
 
     def save(self, path="./keys/uov.pub"):
         with open(path, 'wb') as output:

classes/SignatureScheme.py → classes/helpers/SignatureScheme.py

@@ -3,7 +3,7 @@ from sage.all import *
 
 class SignatureScheme(object):
     """All Functions for an MQPKC Signature Scheme"""
-    """Init will set public and private keys"""
+    """Init must set public and private keys"""
 
     def sign(self, msg):
         """
@@ -11,9 +11,6 @@ class SignatureScheme(object):
         private_key of form (S, P', T)
         invert S, P' and T -> we write _S, _P' and _T
         """
-        if not isinstance(msg, sage.structure.element.Vector):
-            msg = vector(msg)
-
         _t = self.private_key.T.inverse(msg)
         _p = self.invert_MQ(_t)
         return self.private_key.S.inverse(_p)