First commit

tests/carmi_function_oeis

@@ -0,0 +1 @@
+1, 1, 2, 2, 4, 2, 6, 2, 6, 4, 10, 2, 12, 6, 4, 4, 16, 6, 18, 4, 6, 10, 22, 2, 20, 12, 18, 6, 28, 4, 30, 8, 10, 16, 12, 6, 36, 18, 12, 4, 40, 6, 42, 10, 12, 22, 46, 4, 42, 20, 16, 12, 52, 18, 20, 6, 18, 28, 58, 4, 60, 30, 6, 16, 12, 10, 66, 16, 22, 12, 70, 6, 72, 36, 20, 18, 30, 12, 78, 4, 54

tests/carmi_numbers_oeis

@@ -0,0 +1 @@
+561, 1105, 1729, 2465, 2821, 6601, 8911, 10585, 15841, 29341, 41041, 46657, 52633, 62745, 63973, 75361, 101101, 115921, 126217, 162401, 172081, 188461, 252601, 278545, 294409, 314821, 334153, 340561, 399001, 410041, 449065, 488881, 512461, 530881, 552721

tests/execute_tests.py

@@ -0,0 +1,8 @@
+#!/usr/bin/bash
+
+set -e
+source /home/geoffrey/venv/forensic/bin/activate;
+for test in `ls tests/test_*.py`; do
+    echo $test;
+    python3 $test -v;
+done

tests/fibonacci_oeis

@@ -0,0 +1 @@
+0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155

tests/phi_oeis

@@ -0,0 +1 @@
+1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8, 12, 10, 22, 8, 20, 12, 18, 12, 28, 8, 30, 16, 20, 16, 24, 12, 36, 18, 24, 16, 40, 12, 42, 20, 24, 22, 46, 16, 42, 20, 32, 24, 52, 18, 40, 24, 36, 28, 58, 16, 60, 30, 36, 32, 48, 20, 66, 32, 44

tests/prime_numbers_oeis

@@ -0,0 +1 @@
+2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271

tests/test_breaking_rsa.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+
+import unittest
+from Cryptotools.Numbers.primeNumber import isPrimeNumber
+from math import sqrt, isqrt, ceil
+from random import choice
+
+
+class TestBreakingRSA(unittest.TestCase):
+    def test_breaking_rsa(self):
+        # primes = self._list_primes()
+        #p = choice(primes)
+        #q = choice(primes)
+        self._breaking_rsa(7901, 7817)
+        self._breaking_rsa(7907, 7919)
+        self._breaking_rsa(7103, 7127) # Works
+        # self._breaking_rsa(7103, 7121) # Doesn't works
+
+    def _breaking_rsa(self, p, q):
+        # print(f"p = {p}")
+        # print(f"q = {q}")
+        n = p * q
+        # print(f"n = {n}")
+        
+        # a = isqrt(n) + 1
+        a = ceil(sqrt(n))
+        iteration = 1
+        while True:
+            b2 = (a ** 2) - n
+            sqb2 = sqrt(b2)
+            if b2 % 2 == 0.0:
+                b = sqrt(b2)
+                break
+            a = a + 1
+            iteration += 1
+        # print(f"Iteration: {iteration}") 
+        # print(f"a = {a}")
+        # print(f"b2 = {b2}")
+        # print(f"b = {b}")
+        p = int((a + b))
+        q = int((a - b))
+        #N = (a + b) * (a - b)
+        N = p * q
+        # print(isPrimeNumber(p))
+        # print(isPrimeNumber(q))
+        # print(N)
+        # print()
+        self.assertTrue(N == n)
+
+    def _list_primes(self):
+        l = list()
+        i = 100 # We start at 100
+        while (len(l) < 1000):
+            if isPrimeNumber(i):
+                l.append(i)
+            i = i + 1
+        return l
+
+unittest.main()

tests/test_carmi.py

@@ -0,0 +1,44 @@
+import unittest
+
+from Cryptotools.Numbers.carmi import carmi_numbers, is_carmichael, carmichael_lambda
+
+
+class TestCarmichael(unittest.TestCase):
+        def _generate_carmi(self):
+            # Source: https://oeis.org/A002322
+            with open("tests/carmi_function_oeis", "r") as f:
+                data = f.readlines()
+            carmi_s = data[0].split(",")
+            carmi = list()
+            for entry in carmi_s:
+                carmi.append(entry.strip())
+            return carmi 
+
+        def _generate_carmi_numbers(self):
+            # Source: https://oeis.org/A002997
+            with open("tests/carmi_numbers_oeis", "r") as f:
+                data = f.readlines()
+            carmi_s = data[0].split(",")
+            carmi = list()
+            for entry in carmi_s:
+                carmi.append(entry.strip())
+            return carmi # len 69
+
+        def test_carmi_lambda(self):
+            carmi_list = self._generate_carmi()
+            index = 2
+            for i in range(2, len(carmi_list)):
+                res = carmichael_lambda(index)
+                print(f"{res} {carmi_list[i]}")
+                index += 1
+                # self.assertEqual(res, carmi_list[i], "Wrong value")
+
+        def test_carmi_number(self):
+            pass
+            #carmi_list = self._generate_carmi_numbers()
+            #for i in range(0, len(carmi_list) - 10):
+            #    value = int(carmi_list[i])
+            #    l = carmi_numbers(value)
+            #    r = is_carmichael(value, l)
+            #    self.assertTrue(r) 
+unittest.main()

tests/test_numbers.py

@@ -0,0 +1,22 @@
+import unittest
+
+from Cryptotools.Numbers.numbers import fibonacci
+
+class TestNumbers(unittest.TestCase):
+    def _generate_fibonacci(self):
+        # Source https://oeis.org/A000045
+        with open("tests/fibonacci_oeis", "r") as f:
+            data = f.readlines()
+        fibo_s = data[0].split(",")
+        fibo = list()
+        for entry in fibo_s:
+            fibo.append(int(entry.strip()))
+        return fibo
+
+    def test_fibonacci(self):
+        fibo_oeis = self._generate_fibonacci()
+        fibo = fibonacci(40)
+        for i in range(0, len(fibo_oeis)):
+            self.assertEqual(fibo[i], fibo_oeis[i], "Wrong value")
+
+unittest.main()

tests/test_phi.py

@@ -0,0 +1,26 @@
+import unittest
+
+from Cryptotools.Numbers.coprime import phi
+
+class TestPhi(unittest.TestCase):
+    def _generate_phi(self):
+        # Source: https://oeis.org/A000010
+        with open("tests/phi_oeis", "r") as f:
+            data = f.readlines()
+        phi_s = data[0].split(",")
+        phi = list()
+        for entry in phi_s:
+            phi.append(int(entry.strip()))
+        return phi # len 69
+
+    def test_phi(self):
+        phi_list = self._generate_phi()
+        index = 0
+        for i in range(1, len(phi_list) + 1):
+            res = phi(i)
+            # print(f"{i} {res}")
+            value = phi_list[index]
+            # print(f"{res}: {value}")
+            self.assertEqual(res, value, "Wrong value")
+            index += 1
+unittest.main()

tests/test_primes.py

@@ -0,0 +1,57 @@
+import unittest
+
+from Cryptotools.Numbers.primeNumber import getPrimeNumber, isPrimeNumber, sieveOfEratosthenes, _fermatLittleTheorem
+
+"""
+    To confirm if our algorithms for generating a list of prime numbers,
+    Our test check with the list generated by OEIS:
+        https://oeis.org/A000040
+
+"""
+
+class TestPrime(unittest.TestCase):
+    """
+        Lorsqu'on test, on genere une liste de prime number
+        Et une liste de non prime number
+        Nos tests vont verifier si les test de millerRabbin fonctionne et retourne bien que les non primes sont bien non primes
+    """
+    def _generate_sieve(self):
+        # Source: https://oeis.org/A002322
+        with open("tests/prime_numbers_oeis", "r") as f:
+            data = f.readlines()
+        p_s = data[0].split(",")
+        primes = list()
+        for entry in p_s:
+            primes.append(int(entry.strip()))
+        return primes
+
+    def test_prime(self):
+        pass
+        #for i in range(25):
+        #    n = getPrimeNumber(128)
+
+    def test_is_prime(self):
+        pass
+        #for i in range(25):
+        #    n = getPrimeNumber()
+        #    # self.assertTrue(isPrimeNumber(n))
+
+    def test_sieve_eratost(self):
+        sieves = self._generate_sieve()
+        eratost = sieveOfEratosthenes(100) 
+
+        for i in range(len(eratost)):
+            self.assertEqual(eratost[i], sieves[i], "Wrong value")
+
+    def test_fermat(self):
+        numbers = {
+            5: True,
+            19: True,
+            20: False
+        }
+
+        #for number in numbers:
+        #    if numbers[number] != _fermatLittleTheorem(number):
+        #        self.assertFalse(numbers[number])
+
+unittest.main()