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 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]))