diff --git a/classes/helpers/EncryptionScheme.py b/classes/helpers/EncryptionScheme.py
new file mode 100644
index 0000000000000000000000000000000000000000..a59d1ddde4a597946feca1454ccfbcb0317acc8b
--- /dev/null
+++ b/classes/helpers/EncryptionScheme.py
@@ -0,0 +1,24 @@
+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)
diff --git a/classes/helpers/PrivateKey.py b/classes/helpers/PrivateKey.py
index 53d5f45b6d221ebd4e17886ad89896fe031887c1..6797c77666741526f27e36535cc4d6e77820bd84 100644
--- a/classes/helpers/PrivateKey.py
+++ b/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)
diff --git a/classes/helpers/PublicKey.py b/classes/helpers/PublicKey.py
index 9d121a38e76b6222d9c8fa425a353c76685ec786..c6d75b2f4b9cc9e323553a36cb64b84b0a716d6f 100644
--- a/classes/helpers/PublicKey.py
+++ b/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:
diff --git a/classes/helpers/SignatureScheme.py b/classes/helpers/SignatureScheme.py
index c9e5eadcaac0a9726ef72919915a0caf53f5c3b5..63e88815a24d3aff2565fcc1deffe5c07a4269c0 100644
--- a/classes/helpers/SignatureScheme.py
+++ b/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)