import pandas as pd import json import numpy as np from helper import * import argparse from rsa import RSA import matplotlib.pyplot as plt import os with open('config.json') as config_file: config = json.load(config_file) data_path = config['data_path'] file_id = 21540#3278#182 df = pd.read_csv(os.path.join(data_path,f'refCOCO/train/attr_tables/attr_{file_id}.tsv'), encoding='utf-8',sep='\t') with open(os.path.join(data_path,f'refCOCO/train/labels/lab_{file_id}.json')) as json_file: label = json.load(json_file) refs = [[r] for r in label['ref_sents']] print(refs) img_id = df['image_id'][0] filename = os.path.join(data_path, f'refCOCO/train/imgs_by_id/{img_id}.jpg') print(filename) image = plt.imread(filename) rsa_agent = RSA(df) speech = rsa_agent.full_speaker('woman-1') print(speech)
for client in crashed: broadcast('%s left the chat' % names[client]) ADDR = 'localhost' PORT = 33000 BUFSIZ = 1024 BLOCKSIZE = 16 # mapping socket and address clients = {} # mapping socket and chat name names = {} hosts_keys = {} cert = RSA() socket = socket(AF_INET, SOCK_STREAM) if __name__ == "__main__": socket.bind((ADDR, PORT)) socket.listen(5) try: print("Waiting for connection...") accept_thread = Thread(target=accept_connections, args=(socket, )) accept_thread.start() accept_thread.join() except: # you should catch specific errors but this is
def computate(): parser = argparse.ArgumentParser( description="Decrypt a rsa-encrypted message.") parser.add_argument( "-o", "--option", type=str, required=True, help="the way you want to decrypt the message. ibmq, qsharp or numeric" ) parser.add_argument("-f", "--factor", type=int, required=False, help="the factor for the integer factorization") parser.add_argument("-k", "--keysize", type=int, required=False, help="the bitsize of the key for the numeric approach") args = parser.parse_args() if args.option == "ibmq": factor = parseDefaultFactor(args.factor) rsa = RSA(factor=factor) decryptor = IBMDecryptor(rsa.n) elif args.option == "ibmqreal": factor = parseDefaultFactor(args.factor) rsa = RSA(factor=factor) decryptor = IBMDecryptorReal(rsa.n) elif args.option == "qsharp": factor = parseDefaultFactor(args.factor) rsa = RSA(factor=factor) decryptor = QSharpDecryptor(rsa.n) elif args.option == "numeric": if args.keysize != None: bits = args.keysize if bits % 2 != 0: print("Please provide an even keysize") exit(0) rsa = RSA(bits=bits) else: factor = parseDefaultFactor(args.factor) rsa = RSA(factor=factor) decryptor = NumericDecryptor(rsa.n) else: print("Wrong Arguments") exit(0) print("_____Starting Integer Factorization_____") p, q = decryptor.factorize() if p == None or q == None: return False print("_____Found factors!_____") print(f"The two factors are: {p} and {q}") phi = (p - 1) * (q - 1) d = mod_inverse(rsa.e, phi) print(f"The regenerated private key has the value\t(d={d}, {rsa.n})") return True
print('----------------------------') print('############################') print('############################') print('############################') print() use_own_values = ask_input("values_origin") if use_own_values == "1": print() print('Setting values up...') p = get_init_value_input('P: ') q = get_init_value_input('Q: ', p) e = get_e_value('E: ') print() rsa = RSA(p, q, e) elif use_own_values == "2": rsa = RSA.get_random_rsa() elif use_own_values == "3": run = False break show_values = ask_input("show_values") if show_values == "1": rsa.show_values() continue_with_instance = "1" while continue_with_instance == "1": print()
def test_decrypt_encrypt(self, p, q, e, m): rsa = RSA(p, q, e) self.assertEqual(m, rsa.decrypt(rsa.encrypt(m)))
#Servidor TCP import socket from rsa import RSA HOST = '' # Endereo IP do Servidor PORT = 8741 # Porta que o Servidor vai escutar tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM) orig = (HOST, PORT) rsa = RSA() rsa.gerar_chaves() header_l = 10 chave_privada = rsa.chave_privada tcp.bind(orig) tcp.listen(1) #msg = tcp.recv(header_l) while True: con, cliente = tcp.accept() print('Conectado por', cliente) while True: msg = con.recv(header_l).decode('utf-8') #tcp.recv(rsa.desencriptar(msg, chave_privada).decode("utf-8")) if not msg: break mensagem_desencriptada = con.recv( rsa.desencriptar(chave_privada).decode("utf-8")) print(mensagem_desencriptada) print('Finalizando conexao do cliente', cliente) con.close()
""" PORT = 50000 FSPORT = 49999 NAME = "CodeCafe" UserLst = [] usrDB = open("userdata", "rb") while 1: try: UserLst.append(cPickle.load(usrDB)) except EOFError: break usrDB.close() UserDict = dict([(u["username"], u) for u in UserLst]) RSAEncryptor = RSA() fLock = threading.RLock() fcode = "" usrdatLock = threading.RLock() boardLock = threading.RLock() def writeUserData(userlst): """ Persistance for userdate """ with usrdatLock: ouf = open("userdata", "wb") for user in userlst:
def test_generatePrimes(): rsa = RSA() p, q = rsa.generatePrimes() assert fermats(p) == True assert fermats(q) == True
def test_generateExp(): rsa = RSA() assert rsa.generateDecExp(885320963, 238855417, 9007) == 116402471153538991
def test_toNum(): rsa = RSA() assert rsa.toNum("cat") == 121029
def test_attack(): rsa = RSA() assert rsa._RSA__secret_key[0] == attack(rsa.public_key[0])
def test_decrypt(p, q, e, cipher, decrypted): rsa = RSA(p, q, e) assert rsa.decrypt(cipher) == decrypted
import errno import re import random import sys from rsa import RSA HEADER_LENGTH = 100 IP = ""127.0.0.1"" PORT = 5555 FORMAT = 'utf-8' if(len(sys.argv) < 6): print("{}-{}".format(sys.argv[1], sys.argv[2])) rsa = RSA(int(sys.argv[1]), int(sys.argv[2])) else: print("Ejecute los primos en la forma python client.py primo1 primo2") exit() user_n, user_e = rsa.public_key user_n = user_n user_e = user_e public_key = "{}-{}".format(user_n, user_e) # Create a socket client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Connects to server client_socket.connect((IP, PORT)) client_socket.setblocking(False)
y, last_y = last_y - q * y, y return last_r, last_x * (-1 if a < 0 else 1), last_y * (-1 if m < 0 else 1) def modinv(a, m): g, x, y = extended_gcd(a, m) if g != 1: raise ValueError return x % m plaintext = b'text Jun3 bug!' ciphertexts = [] for _ in range(3): cipher = RSA(150) ciphertexts.append([cipher.encrypt(plaintext), cipher.n]) (c_0, n_0), (c_1, n_1), (c_2, n_2) = ciphertexts c_0, c_1, c_2 = int.from_bytes(c_0, 'big'), int.from_bytes(c_1, 'big'),\ int.from_bytes(c_2, 'big') ms_0, ms_1, ms_2 = n_1 * n_2, n_0 * n_2, n_0 * n_1 result = ((c_0 * ms_0 * modinv(ms_0, n_0)) + (c_1 * ms_1 * modinv(ms_1, n_1)) +\ (c_2 * ms_2 * modinv(ms_2, n_2))) result = result % (n_0 * n_1 * n_2) lo, hi = 0, result while lo < hi: mid = (lo + hi) // 2 if mid**3 < result:
def __init__(self, keylen): self.rsa = RSA(keylen)
def brute_force(target, public_key, word_size): start = perf_counter() for word in product(ascii_letters, repeat=word_size): word = ''.join(word) encrypted_word = rsa_encrypt ( bytes_to_int(bytes(word, "utf-8")), public_key ) if encrypted_word == target: end = perf_counter() elapsed = end - start print(f"Found match: \"{word}\" in {elapsed} seconds") break if __name__ == "__main__": public_key = RSA ( public_exponent=65537, key_size=2048 ).public_key four_letter_word = b"Wish" five_letter_word = b"Allow" four_letter_word_as_int = bytes_to_int(four_letter_word) five_letter_word_as_int = bytes_to_int(five_letter_word) encrypted_four_letter_word = rsa_encrypt ( four_letter_word_as_int, public_key ) encrypted_five_letter_word = rsa_encrypt ( five_letter_word_as_int, public_key )
def generateRsaKeys(self): # вызыфвать один раз при регистрации! result = RSA(12).getKeys() self.open_key, self.secret_key = result return result
#!/usr/bin/env python from rsa import RSA from dh import DHUser, DHSession from elgamal import EGUser, EGSession if __name__ == '__main__': # RSA # CRYPTO-19 c19 = RSA(17, 11, 7) assert c19._d == 23 assert c19.public_key() == (7, 187) assert c19.private_key() == (23, 187) # CRYPTO-20 c = RSA.encrypt(c19.public_key(), 88) m = RSA.decrypt(c19.private_key(), c) assert c == 11 assert m == 88 # Diffie-Hellman # CRYPTO-35 dh_session = DHSession(353, 3) dh_user_a = DHUser(dh_session, 97) dh_user_b = DHUser(dh_session, 233) assert dh_user_a.y == 40 assert dh_user_b.y == 248 assert dh_session.session_key(dh_user_a, dh_user_b) == \ dh_user_a.session_key(dh_user_b.public_key()) == \ dh_user_b.session_key(dh_user_a.public_key()) == 160
l, u = max(a, ceil(2 * B + r * n, s)), min(b, (3 * B - 1 + r * n) // s) if l > u: print('Something Wrong') return appendAndMerge(M_new, l, u) if len(M_new) == 0: print('Something Wrong!!') return M = M_new i += 1 if __name__ == '__main__': plaintext = b'howdy!' print('Plaintext -', plaintext) m = pkcs1_5Pad(plaintext, 32) print('m -', m) cipher = RSA(256) c = cipher.encrypt(m) print('c -', c) print('Does c have the right padding -', is_padding_correct(c, cipher)) decrypted_plaintext = attack(c, cipher, 32) print('Decrypted Plaintext -', decrypted_plaintext) print('Are they same? ', plaintext == decrypted_plaintext)
from dh_simple import DHSimple from dlp import DLP from rsa import RSA from pinkas import Pinkas curve = prime192v1 key_size = 1024 M = 1 N = 1 print("Creating worlds...") schemes = [ DHSimple(ECGroup(curve)), DLP(ECGroup(curve)), Pinkas(ECGroup(curve)), RSA(key_size) ] Ms = [random.randrange(N) for _ in range(M)] print("Testing OT", M, "of", N) for OT in schemes: print(OT.__class__.__name__) a, b = OT.gen_params() OT.gen_msgs(a, N) ts_setup = time.time() b.update(OT.setup(a)) ts_setup = time.time() - ts_setup ts_mask = [] ts_total = time.time()
or not; it verifies the compositeness of the number through modular exponentiation. Args: n: number to test. k: number of times that `n` will be tested for primality. Returns: True means "probably prime", whereas False means "composite". Numbers known as Carmichael numbers are examples of false positives to this test. """ if n <= 3: return True if n & 1 == 0: return False return all(pow(randrange(2, n - 1), n - 1, n) == 1 for _ in range(k)) nbits = [2**i for i in range(6, 13)] start = datetime.now() for i in nbits: while True: p, q = getrandbits(i), getrandbits(i) if fermat(p, 100) and fermat(q, 100): end = datetime.now() print("Time: {}\tBits: {}\n{}\n".format(end - start, i, RSA(p, q))) break
from ca import CA from datetime import datetime, timedelta from utils import verify_certificate # Global Constants NBYTES = SHA.digest_size + 1 BYTES_TO_BITS = 8 MAX_ID = 30 RSA_KEY_BITS = 512 ######################################################################################################################## # CA Creation ca = CA(NBYTES) # RSA Creation rsa = RSA(RSA_KEY_BITS) # Alice and Bob Parameters q = generate_safe_prime(NBYTES * BYTES_TO_BITS) a = random.randint(2, q - 1) ######################################################################################################################## # Alice Keys x_a = random.randint(2, q - 1) y_a = pow(a, x_a, q) id_a = random.randint(1, MAX_ID) d_a, e_a, n = rsa.generate_key_pair() print("Alice Certificate...")
def test_encrypt(self, p, q, e, m, encrypted): rsa = RSA(p, q, e) self.assertEqual(encrypted, rsa.encrypt(m))
def __init__(self): self.rsa = RSA() self.pub, self.private = self.rsa.keygen(l=512)
def on_click2(self): self.crypt = RSA() helpMessage = 'use method: ' + self.crypt.name + '\nkey: ' + self.crypt.key self.textbox[2].setText(helpMessage)
from rsa import RSA import requests import json key_req = requests.get('http://asymcryptwebservice.appspot.com/rsa/serverKey?keySize=256') n1 = key_req.text n1 = int(json.loads(n1)['modulus'], 16) e1 = key_req.text e1 = int(json.loads(e1)['publicExponent'], 16) a = RSA(256, 'A') a.GenerateKeyPair() while a.o_key[1] > n1: a = RSA(256, 'A') a.GenerateKeyPair() e, n = a.o_key a.log += f"Отримані Modulus та publicExponent: n1 = {n1} , e1 ={e1}\n" request = f"http://asymcryptwebservice.appspot.com/rsa/sendKey?modulus={hex(n)[2:]}&publicExponent={hex(e)[2:]}" keygen_request = requests.get(request, cookies=key_req.cookies).text k1 = int(json.loads(keygen_request)['key'], 16) s1 = int(json.loads(keygen_request)['signature'], 16) a.log += f"Отримані Key та Signature: k1 = {k1} , s1 = {s1}\n"
Project was made for a College project. No warranty, may occur side effects. Program is in test phase. Algorithm worsk well, efficiently with 512 bit key generation Project by: Zselenák Flórián """ from rsa import RSA import timeit import math import random import time if __name__ == '__main__': rsa_object = RSA() print("[+] Generating keys! Be patient! :) ") print() start = timeit.default_timer() rsa_object.generate_keys(512) stop = timeit.default_timer() print("[i] Keys generated!") print('[+] Elapsed time:', stop-start) print() print("[i] Your public key is: ") time.sleep(.5) print(rsa_object.get_elements()) print() raw_text = input("Write a message to encrypt: ") start = timeit.default_timer()
from base64 import b32encode, b32decode from rsa import RSA import sys if __name__ == '__main__': filename = sys.argv[1] if len(sys.argv) == 2: rsa = RSA(p=199, q=179) else: rsa = RSA(p=int(sys.argv[3]), q=int(sys.argv[3])) with open(filename, 'rb') as file1: data = file1.read() rsa = RSA(p=199, q=179) print("\tP:", rsa.p, "\n\tQ:", rsa.q, "\n\tE:", rsa.e, "\n\tN:", rsa.n, "\n\tD:", rsa.d) str = b32encode(data) dta = str.decode("ascii") print("Encrypting...") enc = rsa.encrypt_string(dta) with open(filename.split('.')[0] + ".encrypted", 'w') as file2: file2.write(enc) print("Decrypting...") dec = rsa.decrypt_string(enc) restored = b32decode(dec) with open(filename.split('.')[0] + ".decrypted", 'wb') as file4: file4.write(restored)
def __init__(self): self.rsa = RSA(1024)
from rsa import RSA my_rsa = RSA() def test_rsa(key_size, original_text): print() private_key, public_key_1, public_key_2 = my_rsa.generate_keys(key_size) print( "Keys generated({key_size} bits): private: {private_key} public 1: {public_key_1} public 2: {public_key_2}" .format(**locals())) encrypted_text = my_rsa.encrypt(original_text, public_key_1, public_key_2) print("Encrypted {original_text} to {encrypted_text}".format(**locals())) decrypted_text = my_rsa.decrypt(encrypted_text, private_key, public_key_1) print("Decrypted {encrypted_text} to {decrypted_text}".format(**locals())) print("Test success :{}".format(str(original_text == decrypted_text))) test_rsa(32, "Go!") test_rsa(64, "AB%CD") test_rsa(96, "Longer word")