added all helpers

classes/helpers/EncryptionScheme.py

+from sage.all import *
+
+from .SignatureScheme import SignatureScheme
+
+
+class EncryptionScheme(SignatureScheme):
+    """Da EncryptionScheme von SignatureScheme erbt, stehen alle Funktionen zur Verfügung.
+    Wichtig ist auch hier, dass private_key und public_key gesetzt sind."""
+
+    def encrypt(self, message):
+        # da EncryptionScheme nicht direkt von PublicKey erbt wird
+        # die Verschlüsseling extra zur Verfügung gestellt
+        return self.public_key.encrypt(message)
+
+    def decrypt(self, ciphertext):
+        # verhält sich analog zu SignatureScheme.sign(msg)
+
+        # Sollte `ciphertext` eine Liste sein -> Typecast
+        if not isinstance(ciphertext, sage.structure.element.Vector):
+            ciphertext = vector(ciphertext)
+
+        _t = self.private_key.T.inverse(ciphertext)
+        _p = self.invert_MQ(_t)
+        return self.private_key.S.inverse(_p)

classes/helpers/PrivateKey.py

@@ -6,51 +6,40 @@ from .PublicKey import PublicKey
 
 
 class PrivateKey(object):
-    """Private Key
-        AffineTransformation::S
-        PolynomialSystem::P
-        AffineTransformation::T
-    """
-
-    def __init__(self, S, P, T, path=None):
-        # type: (AffineTransformation, PolynomialSystem, AffineTransformation,
-        # String) -> None
+    def __init__(self, S, Pr, T, path=None):
+        # wird ein Schlüssel als Dateipfad übergeben, so wird dieser geladen
         if path is not None:
             (self.S, self.P, self.T) = self.load(path)
-        else:
-            self.S = S
-            self.P = P
-            self.T = T
+
+        self.S = S    # Affine Transformation
+        self.Pr = Pr  # Polynomsystem
+        self.T = T    # Affine Transformation
 
     def generate_public_key(self):
-        # type: (None) -> PublicKey
+        # in `x` sind die Variablen x1,...,xn
         x = vector(self.P[0].parent().gens())
-        sx = list(self.S(x))
-        public_poly = []
-        for i in xrange(0, len(self.P)):
-            public_poly.append(self.P[i](sx))
 
-        spt = self.T(vector(public_poly))
+        # angewendet auf die Verschlüsselung ergibt
+        # dies das öffentliche Polynom
+        spt = self.encrypt(x)
 
         return PublicKey(spt)
 
     def encrypt(self, message):
-        # type: (Vector) -> Vector
-        x = list(self.S(vector(message)))
-        y = []
-        for i in xrange(0, len(self.P)):
-            y.append(self.P[i](x))
+        # Die Verschlüsselung wurde angepasst um nicht von
+        # dem PublicKey abzuhängen sondern von (S,Pr,T)
+        sx = list(self.S(vector(message)))
+        spx = self.Pr(list(sx))
+        return self.T(spx)
 
-        return self.T(vector(y))
+    """ Es folgt eine sehr einfache Möglichkeit den Schlüssel zu
+    speichern und entsprechend auch wieder zu laden """
 
     def save(self, path="./keys/uov.priv"):
-        # type: (String) -> None
         with open(path, 'wb') as output:
             pickle.dump((self.S, self.P, self.T),
                         output, pickle.HIGHEST_PROTOCOL)
 
     def load(self, path):
-        # type: (String) -> (AffineTransformation, PolynomialSystem,
-        # AffineTransformation)
         with open(path, 'rb') as output:
             return pickle.load(output)

classes/helpers/PublicKey.py

@@ -4,7 +4,7 @@ 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
+        # wird ein Schlüssel als Dateipfad übergeben, so wird dieser geladen
         if public_polynomial is None and path is not None:
             self.P = self.load(path)
         else:

classes/helpers/SignatureScheme.py

@@ -2,31 +2,27 @@ from sage.all import *
 
 
 class SignatureScheme(object):
-    """All Functions for an MQPKC Signature Scheme"""
-    """Init must set public and private keys"""
+    """
+    SignatureScheme ist ein interface. Entprechend muss es zwingend
+    mit private_key und public_key initialisiert werden
+    """
 
     def sign(self, msg):
-        """
-        Idea: generate signature that __encrypts__ to hash(message)
-        private_key of form (S, P', T)
-        invert S, P' and T -> we write _S, _P' and _T
-        """
+        '''generiere Signatur, die zu wieder zu msg `verschlüsselt`'''
+
+        # Sollte `msg` eine Liste sein -> Typecast
+        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)
 
     def invert_MQ(self, msg):
-        """
-        Every Scheme has to know how to invert the private polynomial
-        """
+        '''Platzhalter für alle Signatur- und Verschlüsselungsverfahren'''
         raise NotImplementedError
 
     def verify(self, signature, msg):
-        """
-        signature: vector of length n
-        msg:    vector of length m
-
-        for each entry of msg check:
-            msg[i]  == P(signature)
-        """
+        # da SignatureScheme nicht direkt von PublicKey erbt wird
+        # die Verifikation extra zur Verfügung gestellt
         return self.public_key.verify(signature, msg)