def main(N):
c=gmpy2.context()
c.precision=len(str(N))+20
c.real_prec=len(str(N))+20
gmpy2.set_context(c)
assert N==gmpy2.mpz(N)
N=gmpy2.mpz(N)
A=find_sqrt(N)
A = gmpy2.mpz(A)
assert ( (A-1)**2<N<A**2 ),'not found'
Atag = A
for iA in xrange(-2**20,2**20):
A = Atag + iA
s =A**2-N
x = gmpy2.sqrt(s)
try:
x = gmpy2.mpz(x)
except:continue
print x**2 > s , x**2 < s
'''while x**2>s:
x-=1
print 1,'''
print x**2 > s , x**2 < s
p = A-x
q = A+x
q = N/p
if p*q==N:
print gmpy2.is_prime(q)
print gmpy2.is_prime(p)
print min(p,q)
break
def checkFactors(p,q,N):
x = g.f_mod( N, p )
y = g.f_mod( N, q )
zero = g.mpz('0')
if g.is_prime(p) and g.is_prime(q):
return N == g.mul(p,q) and x == zero and y == zero
return False
def main23(N):
c=gmpy2.context()
c.precision=len(str(N))+20
c.real_prec=len(str(N))+20
gmpy2.set_context(c)
assert N==gmpy2.mpz(N)
N=gmpy2.mpz(N)
A=find_sqrt(6*N)
A = gmpy2.mpz(A)
assert ( (A-1)**2<6*N<A**2 ),'not found'
Atag = A
for iA in xrange(-2**20,2**20):
A = Atag + iA
s =A**2-N
x = gmpy2.sqrt(s)
try:
x = gmpy2.mpz(x)
except:continue
'''print x**2 > s , x**2 < s
while x**2>s:
x-=1
print 1,
print x**2 > s , x**2 < s'''
for p in [(A-x)/2,(A-x)/3,(A+x)/2,(A+x)/3 ]:
q = N/p
if p*q==N:
print gmpy2.is_prime(q)
print gmpy2.is_prime(p)
print min(p,q)
assert False,'bla'
def factor_N3(N): '''Factor in correctly genrated N, which is a product of two relatively close primes p/q such that, |3p-2q| < N^(1/4)''' N = mpz(N) M = 2*gmpy2.isqrt(6*N)+1 # M = (3p+2q) # M = (3p+2q) # x = (3p-2q) x = gmpy2.isqrt(M*M - 24*N) # X = (3p-2q) # since p,q is not symmetric around M/2, we need to consider two cases p1 = (M+x)/6 q1 = (M-x)/4 p2 = (M-x)/6 q2 = (M+x)/4 if gmpy2.is_prime(p1) and gmpy2.is_prime(q1) and p1*q1 == N: if p1<q1: return p1,q1 else: return q1,p1 if gmpy2.is_prime(p2) and gmpy2.is_prime(q2) and p2*q2 == N: if p2<q2: return p2,q2 else: return q2,p2 return 0
def factor_prime(prime):
# p - 1 is 37-smooth
base = 2
k_sm = 37
# pow(base,k_sm!) mod prime
a = gmpy2.powmod(base, gmpy2.fac(k_sm), prime)
# gcd(r_k - 1, prime)
p = gmpy2.gcd(a-1, prime)
# get second factor of prime
q = (prime / p)
# make sure factors (pq) are prime
if (gmpy2.is_prime(p) and gmpy2.is_prime(q)):
print "p = ", p
print "q = ", q
# make sure n = p*q = prime number
n = gmpy2.mul(p,q)
if (n == prime):
print "n = ", gmpy2.mul(p,q)
return
def confirmed(N, p, q):
if gmpy2.is_prime(mpz(p)) and gmpy2.is_prime(mpz(q)) and N == gmpy2.mul(p, q):
print "N =", N
print "p =", p
print "q =", q
print "confirmed prime factors, smaller prime:"
print q if p > q else p
return True
return False
def get_safe_prime(bits):
"""Get a safe prime which is a specified number of bits long."""
while True:
# Generate a random 1024 bit number, ensuring the lowest order bit is 1 (so it's odd).
candidate = (get_random(bits - 1) << 1) | 1
if candidate % 12 != 11:
continue # all safe primes mod 12 are 11
if not is_prime(candidate):
continue # obviously a safe prime must be prime
if not is_prime((candidate - 1) // 2):
continue # a safe prime must be equal to 2q + 1 where q is prime
return candidate
def challenge1 (N):
"""Factor N=p*q where abs(p-q) < 2*N**(1/4)"""
N = mpz(N)
A = isqrt(N)
while 1:
# A = (p+q)/2 is also ceil(sqrt(N)) indeed (A-sqrt(N)) < 1
# x integer such that p = A - x, q = A + x; x = sqrt(A*A - N)
if pow(A, 2) > N:
x = isqrt(pow(A, 2) - N)
p = A - x
q = A + x
if ((mul(p,q) == N) and is_prime(p) and is_prime(q)):
return (p,q)
A = A + 1
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
def __init__(self,N):
self.N=N
if gmpy2.is_prime(self.N):
#if self.isPrime(N):
self.prime=True
else:
self.prime=False
def checkTruncPrime(n, found, lprimes, rprimes):
isPrime= gmpy2.is_prime(int(n))
good = True
nsl1=n[1:]
if not rprimes.has_key(nsl1):
good = False
else:
if isPrime:
rprimes[n] = 0;
nsr1=n[:-1]
if not lprimes.has_key(nsr1):
good = False
else:
if isPrime:
lprimes[n] = 0;
# is it good both ways?
if not good:
return False
if not isPrime:
return False
if result.has_key(nsl1):
result[nsl1] = 1 # mark as substring of bigger tprime
if result.has_key(nsr1):
result[nsr1] = 1 # mark as substring of bigger tprime
result[n] = 0 # add new item
return True
def __init__(self, p=None, q=None, bit_length=512, e=None):
"""
设定 p 和 q, 如果没有则根据 bit_length 来产生对应长度的素数
:param p: 素数 p
:param q: 素数 q
:param bit_length: 比特位的长度
"""
if p and q and gmpy2.is_prime(p) and gmpy2.is_prime(q):
self.p = p
self.q = q
else:
print("[*] 未给定合理的 p 和 q, 程序将自行产生")
self.p = getPrime(bit_length)
self.q = getPrime(bit_length)
self.__create_rsa(e)
def check(p):
x = p//10
sd = sumdigits(x)
while(x>0):
xx = x%sd
if xx != 0:
return False
sd-= x%10
x//=10
x=p//10
if not gmpy2.is_prime(x//sumdigits(x)):
return False
if not gmpy2.is_prime(p):
return False
return True
def factorize(x):
r"""
>>> factorize(a)
[3, 41]
>>> factorize(b)
[2, 2, 2, 3, 19]
>>>
"""
savex = x
prime = 2
x = _g.mpz(x)
factors = []
while x >= prime:
newx, mult = _g.remove(x, prime)
if mult:
factors.extend([int(prime)] * mult)
x = newx
prime = _g.next_prime(prime)
for factor in factors:
assert _g.is_prime(factor)
from operator import mul
from functools import reduce
assert reduce(mul, factors) == savex
return factors
def new_prime():
np = mpz(r.getrandbits(DH_Consts.bits - 1))
np = gmpy2.next_prime(np)
while not gmpy2.is_prime(2 * np + 1, 25):
np = gmpy2.next_prime(np)
return mpz(2 * np + 1)
def isTruncatable(n): nleft = str(n) nright = str(n) # check from left while len(nleft) > 0: if not is_prime(int(nleft)): return False nleft = nleft[:-1] # check from right while len(nright) > 0: if not is_prime(int(nright)): return False nright = nright[1:] return True
def main():
# first make a dummy request to find the public modulus for our team
initial_request = {"team": TEAM, "ciphertext": "00"*(n//8)}
r = requests.post(SERVER_URL + "/decrypt", data=json.dumps(initial_request))
try:
N = int(r.json()["modulus"], 16)
except:
print(r.text)
sys.exit(1)
# compute R^{-1}_N
Rinv = gmpy2.invert(R, N)
# Start with a "guess" of 0, and analyze the zero-one gap, updating our
# guess each time. Repeat this for the (512-16) most significant bits of q
g = 0
# get bits 2-5
start_bits = 2
max_i = 0
max_t = 0
for i in range(1, 2**start_bits):
t_1 = 0
for j in range(1024):
t_1 += time_decrypt(gmpy2.mpz(i * 2**(511 - start_bits) + 2**511 + j))
print(i, t_1)
if t_1 > max_t:
max_t = t_1
max_i = i
print("MAX:", max_i, max_t)
g += max_i*2**(511 - start_bits) + 2**511
# Q -= g
for i in range(start_bits + 2, 512-16):
gap = compute_gap(g, i, Rinv, 50, N)
# TODO: based on gap, decide whether bit (512 - i) is 0 or 1, and
# update g accordingly
# bit = Q // (2**(512 - i))
# print("gap:", gap, "\t bit at index", i, "should be", bit)
# if bit == 1:
# Q -= 2**(512 - i)
# g += 2**(512 - i)
print("gap:", gap, "\t bit at index", i)
if gap < threshold:
g += 2**(512 - i)
# brute-force last 16 bits
for i in range(2**16):
q = g + i
if gmpy2.is_prime(q):
if submit_guess(q):
print("hooray:", q)
break
def next_prime(x):
"""Return the next probable prime number > x."""
if x <= 1:
x = 2
else:
x += 1 + x%2
while not is_prime(x):
x += 2
return x
def gen_rand_prime(bit):
while 1:
num = gmpy2.mpz(1)
a = randint(0, 2, bit)
for i in a:
num = num * 2 + i
if gmpy2.is_prime(num):
break
return num
def num_consecutive_primes_fitness(self, interval):
i = interval[0]
last_x = 0
x = self.eval_polynomial(np.array([i]))[0]
while is_prime(int(x)) and last_x != x and x > 0:
i += 1
last_x = x
x = self.eval_polynomial(np.array([i]))[0]
return i
def count_valids(s, minp=1):
if len(s) == 0:
return 1
nvalids = 0
for i in range(1, len(s) + 1):
p = int(s[:i])
if p > minp and is_prime(p):
nvalids += count_valids(s[i:], p)
return nvalids
def getFactor(x):
if gmpy2.is_prime(x):
factor=x-1
else:
if len(str(x)) <= 20:
factor=phi(x)
else:
factor=None
return factor
def generate_m(p):
""" Generate large pseudo prime m, which satisfy p|(m-1) .
"""
q=1
m=p*2*q+1
while not gmpy2.is_prime(m):
q=q+1
m= p*2*q+1
return m,q
def p41(l):
tmp = []
while l > 3:
i = list(map(str,range(1,l+1)))
for N in map(lambda x:int("".join(list(x))), permutations(i)):
a = is_prime(N)
if a == True:
tmp.append(N)
l-=1
return sorted(tmp)[-1]
def createPrime(sizeOFMod):
x = 0
while x == 0:
upperBit = math.pow(2, sizeOFMod) - 1
lowerBit = math.pow(2, (sizeOFMod - 1))
potentialPrime = random.randint(lowerBit, upperBit)
if gmpy2.is_prime(potentialPrime):
return potentialPrime
def gen_prime(bits, s):
#s = random.getrandbits(chunk_size)
while True:
s |= 0xc000000000000001
p = 0
for _ in range(bits // chunk_size):
p = (p << chunk_size) + s
s = a * s % 2**chunk_size
if gmpy2.is_prime(p):
return p
def factor(A,N): '''Factor big number N, which is product of prime p/q''' '''Input: N: big number, A: proposed average of prime p,q Output: prime p,q such that N = p*q and p<q or 0 if A is not correct''' if A*A < N: return 0 x = gmpy2.isqrt(A*A - N) p = A-x q = A+x if gmpy2.is_prime(p) and gmpy2.is_prime(q) and p*q == N: return p,q else: return 0
def gen_prime():
base = random.getrandbits(1024)
off = 0
while True:
if gmpy2.is_prime(base + off):
break
off += 1
p = base + off
return p, off
def solve1():
"""
如果允许用 gmpy2 库就好说了
:return:
"""
for i in range(100):
if gmpy2.is_prime(i):
if i != 2:
print(end=" ")
print(i, end="")
def next_left(cur, base, new_length):
# Add digits to the left
mul = base**(new_length - 1)
new = []
for left in range(1, base):
temp = left * mul + cur
if gmpy2.is_prime(temp):
new.append(temp)
return new
def __getSafePrimes(n_len):
rng = secrets.SystemRandom()
prime_ = gmpy2.mpz(rng.getrandbits(n_len - 1))
prime_ = gmpy2.bit_set(prime_, n_len - 2)
while True:
prime_ = gmpy2.next_prime(prime_)
prime = 2 * prime_ + 1
if gmpy2.is_prime(prime, 25):
break
return prime_, prime
def problem35():
answer = 500000
for i in range(3, 1000000, 2):
number = str(i)
for j in range(0, len(number)):
if (not is_prime(int(number))):
answer -= 1
break
number = number[1:] + number[:1]
return answer
def get_a_prime(l):
random_seed = urandom(l)
num = bytes_to_num(random_seed)
while True:
if is_prime(num):
break
num += 1
return num
def analyze_number(n):
print 'Number %-15s' % n
print 'Prime %-15s' % gmpy2.is_prime(n)
print 'Is square %-15s' % ((n ** 0.5) == n)
print 'Square root %-15s' % (n ** 0.5)
print 'Cube root %-15s' % (n ** (1.0 / 3.0))
print 'Sum of digits %-15s' % eulertools.sum_of_digits(n)
print 'Prime factors %-15s' % eulertools.primeFactors(n)
print '# Factors %-15s' % len(eulertools.divisorGenerator(n))
print 'Factors %-15s' % eulertools.divisorGenerator(n)
def factor(A, N):
'''Factor big number N, which is product of prime p/q'''
'''Input:
N: big number,
A: proposed average of prime p,q
Output:
prime p,q such that N = p*q and p<q
or 0 if A is not correct'''
if A * A < N:
return 0
x = gmpy2.isqrt(A * A - N)
p = A - x
q = A + x
if gmpy2.is_prime(p) and gmpy2.is_prime(q) and p * q == N:
return p, q
else:
return 0
def getPrimes(size):
half = random.randint(16, size // 2 - 8)
rand = random.randint(8, half - 1)
sizes = [rand, half, size - half - rand]
while True:
p, q = 0, 0
for s in sizes:
p <<= s
q <<= s
chunk = random.getrandbits(s)
p += chunk
if s == sizes[1]:
chunk = random.getrandbits(s)
q += chunk
p |= 2**(size - 1) | 2**(size - 2) | 1
q |= 2**(size - 1) | 2**(size - 2) | 1
if gmpy2.is_prime(p) and gmpy2.is_prime(q):
return p, q
def next_right(cur, base):
# Add digits to the right
test = cur * base
new = []
for right in range(1, base, 2 - (base % 2)):
temp = test + right
if gmpy2.is_prime(temp):
new.append(temp)
return new
def check_prime(p):
# type: (int) -> RE
"""
Checks if given number is a prime
:p the potential prime
"""
if not gmpy2.is_prime(p):
return RSAPublicKeyResult.NON_PRIME
return RSAPublicKeyResult.OK
def rsa_conspicuous_check(N, p, q, d, e):
ret = 0
txt = ""
nlen = int(math.log(N) / math.log(2))
if gmpy2.is_prime(p) == False:
ret = -1
txt += "p IS NOT PROBABLE PRIME\n"
if gmpy2.is_prime(q) == False:
txt = "q IS NOT PROBABLE PRIME\n"
if gmpy2.gcd(p, e) > 1:
ret = -1
txt = "p and e ARE NOT RELATIVELY PRIME\n"
if gmpy2.gcd(q, e) > 1:
ret = -1
txt += "q and e ARE NOT RELATIVELY PRIME\n"
if p * q != N:
ret - 1
txt += "n IS NOT p * q\n"
if not (abs(p - q) > (2**(nlen // 2 - 100))):
ret - 1
txt += "|p - q| IS NOT > 2^(nlen/2 - 100)\n"
if not (p > 2**(nlen // 2 - 1)):
ret - 1
txt += "p IS NOT > 2^(nlen/2 - 1)\n"
if not (q > 2**(nlen // 2 - 1)):
ret - 1
txt += "q IS NOT > 2^(nlen/2 - 1)\n"
if not (d > 2**(nlen // 2)):
ret - 1
txt += "d IS NOT > 2^(nlen/2)\n"
if not (d < gmpy2.lcm(p - 1, q - 1)):
txt += "d IS NOT < lcm(p-1,q-1)\n"
try:
inv = gmpy2.invert(e, lcm(p - 1, q - 1))
except:
inv = None
ret = -1
txt += "e IS NOT INVERTIBLE mod lcm(p-1,q-1)\n"
if d != inv:
ret = -1
txt += "d IS NOT e^(-1) mod lcm(p-1,q-1)"
return (ret, txt)
def gen():
while True:
p = [gmpy2.next_prime(random.randrange(1 << 48)) for _ in range(50)]
o = 2
for pi in p:
o *= pi
n = o + 1
if gmpy2.is_prime(n):
g = 2
if pow(g, o // 2, n) == n - 1:
return g, n
def gen_prime_froms(bits, s):
p = 0
print('s', hex(s))
for _ in range(bits // chunk_size):
p = (p << chunk_size) + s
s = a * s % 2**chunk_size
print(hex(s))
if gmpy2.is_prime(p):
return p
else:
return 0
def minimum_number(numbers):
s = sum(numbers)
n = s
while True:
if is_prime(n):
break
else:
n += 1
return n - s
def isprimeproof(n):
if n % 2 == 0:
n = str(n)[:-1]
for s in '13579':
if is_prime(int(n + s)):
return False
return True
else:
n = str(n)
for s in '123456789':
if is_prime(int(s + n[1:])):
return False
for i in range(1, len(n)-1):
for s in '0123456789':
if is_prime(int(n[:i] + s + n[i+1:])):
return False
for s in '13579':
if is_prime(int(n[:-1] + s)):
return False
return True
def calcA(a,n):
x=a**2-n
if gmpy2.is_square(x):
x = gmpy2.isqrt(x)
p = a+x
q = a-x
if p*q == n:
if not gmpy2.is_prime(q):
print "not prime q" # simple check
return q
return 0
def is_prime(number: int) -> bool:
"""
Check if the input number is a prime number. Uses GMPY2 if available
:param number: The number to check
:return: Whether the input is prime or not
"""
if USE_GMPY2:
return gmpy2.is_prime(number)
# else
return sympy.isprime(number)
def find_tricky_rng_seed():
# Hand-crafted so you don't have to run Bitcoin Cash before:
return bytes.fromhex(
"693e14ccadf6c831ea694f6d8651d6c912c4377ecc22b2f498d2ee60b66c53bd")
# Find a seed such that we generate a secret == 0
rng = Rng()
for block, base in tricky_sha_inputs():
seed = long_to_bytes(bytes_to_long(base) - 2, 32)
rng.set_seed(seed)
prime = rng.getbits(512)
secret = rng.getbits()
assert secret == 0
strong_prime = 2 * prime + 1
if prime % 5 == 4 and is_prime(prime) and is_prime(strong_prime):
log.success(f"Seed {seed.hex()} is suitable! (from block {block})")
return seed
raise Exception("Could not find a suitable seed!")
def generate_CEK_prime(l, u, b, d):
rs = PRNG()
b_d = b ** d
b_d_bits = int(math.ceil(math.log(b_d, 2)))
if b == 2:
p_t_bits = l - b_d_bits - u
p_t = rs.random_prime(p_t_bits)
while True:
p_s = rs.random_prime(u)
p = b_d * p_s * p_t + 1
if gmpy2.is_prime(p):
return p_s, p
else:
p_t_bits = l - b_d_bits - u - 1
p_t = rs.random_prime(p_t_bits)
while True:
p_s = rs.random_prime(u)
p = 2 * b_d * p_s * p_t + 1
if gmpy2.is_prime(p):
return p_s, p
def __init__(self, p=None, q=None, n=None, d=None, e=DEFAULT_EXP):
"""
Initialize RSA instance using primes (p, q)
or modulus and private exponent (n, d)
"""
self.e = e
if p and q:
assert gmpy.is_prime(p), 'p is not prime'
assert gmpy.is_prime(q), 'q is not prime'
self.p = p
self.q = q
elif n and d:
self.p, self.q = factor_modulus(n, d, e)
else:
raise ArgumentError('Either (p, q) or (n, d) must be provided')
self._calc_values()
def __init__(self, p=None, q=None, n=None, d=None, e=DEFAULT_EXP):
"""
Initialize RSA instance using primes (p, q)
or modulus and private exponent (n, d)
"""
self.e = e
if p and q:
assert gmpy2.is_prime(p), 'p is not prime'
assert gmpy2.is_prime(q), 'q is not prime'
self.p = p
self.q = q
elif n and d:
self.p, self.q = factor_modulus(n, d, e)
else:
raise ValueError('Either (p, q) or (n, d) must be provided')
self._calc_values()
def calcA(a, n):
x = a**2 - n
if gmpy2.is_square(x):
x = gmpy2.isqrt(x)
p = a + x
q = a - x
if p * q == n:
if not gmpy2.is_prime(q):
print "not prime q" # simple check
return q
return 0
def k_thlastDigPrime(k):
res = [0, 1, 1, 2, 4]
total = 0
while total < k:
res.append(res[-1] + res[-2] - res[-3] + res[-4] - res[-5])
temp = str(res[-1])
if len(temp) < 10:
continue
if is_prime(int(temp[-9:])):
total += 1
return [len(res), int(temp[-9:])]
def brentMultipleFactors(N) :
""" Find all the prime factors of N (more than 2) by the brent's cycle finding with batch gcd
"""
res=[]
facts=0,0
while(not(gmpy2.is_prime(facts[1]))) :
facts=brentWithBatchGCD(N)
res+=[facts[0]]
N=facts[1]
res+=[facts[1]]
return res
def random_prime(random_state, m, generator, power_range, multiple_range):
random_power = random_from_interval(random_state, power_range[0],
power_range[1])
random_multiple = random_from_interval(random_state, multiple_range[0],
multiple_range[1])
candidate = g.powmod(generator, random_power, m) + random_multiple * m
while not g.is_prime(candidate):
candidate += m
return candidate
def gen_keys(dimension):
"""
Функция, которая генерирует ключи абонента
"""
print("Parametrs: \n")
p = primegen.prime_gen(dimension)
while is_prime(p) == False:
p = primegen.prime_gen(dimension)
q = primegen.prime_gen(dimension)
while is_prime(q) == False:
q = primegen.prime_gen(dimension)
print(f"p = {p}, q = {q}")
N = p * q
print(f"N = {N}")
C = get_c(p, q)
print(f"c = {C}")
S = get_s(C, N)
print(f"s = {S}")
M = get_m(p, q, C)
print(f"m = {M}")
E, D = get_e_d(M)
print(f"e = {E}, d = {D}\n")
return (p, q, M, D), (N, E, C, S)
def S(n):
res, xmin = 0, (n-1) * n / 2
for i in xrange(1+(xmin%2), n+1, 2):
x = xmin + i
if x % 3 and x % 7 and x % 11 and is_prime(x):
univ = MIDDLE[(x%6, n%6)](x, n)
check = filter(is_prime, univ.keys())
d = len(check)
if d > 1:
res += x
elif d:
try:
for y in check:
for z in univ[y]:
if is_prime(z):
res += x
raise ValueError
except:
pass
return res
def goldbach(n):
"""teste la conjecture de Golbach en tentant de décomposer n pair (>2) en 2 nb premiers"""
x = 3
while True:
# calcul de y et test de primalité
y = n-x
if gmpy2.is_prime(y,20):
return (n,[int(x),int(y)])
# On prend le nombre premier suivant
x = gmpy2.next_prime(x)
def challenge3 (N):
"""Factor N=p*q where abs(3p-2q) < N**(1/4). Indeed (3p+2q)/2 is closed to sqrt(6N). But 3p is odd and 3p+2q / 2 is not an integer. But 2(3p) is even.\
So 6p + 4q / 2 is an integer closed to 2 * sqrt(6N) or 2==sqrt(4) so closed to sqrt(4*6*N) ie sqrt(24N)"""
N = mpz(N)
twentyFour_N = mul(24,N)
A = isqrt(twentyFour_N)
while 1:
if pow(A, 2) > twentyFour_N:
x = isqrt(pow(A, 2) - twentyFour_N)
AminusX = A - x
AplusX = A + x
if (mul(AminusX, AplusX) == twentyFour_N):
p,q = 0,0
if ((AminusX % 6 == 0) and (AplusX % 4 == 0)):
p = AminusX // 6
q = AplusX // 4
elif ((AplusX % 6 == 0) and (AminusX % 4 == 0)):
p = AplusX // 6
q = AminusX // 4
if (is_prime(p) and is_prime(q)):
return (p,q)
A = A + 1
def generate_large_prime(bits):
"""
Generate large pseudo prime .
Args:
bits: int, the number of bits of the prime you want to generate.
"""
rand_prime=random.getrandbits(bits)
if (rand_prime%2)==0 :
rand_prime=rand_prime-1
while not gmpy2.is_prime(rand_prime):
rand_prime=rand_prime+2
return rand_prime
def prime_divisor_decomp(n, rand=False):
dlist, clist = [], []
# 奇偶性判断
c = 0
while n % 2 == 0:
n //= 2
c += 1
if c:
dlist.append(2)
clist.append(c)
# 首先用10000以内的小素数试除
for p in iter(P10K):
c = 0
while n % p == 0:
n //= p
c += 1
if c:
dlist.append(p)
clist.append(c)
if n == 1:
return list(zip(dlist, clist))
if n in P10Kset: # set的in操作复杂度<=O(log(n))
dlist.append(n)
clist.append(1)
return list(zip(dlist, clist))
n = int(n)
# 然后用Pollard rho方法生成素因子
while 1:
if n == 1:
return list(zip(dlist, clist))
if is_prime(n):
dlist.append(n)
clist.append(1)
return list(zip(dlist, clist))
p = _pollard_rho(n, rand)
c = 0
while n % p == 0:
n //= p
c += 1
dlist.append(p)
clist.append(c)
n = int(n)
