def buttonClicked(self):
q = unicode(self.lineEdit_2.text())
p = unicode(self.lineEdit.text())
self.textBrowser.append("q = {0}".format(q))
self.textBrowser.append("p = {0}".format(p))
e = unicode(self.lineEdit_3.text())
self.textBrowser.append("e = {0}".format(e))
key = (int(p) - 1) * (int(q) - 1)
tmp = func.egcd(int(e), key)
d = int(tmp[1])
self.textBrowser.append("key = {0}, d = {1}".format(
unicode(key), unicode(d)))
input = self.plainTextEdit.toPlainText()
self.textBrowser.append("Text lenght: {0}".format(len(input)))
if self.radioButton.isChecked() is True:
[time, output] = rsa.rsa(unicode(input), 1, int(p), int(q), int(e))
self.textBrowser.append("Encoded text: {0}".format(
str(unicode(output))))
self.textBrowser.append("Time elapsed: {0} s<br>".format(time))
elif self.radioButton_2.isChecked() is True:
[time, output] = rsa.rsa(input, 0, int(p), int(q), int(e))
self.textBrowser.append("Decoded text: {0}".format(
unicode(output)))
self.textBrowser.append("Time elapsed: {0} s<br>".format(time))
def rsaDecrypt():
if request.method == "POST":
#get message
#get message
message = request.form["msg"]
#get keys
pubKey1 = int(request.form["iKey1"])
privKey = int(request.form["iKey2"])
#get encrypted and make into useable output
decrypted = rsa.rsa(message, pubKey1, privKey)
decrypted = decrypted[0]
decrypted = ''.join(decrypted)
#render page with output
return render_template("rsa.html",
page="Decrypt",
key1="Public Key 1",
key2="Private Key",
op1="Encrypt",
op2="Key Generator",
link1="/rsa",
link2="key-generator",
outputDisplay="Decrypted",
output=decrypted)
else:
return render_template("rsa.html",
page="Decrypt",
key1="Public Key 1",
key2="Private Key",
op1="Encrypt",
op2="Key Generator",
link1="/rsa",
link2="key-generator")
def rsaKeyGen():
if request.method == "POST":
#get message
message = request.form["msg"]
#generate keys
keys = rsa.keyGen()
pubKey1 = keys[0]
pubKey2 = keys[1]
privKey = keys[2]
#encrypt message
encrypted = rsa.rsa(message, pubKey1, pubKey2)
encrypted = encrypted[0]
encrypted = ''.join(encrypted)
return render_template("keyGen.html",
display="Encrypted",
display1="Public Key 1",
display2="Public Key 2",
display3="Private Key",
output=encrypted,
pubKey1=pubKey1,
pubKey2=pubKey2,
privKey=privKey,
op1="Encrypt",
op2="Decrypt",
link1="/rsa",
link2="/rsa/decrypt")
else:
return render_template("keyGen.html",
op1="Encrypt",
op2="Decrypt",
link1="/rsa",
link2="/rsa/decrypt")
def rsaEncrypt():
if request.method == "POST":
#get message
message = request.form["msg"]
#get keys
pubKey1 = int(request.form["iKey1"])
pubKey2 = int(request.form["iKey2"])
#get encrypted and make into useable output
encrypted = rsa.rsa(message, pubKey1, pubKey2)
encrypted = encrypted[0]
encrypted = ''.join(encrypted)
#render page with output
return render_template("rsa.html",
key1="Public Key 1",
key2="Public Key 2",
outputDisplay="Encrypted",
encrypted="Encrypted: ",
output=encrypted,
page="Encrypt",
op1="KeyGenerator",
op2="Decrypt",
link1="rsa/key-generator",
link2="rsa/decrypt")
#render page without output
else:
return render_template("rsa.html",
page="Encrypt",
key1="Public Key 1",
key2="Public Key 2",
op1="Key Generator",
op2="Decrypt",
link1="rsa/key-generator",
link2="rsa/decrypt")
def genKeyMsg(self):
msg = "NEW KEY\n"
self.encrypter = rsa.rsa()
pubkey = self.encrypter.get_pub_keys()
N = str(pubkey[0])
e = str(pubkey[1])
msg += N + "\n"
msg += e + "\n"
return msg.encode()
def get_sp():
j = prelogin()
nonce = j['nonce']
servertime = j['servertime']
password = u'chinasun00'
sp = rsa(nonce=nonce, servertime=servertime, password=password)
return sp
def main():
print("1)Caesar\n2)Multiplication\n3)affine\n4)ubrytelig\n5)rsa\n")
which_alg = input(": ")
if which_alg == '1':
cy_alg = caesar()
elif which_alg == '2':
cy_alg = multiplikasjons_cypher()
elif which_alg == '3':
cy_alg = affine()
elif which_alg == '4':
cy_alg = ubrytelige()
else:
cy_alg = rsa()
send = sender(cy_alg)
receiv = receiver(cy_alg)
hack = hacker(cy_alg)
while True:
choos_key = input(
"Choose 1 to inter your key, else choose other number: ")
if choos_key == '1':
key = input("your key is: ")
if which_alg == '4':
send.set_receiver(cy_alg, receiv, key)
elif which_alg == '3':
key2 = input("your second key is: ")
send.set_receiver(cy_alg, receiv, (int(key),int(key2)))
else:
send.set_receiver(cy_alg, receiv, int(key))
else:
send.set_receiver(cy_alg, receiv)
receiv.set_sender(cy_alg, send)
my_text = input("Your Text: ")
code = send.operate_cypher(my_text)
print("Cypher: " + code)
decoded_code = receiv.operate_cypher(code)
print("after: " + decoded_code)
verify = cy_alg.verify(my_text, decoded_code)
if verify:
break
else:
print("Repeat!\n")
print("hack: {} ".format(hack.hack(code)))
def plot_neighbour_analysis(steps, final_base_representation, layer_names):
from rsa import rsa
similaritiy_to_pre = [[] for _ in range(len(final_base_representation))]
for i in range(len(final_base_representation)):
for j in range(1, len(final_base_representation[i])):
similaritiy_to_pre[i].append(
rsa(final_base_representation[i][[j - 1, j], :]))
fig = plt.figure(figsize=(8, 4))
plt.title(
"Dissimilarity of meta-initilizations w.r.t representation 1000 trainingsteps before"
)
plt.xlabel("Number of training steps")
plt.ylabel("Dissimilarity")
plt.yscale('symlog', linthreshy=0.015)
print(np.array(steps)[1:])
for i in range(5):
plt.plot(np.array(steps)[1:],
similaritiy_to_pre[i],
label=layer_names[i])
print(similaritiy_to_pre[i])
plt.legend(bbox_to_anchor=(1.04, 0.5), loc="center left", borderaxespad=0)
plt.show()
def __RSA_Encrypt(self,plain,length,rsa_n,rsa_e):
import rsa
ret = rsa.rsa(plain, rsa_e, rsa_n[:256], False)
return b2a_hex(ret)
return False
else:
print "Email not registered."
return False
try:
option = argv[1]
except:
option = None
print ayuda
if option == "-h":
print ayuda
elif option == "-k":
email = raw_input("Your email: ")
rsa(email)
elif option == "-r":
register()
elif option == "-q":
query()
elif option == "-e":
encrypt()
elif option == "-d":
text = raw_input("Ciphertext >> ")
print decrypt(text)
elif option == "-m":
decrypted = raw_input("Decrypted string >> ")
getmessage(decrypted)
elif option == "-c":
modify()
else:
'''
This program is the main method which contains all of the methods and their demos.
@ author Luke, Reissmueller
@ 10/21/2020
@ main.py
'''
option = ''
while option != '0':
option = input('''
1) Generate valid keys (e,n) for the RSA cryptosystem.
2) Use the Sieve of Eratosthenes to find all primes less than 10,000(or in this case the user can choose).
3) Find all of the positive divisors of a positive integer from its prime factorization.
''')
if option == '1':
p = random.randint(1, 10000000)
q = random.randint(1, 10000000)
while not (isPrime(p) and isPrime(q)):
p = random.randint(1, 10000000)
q = random.randint(1, 10000000)
rsa(p, q)
elif option == '2':
o = int(input('Enter positive integer to be sieved.'))
sieve(o)
elif option == '3':
o = int(input('Enter positive integer for prime factorization.'))
factorization(o)
print('Come again.')
def __RSA_Encrypt(self,plain,length,rsa_n,rsa_e):
import rsa
ret = rsa.rsa(plain, rsa_e, rsa_n[:256], False)
return b2a_hex(ret)
def analyze(model,
saver,
sess,
exp_string,
data_generator,
test_num_updates=None,
NUM_ANALYSIS_POINTS=1,
base_analysis=False,
steps=[-1]):
### computing activations
num_classes = data_generator.num_classes # for classification, 1 otherwise
np.random.seed(1)
random.seed(1)
print(exp_string)
hid1, hid2, hid3, hid4, out, acc = [], [], [], [], [], []
for step in steps:
meta_hidden1s = []
meta_hidden2s = []
meta_hidden3s = []
meta_hidden4s = []
meta_outputs = []
metaval_accuracies = []
print(f"Load model {step}")
load_model(FLAGS.logdir, exp_string, saver, sess, step)
print(f"Load model {step} done!")
for i in range(NUM_ANALYSIS_POINTS + 1):
if i == 0: # The first sample is the evaluation sample
continue
if 'generate' not in dir(data_generator):
feed_dict = {}
feed_dict = {model.meta_lr: 0.00}
else:
batch_x, batch_y, amp, phase = data_generator.generate(
train=False)
if FLAGS.baseline == 'oracle': # NOTE - this flag is specific to sinusoid
batch_x = np.concatenate([
batch_x,
np.zeros([batch_x.shape[0], batch_x.shape[1], 2])
], 2)
batch_x[0, :, 1] = amp[0]
batch_x[0, :, 2] = phase[0]
inputa = batch_x[:, :num_classes * FLAGS.update_batch_size, :]
inputb = batch_x[:, num_classes * FLAGS.update_batch_size:, :]
labela = batch_y[:, :num_classes * FLAGS.update_batch_size, :]
labelb = batch_y[:, num_classes * FLAGS.update_batch_size:, :]
feed_dict = {
model.inputa: inputa,
model.inputb: inputb,
model.labela: labela,
model.labelb: labelb,
model.meta_lr: 0.0
}
targets = [
model.hiddens1, model.hiddens2, model.hiddens3, model.hiddens4,
model.outputs,
model.metaval_total_accuracy1 + model.metaval_total_accuracies2
]
def reshape_elems_of_list(layers, shape=(model.dim_output, -1)):
reshaped_layers = []
for layer in layers:
layer = np.reshape(layer, shape)
reshaped_layers.append(layer)
return reshaped_layers
hidden1s, hidden2s, hidden3s, hidden4s, outputs, a = sess.run(
targets, feed_dict)
meta_hidden1s.append(reshape_elems_of_list(hidden1s))
meta_hidden2s.append(reshape_elems_of_list(hidden2s))
meta_hidden3s.append(reshape_elems_of_list(hidden3s))
meta_hidden4s.append(reshape_elems_of_list(hidden4s))
meta_outputs.append(reshape_elems_of_list(outputs))
metaval_accuracies.append(a)
hid1.append(meta_hidden1s)
hid2.append(meta_hidden2s)
hid3.append(meta_hidden3s)
hid4.append(meta_hidden4s)
out.append(meta_outputs)
acc.append(metaval_accuracies)
### prepare for visualizing
from rsa import plot_rsa_fancy, rsa
layers = [hid1, hid2, hid3, hid4, out]
if FLAGS.datasource == 'miniimagenet':
layer_names = [
"Pooling layer 1", "Pooling layer 2", "Pooling layer 3",
"Pooling layer 4", "Logits/Head"
]
else:
layer_names = [
"Convolution layer 1", "Convolution layer 2",
"Convolution layer 3", "Convolution layer 4", "Logits/Head"
]
final_base_representation = []
final_mean_diff_to_base = []
final_std_diff_to_base = []
for i, (layer_name) in enumerate(layer_names):
representations = []
base_representations = []
mean_diff_to_base = []
std_diff_to_base = []
labels = []
colors = []
inner_steps = [0, 1, 5, 10]
for j, step in enumerate(steps):
base_representations.append(layers[i][j][0][0])
diff_to_base = []
for k in range(NUM_ANALYSIS_POINTS):
representations = representations + list(
map(layers[i][j][k].__getitem__, inner_steps))
diff_to_base.append(
rsa(
np.array(
[base_representations[-1], representations[-1]])))
colors = colors + [k + j * NUM_ANALYSIS_POINTS
] * len(inner_steps)
mean_diff_to_base.append(np.mean(diff_to_base))
std_diff_to_base.append(np.std(diff_to_base))
labels = colors
final = np.array(representations)
final_base_representation.append(np.array(base_representations))
final_mean_diff_to_base.append(np.array(mean_diff_to_base))
final_std_diff_to_base.append(np.array(std_diff_to_base))
if not base_analysis:
plot_rsa_fancy(final,
labels,
colors,
method="correlation",
title=layer_name,
n_tasks=NUM_ANALYSIS_POINTS,
steps=steps)
if base_analysis:
plot_neighbour_analysis(steps, final_base_representation, layer_names)
plot_base_analysis(steps, final_mean_diff_to_base,
final_std_diff_to_base, layer_names)
from rsa import rsa encryption = rsa(k=5) encryption.save_keys() keys = encryption.load_keys() #keys = encryption.get_keys() d = keys[0] e = keys[1] n = keys[2] n_length = len(bin(int(n))) a = encryption.encrypt((e, n), 1337) print(a) print(encryption.decrypt((d, n), a))
def test_decode_encode(self):
pubk, prk = rsa(13)
r = random.randint(1, 500)
for i in range(1, r):
self.assertEqual(decode_rsa(prk, encode_rsa(pubk, i)), i)
def main():
size=pow(10,6) # number of bits generated for each run
rsastest=[0]*4
bmstest=[0]*4
bbsstest=[0]*4
decstest=[0]*4
for i in range(10):
for j in range(10):
temp=rsa(primes[2*i],primes[2*i+1],size)
for k in range(4):
rsastest[k]+=temp[k]
temp=bm(primes[i],size)
for k in range(4):
bmstest[k]+=temp[k]
temp=bbs(primes[2*i],primes[2*i+1],size)
for k in range(4):
bbsstest[k]+=temp[k]
temp=dec(primes[i],size)
for k in range(4):
decstest[k]+=temp[k]
rsastest=[a/100 for a in rsastest]
bmstest=[a/100 for a in bmstest]
bbsstest=[a/100 for a in bbsstest]
decstest=[a/100 for a in decstest]
print('---------')
print('Testing Done')
print('---------')
print('Result of RSA Bit Generator:')
print('Average generating time: {0}'.format(rsastest[0]))
print('Frequency of 1s: {0}'.format(rsastest[1]))
print('Frequency of switches: {0}'.format(rsastest[2]))
print('Chi Square of Poker test: {0}'.format(rsastest[3]))
print('---------')
print('Result of Blum-Micali Generator:')
print('Average generating time: {0}'.format(bmstest[0]))
print('Frequency of 1s: {0}'.format(bmstest[1]))
print('Frequency of switches: {0}'.format(bmstest[2]))
print('Chi Square of Poker test: {0}'.format(bmstest[3]))
print('---------')
print('Result of Blum Blum Shub:')
print('Average generating time: {0}'.format(bbsstest[0]))
print('Frequency of 1s: {0}'.format(bbsstest[1]))
print('Frequency of switches: {0}'.format(bbsstest[2]))
print('Chi Square of Poker test: {0}'.format(bbsstest[3]))
print('---------')
print('Result of Dual Elliptic Curve Bit Generator:')
print('Average generating time: {0}'.format(decstest[0]))
print('Frequency of 1s: {0}'.format(decstest[1]))
print('Frequency of switches: {0}'.format(decstest[2]))
print('Chi Square of Poker test: {0}'.format(decstest[3]))
