def verify(self, fname):
ciphertext = fileOp.read_list("Fciphertext")[0]
n = fileOp.read_list("FpublicKey")[0]
public_key = fileOp.read_list("FpublicKey")[1]
inp = fname
inp = fileOp.read_binary_file(inp)
inp = fdh.fdh(inp, (len(bin(n)) - 2))
signaturec = pow(ciphertext, public_key, n)
if signaturec - int(inp, 16) == 0:
print("VERIFIED!")
return True
else:
print("FAILED!")
return False
def verify(self):
ciphertext = fileOp.read_list("Fciphertext")[0]
n = fileOp.read_list("FpublicKey")[0]
public_key = fileOp.read_list("FpublicKey")[1]
print("File to be checked:", end=" ")
inp = input()
inp = fileOp.read_large_data(inp)
inp = fdh.fdh(inp, (len(bin(n)) - 2))
signaturec = pow(ciphertext, public_key, n)
if signaturec - int(inp, 16) == 0:
print("VERIFIED!")
else:
print("FAILED!")
def reconstruct_shamir(
shares,
i,
t=0
): #Do we have to mention which additive share these backups belong to? i.e. need for 'i'?
'''Verify first using VSS and then reconstruct, i is index of the additive share for vss_p, etc'''
vss_q = fileOp.read_list("FvssQ")[0]
vss_p = fileOp.read_list("FvssP")[0]
gen = fileOp.read_list("FvssGen")[0]
commitment_list = fileOp.read_list("FvssCommitmentList")[0]
res = True
for si in shares:
if RSAFeldmanVSS.verify_share(si, gen[i], vss_p[i],
commitment_list[i]) == False:
res = False
break
if res == False:
print("Share:", si, "invalid")
raise Exception("Backup Reconstruction Failed")
return
else:
return (ShamirSS.tncombine(shares, vss_q[i], t))
def __init__(self):
global public_key, private_key, n
public_key = fileOp.read_list("FpublicKey")[1]
n, private_key = fileOp.read_list("FprivateKey")
self.set_message()
self.sign()
def __init__(self, fname):
global public_key, private_key, n
public_key = fileOp.read_list("FpublicKey")[1]
n, private_key = fileOp.read_list(
"FprivateKey") #FIX: Reconstruct using Shamir and rest
self.set_message(fname)
self.sign()
def threshold_additive_shares():
'''Divides all elements in the shares list into t-n threshold shares using Feldman VSS into n sub-shares with threshold t'''
shares = fileOp.read_list("FadditiveShares")
t, n = 3, 5 #Generates a (3,5) threshold scheme FIX: Read from file
sub_shares, commitment_list = [], []
vss_p, vss_q, gen = [], [], []
for i in shares:
feld = RSAFeldmanVSS.feldmanvss(t, n, i)
sub_shares.append(feld[0]) #Generate using VSS
commitment_list.append(feld[1])
vss_p.append(feld[2])
vss_q.append(feld[3])
gen.append(feld[4])
fileOp.write_list("FvssP", vss_p)
fileOp.write_list("FvssQ", vss_q)
fileOp.write_list("FvssGen", gen)
fileOp.write_list("FvssSubShares", sub_shares)
fileOp.write_list("FvssCommitmentList", commitment_list)
return
def refresh_shares():
'''Refreshes all shares in list old_shares,share field size is f'''
additive_shares = fileOp.read_list("FadditiveShares")[0]
n = fileOp.read_list("FpublicKey")[0]
old_shares = additive_shares
l = len(old_shares)
new_shares = [0 for _ in range(l)]
for i in old_shares:
share_div = additive_sharing(l,i,0)
new_shares = [(a+b) for a,b in zip(new_shares,share_div)]
additive_shares = new_shares
fileOp.write_list("FadditiveShares",additive_shares)
thresholdShares.threshold_additive_shares()
def gen_keys():
p,q = fileOp.read_list("FprimesPQ")
n = fileOp.read_list("FmodulusRSA")[0]
toit_n = (p-1)*(q-1) #Euler Toitent Function on RSA Modulus
#Public Key Generation
public_key = coprime.find_coprime(toit_n) #Find public key which is coprime to Toitent Value
fileOp.write_list("FpublicKey",[n,public_key])
#Private key Generation
private_key = modInverse.modular_inverse(public_key,toit_n) % toit_n
fileOp.write_list("FprivateKey",[n,private_key])
#Generate additive shares for private keys
additiveShares.generate(private_key)
#Make additive share's backup threshold shares using Feldman VSS
thresholdShares.threshold_additive_shares()
def refresh_shares():
'''Refreshes all shares in list old_shares,share field size is f'''
additive_shares = fileOp.read_list("FadditiveShares")
n = fileOp.read_list("FmodulusRSA")[0]
old_shares = additive_shares
l = len(old_shares)
new_shares = [0 for _ in range(l)]
#Refresh previous additive shares
for i in old_shares:
share_div = additiveShares.additive_sharing(i, l)
new_shares = [(a + b) for a, b in zip(new_shares, share_div)]
#Update new refreshed shares
fileOp.write_list("FadditiveShares", new_shares)
#Threshold on new shares
print("Running")
thresholdShares.threshold_additive_shares()
print("Done")
def gen_prime_1(n):
first_primes_list = fileOp.read_list("FfirstPrimes")
while True:
sample = random_n(n) #Randomly choose n bit number
for i in first_primes_list:
if sample % i == 0:
break
if sample < 4000000:
if i > sample**(1 / 2):
return sample
else:
return sample
def additive_sharing(m, p):
'''Employs additive sharing to divide a secret 'm' into 'p' shares '''
n = fileOp.read_list("FpublicKey")[0] #Fetch RSA Modulus from file
additive_shares_new = []
for i in range(p - 1): #FIX: If m < p: cannot pick values
additive_shares_new.append(
random.randrange(0, m // p)
) #Picks additive shares randomly between 0 to (total_value)/(no_of_shares) - FIX THIS: Increase field size to allow shares between 0 to m
s = m - sum(additive_shares_new)
while s < 0:
s += n
additive_shares_new.append(s)
return additive_shares_new
def gen_prime_1(n):
try:
first_primes_list = fileOp.read_list("FfirstPrimes")
except Exception as e:
raise Exception("Couldn't read FfirstPrimes from File")
while True:
sample = random_n(n) #Randomly choose n bit number
for i in first_primes_list:
if sample % i == 0: #Divisibility test with pre-generated primes
break
if sample < (first_primes_list[-1])**2:
if i > sample**(
1 / 2
): #If all primes less than sqrt(sample) can't divide then sample is prime
return sample
else:
return sample