Implement crypto api for strings

Author: Christian Pfarr

key.py

@@ -23,6 +23,10 @@
 SOFTWARE.
 
 """
+from io import BytesIO
+from sys import byteorder
+
+from utils import trim_empty_utf32bytes
 
 
 class Key(object):
@@ -92,13 +96,33 @@ def modulo(self):
         """
         return self._modulo
 
-    def modular_exponentiation(self, data):
+    def _modular_exponentiation(self, integer):
         """
-        The operation of modular exponentiation calculates the remainder when an integer data (the base)
-        raised to the power of the exponent, divided by a positive integer modulo.
+        The operation of modular exponentiation calculates the remainder when an integer (the base)
+        raised to the power of the exponent, divided by an modulo.
 
-        :param data: Data to process the modular exponentiation.
+        :param integer: Integer to process the modular exponentiation.
         :return: The result of the modular exponentiation.
         :rtype: int
         """
-        return pow(data, self._exponent, self._modulo)
+        return pow(integer, self._exponent, self._modulo)
+
+    def _stream_modular_exponentiation(self, utf32bytes):
+        """
+        Calculates the operation of modular exponentiation over a stream of UTF-32 formatted bytes.
+
+        :param utf32bytes: UTF-32 formatted input bytes.
+        :return: UTF-32 formatted output bytes.
+        :rtype: bytes
+        """
+        input_stream = BytesIO(utf32bytes)
+        output_stream = BytesIO()
+        buffer_length = self.bit_length // 8
+        buffer = bytearray(buffer_length)
+        while input_stream.readinto(buffer) > 1:
+            input_integer = int.from_bytes(buffer, byteorder)
+            output_integer = self._modular_exponentiation(input_integer)
+            output_buffer = trim_empty_utf32bytes(output_integer.to_bytes(buffer_length, byteorder))
+            output_stream.write(output_buffer)
+            buffer = bytearray(buffer_length)
+        return output_stream.getvalue()

keypair.py

@@ -41,9 +41,9 @@ class KeyPair(object):
     def __init__(self, bit_length=2048):
         """
         Creates the key pair with a given bit length.
-        Works with 2 seperate processes if possible.
+        Works with 2 separate processes if possible.
 
-        :param bit_length: the lenght of the modulo in bits
+        :param bit_length: the length of the modulo in bits
         """
         worker = Pool(min(2, cpu_count()))
         bits = [(bit_length // 2), (bit_length // 2)]

prime.py

@@ -178,4 +178,4 @@ def security(cls):
         :return: The security level in percent.
         :rtype: float
         """
-        return (100 * (1 - (1 / (pow(2, cls.SOLOVAY_STRASSEN_ROUNDS)))))
+        return 100 * (1 - (1 / (pow(2, cls.SOLOVAY_STRASSEN_ROUNDS))))

privatekey.py

@@ -25,6 +25,7 @@
 """
 
 from key import Key
+from utils import utf8str2utf32bytes, utf32bytes2utf8str, pack, unpack
 
 
 class PrivateKey(Key):
@@ -64,22 +65,22 @@ def is_private():
         """
         return True
 
-    def decipher_int(self, data):
+    def decipher(self, hex_utf32bytes):
         """
-        Decipher an integer value.
+        Deciphers the given hex string of UTF-32 formatted bytes.
 
-        :param data: Data to be deciphered.
-        :return: The deciphered data.
-        :rtype: int
+        :param hex_utf32bytes: The enciphered data as hex string of UTF-32 formatted bytes
+        :return: The deciphered Data as UTF-8 string
+        :rtype: string
         """
-        return self.modular_exponentiation(data)
+        return utf32bytes2utf8str(self._stream_modular_exponentiation(bytes.fromhex(unpack(hex_utf32bytes))))
 
-    def sign_int(self, data):
+    def sign(self, utf8str):
         """
-        Sign an integer value.
+        Sign the given plain text as UTF-8 string and return the signed data as a hex representation of UTF-32 bytes.
 
-        :param data: Data to be signed.
-        :return: The signed data
-        :rtype: int
+        :param utf8str: The plain text as UTF-8 string.
+        :return: The signed data as hex representation of UTF-32 bytes.
+        :rtype: string
         """
-        return self.modular_exponentiation(data)
+        return pack(self._stream_modular_exponentiation(utf8str2utf32bytes(utf8str)).hex())

publickey.py

@@ -25,6 +25,7 @@
 """
 
 from key import Key
+from utils import utf8str2utf32bytes, utf32bytes2utf8str, pack, unpack
 
 
 class PublicKey(Key):
@@ -64,23 +65,22 @@ def is_public():
         """
         return True
 
-    def encipher_int(self, data):
+    def encipher(self, utf8str):
         """
-        Encipher an integer value.
+        Encipher the given UTF-8 String into a hex representation of UTF-32 bytes.
 
-        :param data: Data to be enciphered.
-        :return: The enciphered Data.
-        :rtype: int
+        :param utf8str: The input to encipher as UTF-8 string.
+        :return: Hex representation of UTF-32 bytes.
+        :rtype: string
         """
-        return self.modular_exponentiation(data)
+        return pack(self._stream_modular_exponentiation(utf8str2utf32bytes(utf8str)).hex())
 
-    def verify_int(self, data):
+    def verify(self, hex_utf32bytes):
         """
-        Verify an integer value.
-
+        Verify the given hex representation of UTF-32 bytes and return the plain message as UTF-8 string.
 
-        :param data: Data to be verified.
-        :return: The verified Data.
-        :rtype: int
+        :param hex_utf32bytes: Hex representation of UTF-32 string.
+        :return: The plain message as UTF-8 string.
+        :rtype: string
         """
-        return self.modular_exponentiation(data)
+        return utf32bytes2utf8str(self._stream_modular_exponentiation(bytes.fromhex(unpack(hex_utf32bytes))))