def test_miller_rabin(self):
assert not miller_rabin(1000000)
assert miller_rabin(115249)
assert not miller_rabin(115251)
assert miller_rabin(22953686867719691230002707821868552601124472329079)
assert not miller_rabin(
22953686867719691230002707821868552601124472329081)
def test_miller_rabin_64bit(authoritative_lists):
primes, nonprimes = authoritative_lists
for n in primes:
if n >> 64 == 0:
assert miller_rabin.miller_rabin(n)
for n in nonprimes:
if n >> 64 == 0:
assert not miller_rabin.miller_rabin(n)
def basic_test(n):
print n,
start = timeit.default_timer()
miller_rabin(n, 10)
print timeit.default_timer() - start,
#print ecpp(n)
start = timeit.default_timer()
prime(n)
print timeit.default_timer() - start
def basic_test(n):
print n,
start = timeit.default_timer()
miller_rabin(n, 10)
print timeit.default_timer() - start,
#print ecpp(n)
start = timeit.default_timer()
prime(n)
print timeit.default_timer() - start
def test_miller_rabin_super_64bit(authoritative_lists):
primes, nonprimes = authoritative_lists
for n in primes:
if n >> 64 != 0:
assert miller_rabin.miller_rabin(n)
for n in nonprimes:
if n >> 64 != 0:
if miller_rabin.miller_rabin(n):
# The chance is way too small to get a false positive
# after 96 rounds.
assert not miller_rabin.miller_rabin(n, 96)
def main():
h = generate_right_truncatable_harshads(13)
# Filter strong Harshads.
h = [k for k, s in h if miller_rabin(k // s)]
sum_ = 0
for k in h:
for d in (1, 3, 7, 9):
n = k * 10 + d
if miller_rabin(n):
print(n)
sum_ += n
print(f"sum: {sum_}")
def generate_prime():
prime = os.urandom(256)
p_hex = hexlify(prime).decode(ENCODING)
p_int = int(p_hex, 16)
q_int = 2*p_int + 1
while not(mr.miller_rabin(p_int, 40)) and not(mr.miller_rabin(q_int, 40)):
p_int = int(hexlify(os.urandom(256)).decode(ENCODING), 16)
# print(prime_int)
q_int = 2*p_int + 1
# print("extra derpy fail")
print("Successful safe prime has been generated")
return q_int
def genPrime(self, originalPrime):
"""
Generates a new safe-prime through openssl
"""
# p_hex = "FB0ECABBB1897BDE4862BDD74EF53B26D853E3840F9505A030E2C462D777B28D353CBFA959BBD08AF39D300BDE5622173CC05C3E4ED18550D34A36EDF440AE20B086F9366A79517344D6366E2F5B64D3E18BC19F16332EAB76107CB9922BB654DB7D6389DAF033F21596717669DD0E703EDF5F90334F9F1D6956BE6D1907260E45568E2781F1B771BE335A4341DFECBA2C150545DC9D1AEEE2FC5CC7976770C39735B7DAA25B8A0E3947A37B56D387060F76D0524687A1A3357AB9587F6164A9A3D82F352B136318802922A672CB9950A3BC9991EE9871C14615F0B09EF50290A74985B52F4352C557BA2505C78D47D6D4A5EBA9F925CD2FE2D477B3D6FB2BC7"
p_hex = originalPrime
p_int = int(p_hex, 16)
is_prime = mr.miller_rabin(p_int, 40)
q_int = 2*p_int+1
is_prime2 = mr.miller_rabin(q_int, 40) #NOTICE: this is true therefore we have a safe prime
return q_int
def sieve_and_sum(N):
sieve = [[] for k in range(N + 1)]
total = 0
report_interval = 10 ** 5
for k in range(1, N + 1):
if k % report_interval == 0:
print(f"progress: {k}")
divisors = sieve[k]
q = 4 * k * k + 1
max_p = 0
for p in divisors:
while q % p == 0:
q //= p
if p > max_p:
max_p = p
if q < max_p:
# print(k, max_p)
total = (total + max_p) % MODULUS
continue
if miller_rabin(q):
factors = [q]
else:
factors = sorted(sympy.factorint(q))
# print(k, factors[-1])
total = (total + factors[-1]) % MODULUS
for p in factors:
for kk in range(k + p, N + 1, p):
sieve[kk].append(p)
return total
def random_prime(bits):
probably_prime = False
while not probably_prime:
lower = pow(2, bits - 2)
upper = pow(2, bits + 2)
rand_p = random.randint(lower, upper)
probably_prime = miller_rabin(rand_p)
return rand_p
def is_prime(n):
# first, verify that n is a valid input
if type(n) is not int:
raise TypeError("n must be an integer")
if n < 2:
raise ValueError("n must be greater than 1")
return miller_rabin(n)
def test_miller_rabin(self):
self.assertTrue(miller_rabin.miller_rabin(32416190071, 300))
self.assertTrue(miller_rabin.miller_rabin(7, 3))
self.assertFalse(miller_rabin.miller_rabin(-1, 1))
self.assertFalse(miller_rabin.miller_rabin(6, 3))
self.assertTrue(miller_rabin.miller_rabin(99377, 300))
self.assertFalse(miller_rabin.miller_rabin(3434264727117317381232123, 300))
self.assertTrue(miller_rabin.miller_rabin(999979, 300))
self.assertFalse(miller_rabin.miller_rabin(999980, 300))
def testing_primality_checkers():
prime_list = algos.get_primes()
#goes up to around 100k in primes_list
for i in xrange(1, 50000):
#print "testing %d" %i
is_prime = i in prime_list
mr_is_prime, steps = miller_rabin.miller_rabin(i, 10)
if is_prime != mr_is_prime:
print "was bad"
def _large_prime(bits: int):
times = int(1000 * (math.log(bits, 2) + 1))
for _ in range(times):
n = random.randrange(2**(bits - 1), 2**bits)
if miller_rabin(n):
return n
raise Exception(
f'failed to generate prime number of {bits} bit length in {times} tries'
)
def main():
squares = [miller_rabin(i) for i in range(1, N + 1)]
extent = len(SEQUENCE) - 1
total_prob = mpq(0)
for i in range(N):
if i % 100 == 0:
print(f"progress: {i}")
left = max(0, i - extent)
right = min(N, i + extent + 1)
total_prob += prob(tuple(squares[left:right]), i - left) / N
print(total_prob)
def __gen_valid_priv_keys(self, p, e=None):
if e is not None:
good = False
while not good:
q = secrets.randbits(self.k)
while not miller_rabin(q, self.l):
q = secrets.randbits(self.k)
phi = (p - 1) * (q - 1)
n = p * q
d = self.__validate_e(e, phi)
if d is not None:
good = True
return q, phi, d
else:
q = secrets.randbits(self.k)
while not miller_rabin(q, self.l):
q = secrets.randbits(self.k)
phi = (p - 1) * (q - 1)
n = p * q
e, d = self.__gen_e_d(phi)
return q, phi, d, e
def is_safe_prime(n):
# first, verify that n is a valid input
if type(n) is not int:
raise TypeError("n must be an integer")
if n < 2:
raise ValueError("n must be greater than 1")
# handle the cases of n = 2, 3 to ensure safe input to is_prime
if n == 2 or n == 3:
return False
q = int((n - 1) / 2) # int cast will not floor value since n is odd
return miller_rabin(q)
def generate_primes(bits=512, n_primes=1):
r"""
Generate any number of primes of specified
bitlength.
"""
primes = [0] * n_primes
for i in range(n_primes):
prime = 1
for j in range(1, bits):
prime += pow(2, j) * rand(0, 2)
while not miller_rabin(prime):
prime += 2
primes[i] = prime
return primes
def prime_gen1(digits, remove_prime_mults_up_to=1): #inclusive
if remove_prime_mults_up_to > 7:
raise ("Removing primes up to mults above 7 is not supported")
start = time.time()
primes_list = [
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
]
gen_steps = 0
min_num, max_num = 10**(digits - 1), 10**digits - 1
big, i = 1, -1
while True:
i += 1
if primes_list[i] <= remove_prime_mults_up_to:
big *= primes_list[i]
else:
break
big_digits = int(math.floor(math.log(big) / math.log(10)))
if big_digits >= digits:
# if digits is same as big digits, will not be able to find some primes
# if digits is less than big digits, will not be able to find any
return 0, 0, 0
while True:
curr_num = random.randint(min_num, max_num)
# if not, is not a potential prime
cont = True
for p in xrange(0, i):
gen_steps += 1
if (curr_num - p) % big == 0:
cont = False
if cont:
continue
is_prime, mr_steps = miller_rabin.miller_rabin(curr_num, 10)
gen_steps += mr_steps
if is_prime:
end = time.time()
return curr_num, gen_steps, end - start
# refernces: https://medium.com/@prudywsh/how-to-generate-big-prime-numbers-miller-rabin-49e6e6af32fb
# https://math.stackexchange.com/questions/68473/fastest-prime-generating-algorithm
def count(n):
primes = primesieve.primes(n)
sum_counts = collections.defaultdict(int)
sum_counts[0] = 1
for i, p in enumerate(primes):
if (i + 1) % 100 == 0:
print(f"progress: {i+1}-th prime")
prev_sums = sorted(sum_counts.keys(), reverse=True)
for prev_sum in prev_sums:
sum_counts[prev_sum + p] = (sum_counts[prev_sum + p] +
sum_counts[prev_sum]) % MODULUS
total_count = 0
for sum_, count in sum_counts.items():
if miller_rabin.miller_rabin(sum_):
total_count = (total_count + count) % MODULUS
return total_count
def main():
limit = 1_000_000_000_000
primes = primesieve.primes(pow(limit, 1 / 2))
squbes = set()
for q in primes:
q3 = pow(q, 3)
if q3 * 4 > limit:
break
for p in primes:
if p == q:
continue
n = p * p * q3
if n > limit:
break
s = str(n)
if "200" not in s:
continue
squbes.add(n)
length = len(s)
failed = False
for i in range(length):
ss = [ch for ch in s]
d = s[i]
if i == 0:
replacements = set("123456789")
elif i == length - 1:
replacements = set("1379")
else:
replacements = set("0123456789")
replacements.discard(d)
for dd in replacements:
ss[i] = dd
nn = int("".join(ss))
if miller_rabin.miller_rabin(nn):
failed = True
break
if failed:
break
if not failed:
squbes.add(n)
for i, n in enumerate(sorted(squbes)):
print(i + 1, n)
def prime(n):
"""
Final Product: Run Miller-Rabin first, use ECPP only when its probable prime.
Args:
n: Number to be tested
Returns:
certificate if the number is prime, False otherwise.
"""
if not n > 0:
raise ValueError("input must be greater than 0")
repeat = 50
if miller_rabin(n, repeat):
cert = atkin_morain(n)
if not cert:
raise InconsistencyError("ECPP")
else:
return cert
else:
return False
def prime(n):
"""
Final Product: Run Miller-Rabin first, use ECPP only when its probable prime.
Args:
n: Number to be tested
Returns:
certificate if the number is prime, False otherwise.
"""
if not n > 0:
raise ValueError("input must be greater than 0")
repeat = 50
if miller_rabin(n, repeat):
cert = atkin_morain(n)
if not cert:
raise InconsistencyError("ECPP")
else:
return cert
else:
return False
def main():
hammings = []
p2 = 1
while p2 <= BOUND:
p3 = 1
while p2 * p3 <= BOUND:
p23 = p2 * p3
p5 = 1
while p23 * p5 <= BOUND:
n = p23 * p5
hammings.append(n)
p5 *= 5
p3 *= 3
p2 *= 2
hammings.sort()
hamming_primes = []
for h in hammings:
p = h + 1
if p not in (2, 3, 5) and miller_rabin(p):
hamming_primes.append(p)
hamming_prime_products = [1]
for p in hamming_primes:
new_products = []
for n in hamming_prime_products:
prod = n * p
if prod > BOUND:
break
new_products.append(prod)
hamming_prime_products.extend(new_products)
hamming_prime_products.sort()
total = 0
for n1 in hammings:
for n2 in hamming_prime_products:
prod = n1 * n2
if prod > BOUND:
break
total = (total + prod) % MODULUS
print(total)
def key_gen(seed, d):
random.seed(seed)
die = random.SystemRandom()
g = 2
p = None
while True:
q = die.getrandbits(32)
if q % 12 is 5:
p = 2 * q + 1
if miller_rabin(p):
break
e_2 = fast_exp(g, d, p)
#write files
print('key gen:')
print('public key:')
print('p = ' + str(p))
print('g = ' + str(g))
print('e_2 = ' + str(e_2))
print('private key:')
print('p = ' + str(p))
print('g = ' + str(g))
print('d = ' + str(d))
return p, g, e_2
def primeQ_res(self):
try:
num = int(self.primeInTxt.get())
try:
rnds = int(self.primeTestTxt.get())
if miller_rabin(num,rnds) == True:
out = 'Вероятно простое'
else:
out = 'Составное'
self.primeResTxt.configure(state='normal')
self.primeResTxt.delete(1.0,'end')
self.primeResTxt.insert(1.0,out)
self.primeResTxt.configure(state='disabled')
except Exception:
if miller_rabin_test(num) == True:
out = 'Вероятно простое'
else:
out = 'Составное'
self.primeResTxt.configure(state='normal')
self.primeResTxt.delete(1.0,'end')
self.primeResTxt.insert(1.0,out)
self.primeResTxt.configure(state='disabled')
except Exception:
tkinter.messagebox.showinfo('Ошибка','Введите число для проверки в поле.')
def __init__(self, *, p=None, q=None, n=None, e=None, k=512, l=10):
# Make sure k is big enough to be a prime
if k < 3:
raise Exception("k must be at least 3")
self.k = k
if l < 1:
raise Exception("l must be at least 1")
self.l = l
if n is not None:
# Check if p and q are invalid for n
if p is not None and q is not None:
if p * q != n:
raise Exception("n must equal p*q")
elif not miller_rabin(p, l) or not miller_rabin(q, l):
raise Exception("Please provide valid primes")
self._p = p
self._q = q
# Check p is good for n
elif p is not None:
self.__validate_prime(p)
self._p = p
self._q = None
# Check q is good for n
elif q is not None:
self.__validate_prime(q)
self._p = None
self._q = q
else:
self._p = None
self._q = None
self.n = n
# Checks to see if e is valid
# TODO supplying e by itself is a bit broken now
if e is not None:
if p is not None and q is not None:
self._phi = (p - 1) * (q - 1)
self.n = p * q
self._d = self.__validate_e(e, self._phi)
if self._d is None:
raise Exception("Please supply a valid e")
self.e = e
if p is not None and q is not None and n is None:
if not miller_rabin(p, l) or not miller_rabin(q, l):
raise Exception("Please provide valid primes")
self._p = p
self._q = q
self._phi = (self._p - 1) * (self._q - 1)
self.n = self._p * self._q
if self.e is None:
self.e, self._d = self.__gen_e_d(self._phi)
elif n is None:
if p is not None:
if not miller_rabin(p, l):
raise Exception("Please provide a valid prime")
self._p = p
#Get number of bits
self.k = int(math.log2(self._p))
if self.e is None:
self._q, self._phi, self._d, self.e = self.__gen_valid_priv_keys(
self._q)
else:
self._q, self._phi, self._d = self.__gen_valid_priv_keys(
self._q, self.e)
elif q is not None:
if not miller_rabin(q, l):
raise Exception("Please provide a valid prime")
#Generate the rest of the keys
if e is None:
self._p, self._phi, self._d, self.e = self.__gen_valid_priv_keys(
self._q)
else:
self._p, self._phi, self._d = self.__gen_valid_priv_keys(
self._q, self.e)
else:
self.k = k
#Generate p
self._p = secrets.randbits(self.k)
while not miller_rabin(self._p, l):
self._p = secrets.randbits(self.k)
#Generate the rest of the keys
if e is None:
self._q, self._phi, self._d, self.e = self.__gen_valid_priv_keys(
self._p)
else:
self._q, self._phi, self._d = self.__gen_valid_priv_keys(
self._p, self.e)
self.n = self._p * self._q
def test_miller_rabin_errors():
with pytest.raises(ValueError):
miller_rabin.miller_rabin(-1)
with pytest.raises(ValueError):
miller_rabin.miller_rabin(77228969362076174340113658373, -1)
with pytest.raises(ValueError):
miller_rabin.miller_rabin(77228969362076174340113658373, 0)
with pytest.raises(OverflowError):
miller_rabin.miller_rabin(77228969362076174340113658373, 1 << 64)
with pytest.raises(TypeError):
miller_rabin.miller_rabin(1.0)
with pytest.raises(TypeError):
miller_rabin.miller_rabin("1")
with pytest.raises(TypeError):
miller_rabin.miller_rabin(1, 1.0)
with pytest.raises(TypeError):
miller_rabin.miller_rabin(1, "1")
with pytest.raises(TypeError):
miller_rabin.miller_rabin()
with pytest.raises(TypeError):
miller_rabin.miller_rabin(1, 2, 3)
with pytest.raises(TypeError):
miller_rabin.miller_rabin(n=1)
with pytest.raises(TypeError):
miller_rabin.miller_rabin(1, k=1)
def next_prime(p):
next_p = p + 1
while not miller_rabin(next_p) or not miller_rabin((next_p - 1) / 2):
next_p += 1
return next_p
from RSA import RSA
from OAEP import RSA_OAEP
from miller_rabin import miller_rabin
BYTES_IN_KILOBYTE = 10**3
BYTES_IN_MEGABYTE = 10**6
BYTES_IN_GIGABYTE = 10**9
def runMode(mode, msg):
c = mode.encrypt(msg)
m = mode.decrypt(c)
assert m.hex() == msg.hex()
if __name__ == "__main__":
inp = os.urandom(10 * BYTES_IN_MEGABYTE)
# inp = os.urandom(BYTES_IN_KILOBYTE)
# rsa = RSA(64)
# oaep = RSA_OAEP()
# runMode(rsa, inp)
# runMode(oaep, inp)
t1 = time.time()
for _ in progressbar(range(100)):
miller_rabin(
2074722246773485207821695222107608587480996474721117292752992589912196684750549658310084416732550077
)
t2 = time.time()
print((t2 - t1) / 100)
def test_true(self):
# Makes sure the test returns true for primes
for prime in self.prime_set:
self.assertTrue(miller_rabin(prime, prime))
def is_prime(n):
if type(n) is not int:
raise TypeError("n must be an integer")
if n < 2:
raise ValueError("n must be greater than 1")
return miller_rabin(n)
def test_false(self):
# Makes sure the test returns false for non-primes
for notPrime in self.not_primes:
self.assertFalse(miller_rabin(notPrime, notPrime))
#!/usr/bin/env python3
import miller_rabin
LIMIT = 5 * 10**15
def main():
n = 1
count = 0
while (p := n * n + (n + 1) * (n + 1)) < LIMIT:
if n % 1_000_000 == 0:
print(f"progress: {n:,}")
if miller_rabin.miller_rabin(p):
count += 1
n += 1
print(count)
if __name__ == "__main__":
main()
def __validate_prime(self, p, n):
if not miller_rabin(p, l):
raise Exception("Please provide a valid prime")
q = n / p
if not miller_rabin(q, l):
raise Exception("Prime is invalid for this n")
