def generate_sparse_matrix(u_1, modified_secret_key, x_p):
global global_random_state
seed = mpz(time.time())
global_random_state = gmpy2.random_state(seed)
Theta_vector = [0 for _ in range(Theta)]
for i in range(1, Theta):
Theta_vector[i] = generate_random(kappa + 1, False, True, False)
modified_secret_key[0] = True
for i in range(1, Theta):
modified_secret_key[i] = False
count = theta - 1
gmpy2.random_state()
while count > 0:
index = gmpy2.mpz_random(global_random_state, RAND_MAX) % Theta
if not modified_secret_key[index]:
modified_secret_key[index] = True
count -= 1
sum_ = zero
temp = gmpy2.mul_2exp(one, kappa + 1)
for i in range(1, Theta):
if modified_secret_key[i]:
sum_ = gmpy2.add(sum_, Theta_vector[i])
sum_ %= temp
u_1 = gmpy2.sub(x_p, sum_)
if u_1 < zero:
u_1 = gmpy2.add(temp, u_1)
return mpz(seed), mpz(u_1)
def distributed_Paillier_key_generation(self):
self.generator = self.N + 1
self.modulus_KN = self.secure_K * self.N
self.modulus_KKN = self.secure_K * self.secure_K * self.N
random_state = gmpy2.random_state(int(time.time() * 100000))
self.beta = gmpy2.mpz_random(random_state, self.modulus_KN)
random_state = gmpy2.random_state(int(time.time() * 100000))
self.ri = gmpy2.mpz_random(random_state, self.modulus_KKN)
self.ri_delta = self.delta * self.ri
self.pq_sum = self.pi + self.qi
self.send_pq_sum(self.pq_sum)
pq_sum_list = self.receive_pq_sum_list()
self.phi = self.N + 1 - pq_sum_list[0] - pq_sum_list[1] - pq_sum_list[2]
self.thetai = self.delta * self.phi * self.beta + self.N * self.delta * self.ri
self.send_thetai(self.thetai)
thetai_list = self.receive_thetai_list()
self.theta = thetai_list[0] + thetai_list[1] + thetai_list[2]
self.fi = self.N * self.Ri_sharing(self.ri_delta,
self.modulus_KKN) - self.theta
# verification key
self.r_vk = self.gen_coprime(self.N * self.N)
self.vk = gmpy2.powmod(self.r_vk, 2, self.N * self.N)
self.vki = gmpy2.powmod(self.vk, self.delta * self.fi, self.N * self.N)
def computeProducts(self):
lf = DEFAULT_PRECISION
# Compute LCA encrypted
prod_LCA = Mult3Matrix(self.enc_L, self.enc_C, self.enc_A,
self.enc_bLC, self.enc_bLA, self.enc_bCA)
self.enc_LCA = prod_LCA
# Compute Gamma2 = (I-LC)BK = BK - LCBK = Gamma3*K
enc_Gamma2 = np.dot(self.enc_Gamma3, self.enc_K)
rGamma2 = [[
gmpy2.mpz_urandomb(gmpy2.random_state(), self.l + lf + self.sigma)
for i in range(self.n)
] for j in range(self.n)]
self.rGamma2 = util_fpv.vfp(rGamma2, -lf)
# Compute Gamma = (I-LC)(A+BK) = A + BK - LCA - LCBK, they have different precisions
enc_Gamma = (
np.dot(self.enc_A, 2**(2 * lf) * np.eye(self.n, dtype=object)) -
prod_LCA +
np.dot(enc_Gamma2, 2**lf * np.eye(self.n, dtype=object)))
rGamma = [[
gmpy2.mpz_urandomb(gmpy2.random_state(),
self.l + 2 * lf + self.sigma)
for i in range(self.n)
] for j in range(self.n)]
self.rGamma = util_fpv.vfp(rGamma, -2 * lf)
return enc_Gamma + rGamma, enc_Gamma2 + rGamma2
def elliptical_curve(n, process_id):
# I decided not to finish the implementation of this algo as the learning curve for implementation was steep
# and not worth it. I left this code here to show that I tried though.
print("Pollard p-1 Part 2: The Lenstra Boogolo")
print(process_id, "ECM Called")
# vars to maintain the generation loop
coor_x, coor_y = 0, 0
# generate curve
# TODO: Not sure if these random ranges are correct
coor_x, coor_y = gmpy2.mpz_random(gmpy2.random_state(),
n), gmpy2.mpz_random(
gmpy2.random_state(), n)
a = gmpy2.mpz_random(gmpy2.random_state(), n)
# b = y^2 - ax - x^3
b = gmpy2.f_mod((coor_y * coor_y - a * coor_x - coor_x * coor_x * coor_x),
n)
# TODO: The wikipedia says there's checks you can do for the curve at this point by I don't want to put in the
# effort, however this note is here as a reminder in case things aren't working
# (while loop to check this stuff?)
# is this the right check? (delta)
# generate point
curr_x = coor_x
curr_y = coor_y
# range to loop to
current = 2
work_limit = random.randint(10000000, 1000000000)
# loop to do the monster math
# TODO: loop to do the actual ECM stuff
# return value since this is broken and un finished
return 1
def generate_x(x, sk):
gmpy2.random_state()
q, r = 0, 0
q = generate_random(gamma - eta, False, False, False)
r = generate_random(rho, True, False, False)
x = gmpy2.mul(q, sk)
x = gmpy2.add(r, x)
return mpz(x)
def share(x, N):
# P1
random_state = gmpy2.random_state(int(time.time() * 10000))
x1 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10001))
x2 = gmpy2.mpz_random(random_state, N)
x3 = (x - x1 - x2) % N
return [x1, x2, x3]
def generate_q():
q = gmp.mpz_urandomb(gmp.random_state(random.randint(0, 367263292)), N)
while not gmp.is_prime(q):
q = gmp.next_prime(q)
if no_bits(q) != N:
q = gmp.mpz_urandomb(
gmp.random_state(random.randint(0, 367263292)), N)
return q
def mult(share_tuple, N):
share_sum = (share_tuple[0] + share_tuple[1] + share_tuple[2]) % N
share_sum_square = (share_sum * share_sum) % N
random_state = gmpy2.random_state(int(time.time() * 10000))
share1 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10001))
share2 = gmpy2.mpz_random(random_state, N)
share0 = (share_sum_square - share1 - share2) % N
return [share0, share1, share2]
def ranp(N):
# P1
random_state = gmpy2.random_state(int(time.time() * 10000))
a11 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10001))
a12 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10002))
a13 = gmpy2.mpz_random(random_state, N)
# P2
random_state = gmpy2.random_state(int(time.time() * 10000))
a21 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10001))
a22 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10002))
a23 = gmpy2.mpz_random(random_state, N)
# P3
random_state = gmpy2.random_state(int(time.time() * 10000))
a31 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10001))
a32 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10002))
a33 = gmpy2.mpz_random(random_state, N)
# compute sharing
a1 = (a11 + a21 + a31) % N
a2 = (a12 + a22 + a32) % N
a3 = (a13 + a23 + a33) % N
return (a1, a2, a3)
def encrypt(pub, plain):
one = gmpy2.mpz(1)
state = gmpy2.random_state(int_time())
r = gmpy2.mpz_random(state, pub.n)
while gmpy2.gcd(r, pub.n) != one:
state = gmpy2.random_state(int_time())
r = gmpy2.mpz_random(state, pub.n)
x = gmpy2.powmod(r, pub.n, pub.n_sq)
cipher = gmpy2.f_mod(gmpy2.mul(gmpy2.powmod(pub.g, plain, pub.n_sq), x),
pub.n_sq)
return cipher
def PRandFld(modulus):
# P1
random_state = gmpy2.random_state(int(time.time() * 10000))
a1 = gmpy2.mpz_random(random_state, int(modulus/3))
# P2
random_state = gmpy2.random_state(int(time.time() * 10000))
a2 = gmpy2.mpz_random(random_state, int(modulus/3))
# P3
random_state = gmpy2.random_state(int(time.time() * 10000))
a3 = gmpy2.mpz_random(random_state, int(modulus/3))
return (a1, a2, a3)
def random(cls, allow_inf=True) -> 'FPVector':
bias = (1 << (cls.exponent_size - 1)) - 1
if allow_inf:
sign = random.choice([-1, 1])
mantissa = gmpy2.mpfr_random(gmpy2.random_state()) + 1
exp = random.randint(1 - bias, bias + 1)
return cls(mantissa * sign * (gmpy2.mpfr(2)**gmpy2.mpfr(exp)))
else:
sign = random.choice([-1, 1])
mantissa = gmpy2.mpfr_random(gmpy2.random_state()) + 1
exp = random.randint(1 - bias, bias)
return cls(mantissa * sign * (gmpy2.mpfr(2)**gmpy2.mpfr(exp)))
def generate_x_i(sk, length):
tmp, q, r = 0, 0, 0
q = gmpy2.mul_2exp(one, length - 1)
gmpy2.random_state()
for i in range(length - 32, 0 - 1, -32):
tmp = gmpy2.get_random()
tmp = gmpy2.mul_2exp(tmp, i)
q = gmpy2.add(tmp, q)
q = gmpy2.add(q, gmpy2.get_random())
r = generate_random(rho, True, False, False)
x_i = gmpy2.mul(q, sk)
x_i = gmpy2.add(r, x_i)
return x_i
def new_prime(n_bits=1024):
"""
is_prime: Miller-Rabin's test (default=25 times)
"""
upper_bound = gmpy2.mpz(2**n_bits)
state = gmpy2.random_state(int_time())
rand_num = gmpy2.mpz_random(state, upper_bound)
rand_num = gmpy2.bit_set(rand_num, n_bits - 1)
while not gmpy2.is_prime(rand_num):
state = gmpy2.random_state(int_time())
rand_num = gmpy2.mpz_random(state, upper_bound)
rand_num = gmpy2.bit_set(rand_num, n_bits - 1)
return rand_num
def gen_keys():
rs = gmpy2.random_state(hash(gmpy2.random_state()))
P = gmpy2.mpz_urandomb(rs, mpz('128'))
P = gmpy2.next_prime(P)
Q = gmpy2.mpz_urandomb(rs, mpz('128'))
Q = gmpy2.next_prime(Q)
N = P*Q
Fi = (P-1)*(Q-1)
Pkey = gmpy2.mpz_random(rs, Fi)
while not (gmpy2.gcd(Fi, Pkey) == 1):
Pkey = gmpy2.mpz_random(rs, Fi)
Skey = gmpy2.invert(Pkey, Fi)
assert gmpy2.t_mod(Skey*Pkey,Fi) == 1
return Pkey, Skey, N
def getStrongPrime():
bit_count = 512
rand_state = gmp.random_state(getRandomSeed())
rand_no = gmp.mpz_rrandomb(rand_state, bit_count)
p1 = getNextPrime(rand_no)
p2 = getNextPrime(p1)
p3 = getNextPrime(p2)
while (not StrongPrime(p1, p2, p3)):
rand_state = gmp.random_state(getRandomSeed())
rand_no = gmp.mpz_rrandomb(rand_state, bit_count)
p1 = getNextPrime(rand_no)
p2 = getNextPrime(p1)
p3 = getNextPrime(p2)
return p2
def get_gpq():
randnum = gmpy2.random_state(int(1000 * time.time()))
Len_p = 1024
Len_q = 256
Len_t = 768
p = 4
q = gmpy2.mpz_urandomb(randnum, Len_q)
q = gmpy2.next_prime(q)
while not gmpy2.is_prime(p):
t = gmpy2.mpz_urandomb(randnum, Len_t)
p = t * q + 1
g = 1
while not g > 1:
r = gmpy2.mpz_urandomb(randnum, Len_p)
g = gmpy2.powmod(r, t, p)
f = open('gpq.txt', 'w')
print('g = ', g)
print('p = ', p)
print('q = ', q)
f.write('g = ' + str(g) + '\n')
f.write('p = ' + str(p) + '\n')
f.write('q = ' + str(q))
f.close()
def __init__(self):
try:
a = os.urandom(32)
self.rs = gmpy2.random_state(int(a.encode('hex'), 16))
except:
print "Problem initializing PRNG"
sys.exit()
def recrypt_util(self, encrypted_z, ct, PKC):
global global_random_state
u_i = [mpz() for i in range(Theta)]
u_i[0] = mpz(self.u_1)
global_random_state = gmpy2.random_state(self.seed)
for i in range(1, Theta):
u_i[i] = generate_random(kappa + 1, False, True, False)
z_i = []
den = mpz(gmpy2.mul_2exp(1, kappa))
Sum = binary_real(zero, one, n + e)
for i in range(Theta):
num = u_i[i] * ct
z_i.append(binary_real(num, den, n + e))
for i in range(Theta):
for j in range(n + 1 + e):
if j == 0:
if z_i[i].decimal == 1:
encrypted_z[i][j] = mpz(1)
else:
encrypted_z[i][j] = mpz(0)
else:
if z_i[i].value[j - 1] is True:
encrypted_z[i][j] = mpz(1)
else:
encrypted_z[i][j] = mpz(0)
def _random_int(self, modulo):
"""Generate a random number modulo the supplied argument"""
r_seed = int(os.urandom(32).encode('hex'), 16)
r_state = gmp.random_state(r_seed)
raw = gmp.mpz_urandomb(r_state, self.RANDOM_BITS)
return gmp.t_mod(raw, modulo)
def _generate_random_number(self):
"""
:return: random number
"""
rstate = random_state()
r = randint(40, 100)
return f_mod(mpz_random(rstate, 2 << r).bit_set(0).bit_set(r), self.N)
def generate_random(bit_size, include_negative_range, seeded, full_range):
global global_random_state
if not seeded or global_random_state is None:
global_random_state = gmpy2.random_state()
x = zero
if full_range:
x = gmpy2.mul_2exp(one, bit_size - 1)
tmp = 0
if bit_size < 33:
tmp = gmpy2.mpz_random(global_random_state, RAND_MAX)
temp = (1 << bit_size)
x = gmpy2.f_mod(tmp, temp)
if include_negative_range:
tmp = gmpy2.mul_2exp(one, bit_size - 1)
x = gmpy2.sub(x, tmp)
return x
for i in range(bit_size - 32, 0 - 1, -32):
tmp = gmpy2.mpz_random(global_random_state, RAND_MAX)
tmp = gmpy2.mul_2exp(tmp, i)
x = gmpy2.add(x, tmp)
x = gmpy2.add(x, gmpy2.mpz_random(global_random_state, RAND_MAX))
if include_negative_range:
tmp = gmpy2.mul_2exp(one, bit_size - 1)
x = gmpy2.sub(x, tmp)
return mpz(x)
def _random_int(self, modulo):
"""Generate a random number modulo the supplied argument"""
r_seed = int(os.urandom(32).encode('hex'), 16)
r_state = gmp.random_state(r_seed)
raw = gmp.mpz_urandomb(r_state, self.RANDOM_BITS)
return gmp.t_mod(raw, modulo)
def mult_share(share_tuple_1, share_tuple_2, N):
if not isinstance(share_tuple_1, list):
share_1 = share_tuple_1
else:
share_1 = (share_tuple_1[0] + share_tuple_1[1] + share_tuple_1[2]) % N
if not isinstance(share_tuple_2, list):
share_2 = share_tuple_2
else:
share_2 = (share_tuple_2[0] + share_tuple_2[1] + share_tuple_2[2]) % N
share_mult = (share_1 * share_2) % N
random_state = gmpy2.random_state(int(time.time() * 10000))
share1 = gmpy2.mpz_random(random_state, N)
random_state = gmpy2.random_state(int(time.time() * 10001))
share2 = gmpy2.mpz_random(random_state, N)
share0 = (share_mult - share1 - share2) % N
return [share0, share1, share2]
def algorithmRabin_Miller(n, s): random_state = gmpy2.random_state(int(round(time() * 1000))) for j in range (1, s+1): a = gmpy2.mpz_random(random_state, n) if algorithmWitness(a, n) == 1: return 1 return 0
def DGK_s1(self, b):
l = self.l
nc = self.nc
self.delta_A = [0] * nc
c_all = [[0] * l] * nc
for k in range(0, nc):
beta = b[k]
alpha = self.alpha[k]
DGK_pubkey = self.DGK_pubkey
delta_A = np.random.randint(0, 2)
self.delta_A[k] = delta_A
prod = [0] * l
c = [DGK_pubkey.raw_encrypt(0)] * l
# index 0 is the MSB
for i in range(0, l):
if (int(alpha[i]) == 0):
prod[i] = beta[i]
else:
prod[i] = DGK.diff_encrypted(
DGK_pubkey.raw_encrypt(1, self.coinsDGK.pop()),
beta[i], DGK_pubkey)
if (int(delta_A) == int(alpha[i])):
if i == 0:
c[i] = DGK_pubkey.raw_encrypt(0, self.coinsDGK.pop())
else:
for iter in range(0, i):
c[i] = DGK.add_encrypted(c[i], prod[iter],
DGK_pubkey)
if (int(delta_A) == 0):
diff = DGK.diff_encrypted(
DGK_pubkey.raw_encrypt(1, self.coinsDGK.pop()),
beta[i], DGK_pubkey)
c[i] = DGK.add_encrypted(c[i], diff, DGK_pubkey)
else:
c[i] = DGK.add_encrypted(c[i], beta[i], DGK_pubkey)
for i in range(0, l):
if (int(delta_A) == int(alpha[i])):
r = gmpy2.mpz_urandomb(gmpy2.random_state(),
self.sigma + self.sigma)
c[i] = DGK.mul_sc_encrypted(c[i], r, DGK_pubkey)
else:
c[i] = DGK_pubkey.raw_encrypt(
gmpy2.mpz_urandomb(gmpy2.random_state(),
self.sigma + self.sigma),
self.coinsDGK.pop())
c_all[k] = np.random.permutation(c)
return c_all
def random_prime(size):
seed = int.from_bytes(os.urandom(16), byteorder='little')
state = gmpy2.random_state(seed)
rnd = gmpy2.mpz_rrandomb(state, size)
while True:
prime = gmpy2.next_prime(rnd)
if prime.bit_length() == size:
return prime
def generate_random_factored_numbers_with_multiplicative_group_mp(
n, seed, num):
global random_state
random_state = gmpy2.random_state(seed)
for i in range(num):
r = process_r_with_multiplicative_group(n)
complete_multiplicative_group_hint(r[1], r[2])
output.put(r)
def gen_keys():
rs = gmpy2.random_state(hash(gmpy2.random_state()))
P = gmpy2.mpz_urandomb(rs, mpz('256'))
P = gmpy2.next_prime(P)
Q = gmpy2.mpz_urandomb(rs, mpz('256'))
Q = gmpy2.next_prime(Q)
N = P*Q
Fi = (P-1)*(Q-1)
Pkey = gmpy2.mpz_random(rs, Fi)
while not (gmpy2.gcd(Fi, Pkey) == 1):
Pkey = gmpy2.mpz_random(rs, Fi)
Skey = gmpy2.invert(Pkey, Fi)
print('Публичный ключ: ')
print(Pkey)
print('Приватный ключ:')
print(Skey)
print('N:')
print(N)
def generate_keys(q, p, g):
# generates private key x and public key y
x = gmp.mpz_random(gmp.random_state(random.randint(0, 367263292)), q)
while x == 0:
x = gmp.mpz_random(random.randint(0, 367263292), q)
y = gmp.powmod(g, x, p)
return x, y
def primoRelativo(self, phi):
x = 0
mdc = 0
seed = gmpy2.random_state(int(datetime.now().microsecond))
while mdc != 1:
x = gmpy2.mpz_random(seed,phi ) + 1
mdc = self.euclides(x, phi)
return x
def test_pack_unpack(repeat):
"""Test gmpy2.pack and gmpy2.unpack."""
r = gmpy2.random_state(42)
for counter in range(repeat):
for t in (10, 1000, 2000, 10000, 100000):
v = gmpy2.mpz_rrandomb(r, t)
for b in range(1, max(1001,t)):
temp = gmpy2.unpack(v, b)
u = gmpy2.pack(temp, b)
assert u == v
def pick_pq(self):
pq = mpz(2)
random_state = gmpy2.random_state(int(time.time()*100000))
if self.PartyIndex == 1:
while gmpy2.f_mod(pq, 4) != 3 or (pq - pow(2, self.KeyLength - 1) <= 0):
pq = gmpy2.mpz_random(random_state, pow(2, self.KeyLength))
else:
while gmpy2.f_mod(pq, 4) != 0 or (pq - pow(2, self.KeyLength - 1) <= 0):
pq = gmpy2.mpz_random(random_state, pow(2, self.KeyLength))
return pq
def keygen():
rs = gmpy2.random_state(int(time.time()))
p = get_prime(rs)
q = get_prime(rs)
n = p * q
e = 0x10001
pk = [n, e]
d = gmpy2.invert(e, (p - 1) * (q - 1))
sk = d
return pk, sk
def aby_prng(Len):
"""Generates a random mpz with bitlength Len."""
global global_random_state
if global_random_state is None:
global_random_state = gmpy2.random_state(int(time.time()))
result = mpz(0)
for i in range(Len):
if gmpy2.mpz_random(global_random_state, 2) == 1:
result += gmpy2.exp2(i)
return mpz(result)
def keygen(size):
rs = gmpy2.random_state(int(time.time()))
p = gmpy2.next_prime(gmpy2.mpz_urandomb(rs, size))
while p % 4 != 3:
p = gmpy2.next_prime(p)
q = gmpy2.next_prime(p)
while q % 4 != 3:
q = gmpy2.next_prime(q)
n = p*q
x = n-1
return (x, n), (p, q)
def break_keygen(n):
start_val = 1475784906
while True:
rs = gmpy2.random_state(start_val)
p = gmpy2.next_prime(gmpy2.mpz_urandomb(rs, 2048))
while p % 4 != 3:
p = gmpy2.next_prime(p)
if n % p == 0:
print p
break
start_val -= 1
def test(repeat=1):
"""Test gmpy2.pack and gmpy2.unpack."""
r = gmpy2.random_state(42)
try:
for counter in range(repeat):
for t in (10, 30, 60, 500, 1000, 2000, 10000, 100000):
v = gmpy2.mpz_rrandomb(r, t)
for b in range(1, max(1001,t)):
temp = gmpy2.unpack(v, b)
u = gmpy2.pack(temp, b)
if u != v:
raise ValueError
return True
except ValueError:
return False
'''
Created on Feb 25, 2014
@author: NASSAR
'''
import random
import sys
from gmpy2 import mpz, powmod, invert, is_prime, random_state, mpz_urandomb
import time
rand=random_state(random.randrange(sys.maxsize))
def timing(f, c=0):
def wrap(*args):
time1 = time.time()
ret = f(*args)
time2 = time.time()
clocktime=time2-time1
print ('%s function took %0.3f ms' % (f.__name__, (clocktime)*1000.0))
if c==0:
return ret
else:
return ret, clocktime
return wrap
def generate_prime(bits):
"""Will generate an integer of b bits that is prime
using the gmpy2 library """
def get_random_int(n):
i = random.randint(0,2**30) # better random nunber generator
return gmpy2.mpz_random(gmpy2.random_state(i), n)
def random():
seed = int(os.urandom(BYTES).encode('hex'), 16)
return gmpy2.mpfr_random(gmpy2.random_state(seed))
import time
def timing(f, c=0):
def wrap(*args):
time1 = time.time()
ret = f(*args)
time2 = time.time()
clocktime=time2-time1
print '%s function took %0.3f ms' % (f.func_name, (clocktime)*1000.0)
if c==0:
return ret
else:
return ret, clocktime
return wrap
rand=random_state(random.randrange(sys.maxint))
def generate_prime(bits):
"""Will generate an integer of b bits that is prime
using the gmpy2 library """
while True:
possible = mpz(2)**(bits-1) + mpz_urandomb(rand, (bits-1) )
if is_prime(possible):
return possible
if __name__ == '__main__':
#testing
p=generate_prime(1024)
print p
print p.bit_length()
t_generate_prime=timing(generate_prime,1)
def gerarPrimo(self, limInf, limSup):
seed = gmpy2.random_state(int(datetime.now().microsecond))
primo = gmpy2.mpz_random(seed,(limSup - limInf + 1)) + limInf
while not gmpy2.is_prime(primo):
primo = gmpy2.mpz_random(seed,(limSup - limInf + 1)) + limInf
return primo
#!/usr/bin/env python
'''
Created on 18 Jul 2014
@author: henryk
'''
import gmpy2,time
rstate = gmpy2.random_state()
def get_prime(length):
a = gmpy2.mpz_random(rstate,2<<length).bit_set(0).bit_set(length)
while not gmpy2.is_prime(a):
a = a+2
return a
def generate_rsa(length):
p = get_prime(length/2)
q = get_prime(length - length/2)
n = p * q
phi_n = (p-1)*(q-1)
e = 65537
d = gmpy2.powmod(e, -1, phi_n)
return e,d,n
if __name__ == '__main__':
for i in range(5,13):
start = time.time()
e,d,n = generate_rsa(2<<i)
stop = time.time()
import gmpy2 from gmpy2 import mpz import time import math mr_accuracy = 100 random_state = gmpy2.random_state(int(time.time())) rand_min = 3600 rand_max = pow(2, 82) def RandomInteger(Min = rand_min, Max = rand_max): return Min + gmpy2.mpz_random(random_state, Max - Min + 1) def RandomPrimeInteger(Min = rand_min, Max = rand_max): out = RandomInteger(Min, Max); while not gmpy2.is_prime(out, mr_accuracy): out = RandomInteger(Min, Max) return out
