def generateKey(keySize):
# Creates a public/private key pair with keys that are keySize bits in
# size. This function may take a while to run.
# Step 1: Create two prime numbers, p and q. Calculate n = p * q.
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
# Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
# Keep trying random numbers for e until one is valid.
e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Step 3: Calculate d, the mod inverse of e.
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
print('Public key:', publicKey)
print('Private key:', privateKey)
return (publicKey, privateKey)
def generateKey(keySize):
# Creates a public/private key pair with keys that are keySize bits in
# size. This function may take a while to run.
# Step 1: Create two prime numbers, p and q. Calculate n = p * q.
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
# Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
# Keep trying random numbers for e until one is valid.
e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Step 3: Calculate d, the mod inverse of e.
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
print('Public key:', publicKey)
print('Private key:', privateKey)
return (publicKey, privateKey)
def generateKey(keySize):
# Step 1: Create two prime numbers, p and q. Calculate n = p * q.
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
# Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Step 3: Calculate d, the mod inverse of e.
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
print('Public key:', publicKey)
print('Private key:', privateKey)
return (publicKey, privateKey)
def generateKey(keySize):
#create pasangan public key dan private key
#Step 1,generate bilangan prima , n = p * q
print('Create bilangan prima p...')
p = rabinMiller.generateLargePrime(keySize)
print('Create bilangan prima q...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
#Step 2,generate bilangan e (relatif prima) dengan (p-1)*(q-1)
print('Create e(relatif prima) ...')
while True:
#looping terus hingga di dapat bilangan e yang valid
e = random.randrange(2 **(keySize-1), 2 ** (keySize))
if cryptomath.gcd(e , (p-1)*(q-1)) == 1:
break
#Step 3,hitung d,mod inverse dari e
print('Generate d,mod inverse e...')
d = cryptomath.findModInverse(e, (p-1)&(q-1))
publicKey = (n,e)
privateKey = (n,d)
print('Public key : ',publicKey)
print('Private key : ',privateKey)
return (publicKey,privateKey)
def generateKey(keySize):
# Step 1: Create two prime numbers, p and q. Calculate n = p * q.
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
print("\nN is: " + str(n) + "\n")
# Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
e = random.randrange(2**(keySize - 1), 2**(keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Step 3: Calculate d, the mod inverse of e.
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
print("\nD is: ", d) #Esta es la que se queda el propietario
print("\nE is: ", e) #Esta es la que se publica junto a n
publicKey = (n, e)
privateKey = (n, d)
print('\nPublic key:', publicKey)
print('\nPrivate key:', privateKey)
return (publicKey, privateKey)
def generateKey(self, keysize=1024):
p = rabinMiller.generateLargePrime(keysize)
q = rabinMiller.generateLargePrime(keysize)
n = p * q
g = n + 1
lam = (p - 1) * (q - 1)
mu = crypton.mod_inv(lam, n)
return n, g, lam, mu
def generate_pq():
while True:
i = rabinMiller.generateLargePrime()
j = rabinMiller.generateLargePrime()
inverse3 = getInverse(i, j)
if (inverse3 != 0):
break
return i, j, inverse3
def generateRSAkey(keySize=1024):
p = rabinMiller.generateLargePrime(keySize)
q = rabinMiller.generateLargePrime(keySize)
n = p * q
while True:
e = random.randrange(2**(keySize - 1), 2**(keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
return (publicKey, privateKey)
def generateKey(keysize=1024):
#############################
p = rabinMiller.generateLargePrime(keysize)
q = rabinMiller.generateLargePrime(keysize)
n = p * q
################################
while True:
e = random.randrange(2**(keysize - 1), 2**keysize)
if gcd(e, (p - 1) * (q - 1)) == 1:
break
################################
d = findModInverse(e, (p - 1) * (q - 1))
################################
public_key = (n, e)
private_key = (n, d)
return (public_key, private_key)
def generateKey(keySize):
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
e = random.randrange(2**(keySize - 1), 2**(keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
return (publicKey, privateKey)
def generateKey(size):
p = rabinMiller.generateLargePrime(size)
q = rabinMiller.generateLargePrime(size)
n = p*q
while True:
e = random.randrange(2**(size-1), 2** (size))
if Cryptomath.gcd(e, (p-1)*(q-1)) == 1:
break
d = Cryptomath.findModInverse(e, (p-1) * (q-1))
publickey = (n,e)
privatekey = (n,d)
print('Public Key:',publickey)
print('Private Key', privatekey)
return (publickey,privatekey)
def generateKey(keySize):
p = rabinMiller.generateLargePrime(keySize)
while True:
q = rabinMiller.generateLargePrime(keySize)
if p == q:
continue
break
n = p * q
while True:
# Keep trying random numbers for e until one is valid.
e = random.randrange(2**(keySize - 1), 2**(keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
return (publicKey, privateKey)
def generateKey(keySize):
# creates public and private key pair with keys that are keySize bits in size
#
# print('selecting prime number for p')
# select prime number from list for p
p = rabinMiller.generateLargePrime(keySize)
# print('p is : ', p)
# print('selecting prime number for q')
q = rabinMiller.generateLargePrime(keySize)
# print('q is : ', q)
n = p * q
# print('Generating e that is relatively prime to (p-1)*(q-1)')
while True:
e = random.randrange(2**(keySize - 1), 2**keySize)
if rsahelp.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Calcuates the d, the mod inverse of e
# print('Calcuating d that is mod inverse of e...')
d = rsahelp.findModInverse(e, (p - 1) * (q - 1))
# print('d is : ', d)
publicKey = (n, e)
privateKey = (n, d)
# print('Public key:', publicKey)
# print('Private key:', privateKey)
return (publicKey, privateKey)
def r_num_generator(rSize):
f = open("rsa_privkey.txt", "r")
val = f.read()
f.close()
res = val.split(",")
keysize = int(res[0])
f = open("random_file.txt", "w")
# rsize=8
rsize = int(rSize)
# split=(keysize-rsize)/8
split = (keysize - rsize)
n = rabinMiller.generateLargePrime(rsize)
x = bin(n)[2:]
res = (x * (split / rsize)) + x[:(split % rsize)]
G = int(res, 2)
f.write(str(rsize) + "," + str(n) + "," + str(G))
f.close()
def twoPrimes():
p = rabinMiller.generateLargePrime()
q = rabinMiller.generateLargePrime()
return p, q
