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