Initial commit

Author: Z0ltrix

.gitignore

@@ -0,0 +1,101 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Christian Pfarr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,2 @@
+# simplersa
+Simple RSA Library completely written in Python

euclid.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+class Euclid:
+    def gcd(self, a, b):
+        while (b != 0):
+            (a, b) = (b, a % b)
+        return abs(a)
+
+    def extendedGcd(self, a, b):
+        u, v, s, t = 1, 0, 0, 1
+        oa, ob = a, b
+        while b > 0:
+            q = a // b
+            a, b = b, a - q * b
+            u, s = s, u - q * s
+            v, t = t, v - q * t
+        if (u < 0): u += ob
+        if (v < 0): v += oa
+        return a, u, v

jacobi.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+class Jacobi:
+
+    def symbol(self, a, b):
+        result = 1
+        while (a != 0):
+            while ((a % 2) == 0):
+                a = a // 2
+                if ((b == (3 % 8)) or (b == (5 % 8))):
+                    result = -result
+            (a, b) = (b, a)
+            if ((a == (3 % 4)) or (b == (3 % 4))):
+                result = -result
+            a = a % b
+        if (b == 1):
+            return result
+        return 0

key.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+class Key:
+    def __init__(self, modulo, exponent):
+        self.__modulo = modulo
+        self.__exponent = exponent
+
+    def getBits(self):
+        return self.__modulo.bit_length()
+
+    def getModulo(self):
+        return self.__modulo
+
+    def getExponent(self):
+        return self.__exponent
+
+    def isPublic(self):
+        return False
+
+    def isPrivate(self):
+        return False
+
+
+class PrivateKey(Key):
+    def __init__(self, modulo, decipherExponent):
+        Key.__init__(self, modulo, decipherExponent)
+
+    def getDecipherExponent(self):
+        return self.getExponent()
+
+    def isPrivate(self):
+        return True
+
+
+class PublicKey(Key):
+    def __init__(self, modulo, encipherExponent):
+        Key.__init__(self, modulo, encipherExponent)
+        self.__isPublic = True
+
+    def getEncipherExponent(self):
+        return self.getExponent()
+
+    def isPublic(self):
+        return True

prime.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+import random
+import solovaystrassen
+
+
+class Prime:
+    __SOLOVAYSTRASSENROUNDS = 100
+
+    def __init__(self, bits):
+        self.__solovayStrassen = solovaystrassen.SolovayStrassen()
+        while True:
+            prime = random.SystemRandom().getrandbits(bits)
+            prime |= 1
+            if self.__isPrimality(prime): break
+        self.__value = prime
+
+    def __del__(self):
+        del self.__value
+
+    def __eq__(self, b):
+        if isinstance(b, Prime):
+            if self.__value == b.__value:
+                return True
+            else:
+                return False
+        else:
+            if self.__value == b:
+                return True
+            else:
+                return False
+
+    def __add_(self, b):
+        if isinstance(b, Prime):
+            return (self.__value + b.__value)
+        else:
+            return (self.__value + b)
+
+    def __sub__(self, b):
+        if isinstance(b, Prime):
+            return (self.__value - b.__value)
+        else:
+            return (self.__value - b)
+
+    def __mul__(self, b):
+        if isinstance(b, Prime):
+            return (self.__value * b.__value)
+        else:
+            return (self.__value * b)
+
+    def __div__(self, b):
+        if isinstance(b, Prime):
+            return (self.__value / b.__value)
+        else:
+            return (self.__value / b)
+
+    def getValue(self):
+        return self.__value
+
+    def __isPrimality(self, maybe):
+        for _ in range(self.__SOLOVAYSTRASSENROUNDS):
+            x = random.SystemRandom().randint(1, maybe)
+            if self.__solovayStrassen.isComposite(x, maybe):
+                return False
+        return True

simplersa.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+
+import euclid
+import prime
+import key
+import random
+
+
+class SimpleRsa:
+    def __init__(self):
+        self.__euclid = euclid.Euclid()
+
+    def __calculateModulo(self, p, q):
+        modulo = p * q
+        return modulo
+
+    def __calculatePhi(self, p, q):
+        phi = (p - 1) * (q - 1)
+        return phi
+
+    def __calculateEncipherExponent(self, phi):
+        while True:
+            encipherExponent = random.SystemRandom().randint(1, phi)
+            if (self.__euclid.gcd(encipherExponent, phi) == 1):
+                break
+        return encipherExponent
+
+    def __calculateDecipherExponent(self, phi, encipherExponent):
+        gcd, k, decipherExponent = self.__euclid.extendedGcd(phi, encipherExponent)
+        return decipherExponent
+
+    def __checkModulo(self, modulo):
+        if (modulo.bit_length() == bits):
+            return True
+        else:
+            return False
+
+    def generateKeyPair(self, bits=2048):
+        p = 0
+        q = 0
+        pBits = bits // 2
+        qBits = bits // 2
+        change = 0
+        while True:
+            if (p == 0) or (change == 1):
+                p = prime.Prime(pBits)
+            if (q == 0) or (change == 0):
+                q = prime.Prime(qBits)
+            modulo = self.__calculateModulo(p, q)
+            if self.__checkModulo(modulo):
+                break
+            else:
+                if (change == 0):
+                    change = 1
+                else:
+                    change = 0
+                continue
+        phi = self.__calculatePhi(p, q)
+        encipherExponent = self.__calculateEncipherExponent(phi)
+        decipherExponent = self.__calculateDecipherExponent(phi, encipherExponent)
+        privateKey = key.PrivateKey(modulo, decipherExponent)
+        publicKey = key.PublicKey(modulo, encipherExponent)
+        return (privateKey, publicKey)
+
+    def encipher(self, data, encipherExponent, modulo):
+        return pow(data, encipherExponent, modulo)
+
+    def decipher(self, data, decipherExponent, modulo):
+        return pow(data, decipherExponent, modulo)
+
+    def sign(self, data, decipherExponent, modulo):
+        return pow(data, decipherExponent, modulo)
+
+    def verify(self, data, encipherExponent, modulo):
+        return pow(data, encipherExponent, modulo)
+
+
+# TESTS
+rsa = SimpleRsa()
+data = int(input("Data      : "))
+while True:
+    bits = int(input("Bits      : "))
+    privateKey, publicKey = rsa.generateKeyPair(bits)
+    print("encipherExponent : ", publicKey.getEncipherExponent())
+    print("decipherExponent : ", privateKey.getDecipherExponent())
+    encipheredData = rsa.encipher(data, publicKey.getEncipherExponent(), publicKey.getModulo())
+    print("encipheredData   : ", encipheredData)
+    decipheredData = rsa.decipher(encipheredData, privateKey.getDecipherExponent(), privateKey.getModulo())
+    print("decipheredData   : ", decipheredData)
+    if input("nochmal? ") == "nein": break

solovaystrassen.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+import euclid
+import jacobi
+
+
+class SolovayStrassen:
+    def __init__(self):
+        self.__euclid = euclid.Euclid()
+        self.__jacobi = jacobi.Jacobi()
+
+    def isComposite(self, a, maybe):
+        g = self.__euclid.gcd(a, maybe)
+        b = pow(a, maybe >> 1, maybe)
+        if g > 1:
+            return True
+        elif (1 < b) and (b < maybe - 1):
+            return True
+        elif (b == 1) or (b == maybe - 1):
+            j = self.__jacobi.symbol(a, maybe)
+            c = b % maybe
+            if (j == c): return False
+        return False