def main():
mode = int(input("Enter mode(1 - encode, 2 - decode) :"))
if mode == 1:
source = input("Enter file name: ")
data = readFromFile(source)
h1 = sha256()
h1.update(data)
hash = [i for i in h1.digest()]
rsa = RSA.RSA()
public, private = rsa.encrypt('signature_' + source, hash)
else:
source = input("Enter file name: ")
signature = input("Enter signature name: ")
pub_exp = int(input("Enter public exponent: "))
pub_module = int(input("Enter public module: "))
public = (pub_exp, pub_module)
data = readFromFile(source)
h1 = sha256()
h1.update(data)
hash1 = [i for i in h1.digest()]
rsa = RSA.RSA()
hash2 = rsa.decrypt(signature, public)
if hash1 == hash2:
print("Verified")
else:
print("Not verified")
def OnGo(self, e):
if self.labels == ['Tetris']:
import Tetris
else:
wait = wx.BusyCursor()
rsa.RSA(self.paths, self.files, self.labels)
del wait
def decrypt(self):
cipher_path = self.ciphertext_entry.get()
key_path = self.private_keys_entry.get()
try:
if len(cipher_path) == 0 or len(key_path) == 0:
raise Exception(
"Please select the ciphertext and private key !")
if not isfile(cipher_path) or not isfile(key_path):
raise Exception("Cannot find the specified file !")
with open(key_path, 'r') as infile:
key = infile.read()
private_key = int(key.split(",")[0]), int(key.split(",")[1])
# Do the decryption here
cipher = rsa.RSA()
start = time.clock()
result = cipher.decrypt(cipher_path, private_key)
end = time.clock()
result_string = "".join(chr(x) for x in result)
self.decryption_result_message.delete(1.0, END)
self.decryption_result_message.insert(INSERT, result_string)
summary = "Elapsed = " + str(end - start) + " seconds\n"
summary += "File Size = " + str(len(result_string)) + " bytes"
messagebox.showinfo("Summary", summary)
except Exception as e:
messagebox.showerror("Exception Caught!", str(e))
def encrypt(self):
plaintext_path = self.plaintext_entry.get()
key_path = self.public_keys_entry.get()
try:
if len(plaintext_path) == 0 or len(key_path) == 0:
raise Exception("Please select the plaintext and public key !")
if not isfile(plaintext_path) or not isfile(key_path):
raise Exception("Cannot find the specified file !")
# Do Encryption here
with open(key_path, 'r') as infile:
key = infile.read()
public_key = int(key.split(',')[0]), int(key.split(',')[1])
cipher = rsa.RSA()
start = time.clock()
result = cipher.encrypt(plaintext_path, public_key)
end = time.clock()
self.result_string = " ".join([hex(x) for x in result])
self.encryption_result_message.delete(1.0, END)
self.encryption_result_message.insert(INSERT, self.result_string)
summary = "Elapsed = " + str(end - start) + " seconds\n"
summary += "File Size = " + str(len(self.result_string) +
2) + " bytes"
messagebox.showinfo("Summary", summary)
except Exception as e:
messagebox.showerror('Exception Caught', str(e))
def generate_keys(self):
try:
if not self.random_length_entry_p.get(
) or not self.random_length_entry_q.get():
raise Exception('Please specify the length of p and q')
if not self.random_length_entry_p.get().isdigit(
) or not self.random_length_entry_q.get().isdigit():
raise Exception('The length must be an integer')
if int(self.random_length_entry_p.get()) <= 0 or int(
self.random_length_entry_q.get()) <= 0:
raise Exception('The length must larger than zero')
cipher = rsa.RSA()
p = cipher.generate_prime(
length=int(self.random_length_entry_p.get()))
q = cipher.generate_prime(
length=int(self.random_length_entry_q.get()))
public_keys, private_keys = cipher.generate_keys(p, q)
self.public_key_e_entry.delete(0, END)
self.public_key_n_entry.delete(0, END)
self.private_key_d_entry.delete(0, END)
self.private_key_n_entry.delete(0, END)
self.public_key_e_entry.insert(0, str(public_keys[0]))
self.public_key_n_entry.insert(0, str(public_keys[1]))
self.private_key_d_entry.insert(0, str(private_keys[0]))
self.private_key_n_entry.insert(0, str(private_keys[1]))
except Exception as e:
messagebox.showerror('Exception Caught', str(e))
def __init__(self):
self.RSA = rsa.RSA()
self.DSA = dsa.DSA()
self.keys = self.RSA.get_key_pair()
print("Client RSA private key: ", self.keys[1])
print("Client RSA public key: ", self.keys[0])
print(
"=================================================================="
)
N = 160
L = 1024
self.dsa_p, self.dsa_q, self.dsa_g = self.DSA.generate_params(L, N)
self.dsa_priv_key, self.dsa_pub_key = self.DSA.generate_keys(
self.dsa_g, self.dsa_p, self.dsa_q)
print("Client DSA private key: ", self.dsa_priv_key)
print("Client DSA public key: ", self.dsa_pub_key)
print(
"=================================================================="
)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect(('localhost', 8989))
self.server_pub_key = None
self.server_dsa_pub_key = None
self.requesting_thread = None
self.listening_thread = None
self.threads = []
def new_keys(self):
""" Generate new RSA keys. """
debut = time.clock()
bits = self.nb_bits / 2
self.rsa = rsa.RSA(nb_bits = self.nb_bits)
fin = time.clock()
print "Nouvelles clés de " + str(self.nb_bits) + \
" bits générées en " + str(fin - debut) + " secondes."
def test_message_transmission_controlledkeys(self):
rigged = crypto.RSA(8, p=11, q=3, e=3)
jane = agent.Agent(c=rigged)
assert jane.get_public_key() == (33, 3), jane.get_public_key()
assert jane.c.d == 7
y = self.alice.encrypt_message(7, jane.get_public_key())
p = jane.decrypt_message(y)
assert p == 7
def main():
args = init_vars()
dir = args.fin
with open(dir, 'rb') as f:
file = f.read()
r = rsa.RSA(100)
# print(list(map(int, file)))
key_o, key_s = r.getKeys()
cr = r.encrypt(file, key_s)
with open(dir + '.crypt', 'w') as f:
f.write(cr)
with open(dir + '.crypt', 'r') as f:
file = f.read()
with open('decrypt_' + dir, 'bw') as f:
to_write = r.decrypt(file, key_o)
# print(to_write)
to_write = bytes(to_write)
f.write(to_write)
def testRSA():
testRSA = rsa.RSA()
valuesForTesting = [
u"123\n456\n78\n90", u"Лєл╣ЛЈЛЄ\n", u"qw\nert\ny", u"├▒├│├Д├А\n├Е",
u"@#\n$%^", u"12#$fg\nл╣ЛЉЛЈ├▒", u"Яа╣\nЯа╣",
u"Юёъ├▒аѕГЮёъл╣Юёъad12!", u"аицаицаицаиц"
]
for i in valuesForTesting:
fileWithTextToEncrypt = open("fileWithTextToEncrypt",
"w",
encoding='utf-8')
fileWithTextToEncrypt.write(i)
fileWithTextToEncrypt.close()
fileWithEncryptedText = open("fileWithEncryptedText",
"w",
encoding='utf-8')
fileWithEncryptedText.close()
fileWithDecryptedText = open("fileWithDecryptedText",
"w",
encoding='utf-8')
fileWithDecryptedText.close()
testRSA.encrypt("fileWithTextToEncrypt", "fileWithEncryptedText",
"public.key")
testRSA.decrypt("fileWithDecryptedText", "fileWithEncryptedText",
"private.key")
fileWithTextToEncrypt = open("fileWithTextToEncrypt",
"r",
encoding='utf-8')
source = ""
for line in fileWithTextToEncrypt:
source = source + line
fileWithTextToEncrypt.close()
fileWithDecryptedText = open("fileWithDecryptedText",
"r",
encoding='utf-8')
target = ""
for line in fileWithDecryptedText:
target = target + line
fileWithDecryptedText.close()
assert source == target
def main():
parser = create_parser()
args = parser.parse_args(sys.argv[1:])
rsa = rsa_module.RSA(random_seed=args.seed)
print("public key = %s" % str(rsa._pub))
print("private key = %s" % str(rsa._pri))
input_file = open(args.input_file, 'rb')
output_file = open(args.output_file, 'wb')
inputbytes = input_file.read()
outputbytes = None
if args.decrypt:
outputbytes = rsa.decrypt(inputbytes)
else:
outputbytes = rsa.encrypt(inputbytes)
output_file.write(outputbytes)
input_file.close()
output_file.close()
def __init__(self):
self.RSA = rsa.RSA()
self.DSA = dsa.DSA()
self.keys = self.RSA.get_key_pair()
print("Server RSA private key: ", self.keys[1])
print("Server RSA public key: ", self.keys[0])
print(
"=================================================================="
)
self.client_pub_key = None
self.client_dsa_pub_key = None
self.dsa_p = None
self.dsa_q = None
self.dsa_g = None
self.dsa_priv_key = None
self.dsa_pub_key = None
self.client_socket = None
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind(('localhost', 8989))
import rsa
import sys
if len(sys.argv) != 3:
print("Argumentos inválidos")
sys.exit()
#Cria objeto RSA
alg = rsa.RSA(13, 17, 2, 2)
alg.findPublicKey()
alg.findPrivateKey()
#Leitura de arquivo de entrada
inpString = ""
inp = open(sys.argv[2], 'r')
for line in inp:
inpString += line
#Limpa fim da string
inpString = inpString.rstrip()
#Determina modo de operação
if sys.argv[1] == 'e':
alg.encrypt(inpString)
elif sys.argv[1] == 'd':
alg.decrypt(inpString)
else:
print("Argumento inválido -- [e|d]")
import rsa
import json
import requests
tolik = rsa.RSA("tolik",512)
keygen_request = requests.get('http://asymcryptwebservice.appspot.com/rsa/serverKey?keySize=512')
cookie = keygen_request.cookies
cookie_name = cookie.keys()[0]
cookie_value = cookie.values()[0]
print("ім'я cookie: {}".format(cookie_name))
print("значення cookie: {}".format(cookie_value))
n1 = keygen_request.text
n1 = json.loads(n1)['modulus']
n1 = int(n1,16)
e1 = 65537
while tolik.Get_n() > n1:
tolik.GenerateKeyPair(512)
tolik.GetInfoForReport()
print('n1 сайта {}'.format(hex(n1)))
print('e1 сайта {}'.format(hex(e1)))
k1,s1=tolik.SendKey([e1,n1])
e,n = tolik.public_key
request = "http://asymcryptwebservice.appspot.com/rsa/receiveKey?key={k}&signature={s}&modulus={n}&publicExponent={e}".format(k=hex(k1)[2:],s=hex(s1)[2:],n=hex(n)[2:],e=hex(e)[2:])
cookie = {cookie_name:cookie_value}
print("відповідь ReciveKey сайту: ")
print(requests.get(request,cookies=cookie).text)
def _benchmark_rsa(key_length):
_helper_benchmark(rsa.RSA(key_length))
def __init__(self, c=None):
self.c = c if c else crypto.RSA(8)
def dec(useCRT=True):
k = key if useCRT else key.simplify()
rsa.RSA(k).decrypt_data(e)
def enc():
global e
e = rsa.RSA(key).encrypt_data(JUNK)
def __init__(self):
""" Constructeur de la fenêtre principale """
self.root = Tk()
self.root.title('Krypto RSA')
self.root.resizable(height = False, width = True)
# ---- Création d'un objet RSA ----
self.nb_bits = 128
self.rsa = rsa.RSA(nb_bits = self.nb_bits)
# ---- Définitions des formats de fichiers ----
self.formats = [ \
('Format', '*.key'), \
('Tous', '*.*') \
]
# ---- Champ de saisie ----
self.text = Text(self.root, wrap = WORD)
self.text.grid(row = 1, column = 1, columnspan = 2)
self.text.insert("1.0", lorem, lorem.encode('UTF-8'))
# ---- Bouttons ----
Button(self.root, text = 'Crypter', fg = 'black', \
command = self.code).grid(row = 2, column = 1)
Button(self.root, text = 'Décrypter', fg = 'black', \
command = self.decode).grid(row = 2, column = 2)
Scale(self.root, length=150, orient=HORIZONTAL, sliderlength = 25, \
label = 'Taille de la clé :', from_=128, to=1024, \
tickinterval = 256, resolution = 128, showvalue = 0, \
command = self.key_length).grid(row = 3, column = 1, \
columnspan = 2)
# ---- Menu de la fenêtre principale ----
barre = Menu(self.root)
# menu Fichier
menu_fichier = Menu(barre,tearoff=0)
menu_fichier.add_command(label="Crypter un texte", command = self.texte)
menu_fichier.add_separator()
menu_fichier.add_command(label="Quitter", command = self.root.quit)
# menu Clés
menu_cles = Menu(barre,tearoff=0)
menu_cles.add_command(label="Exporter", command = self.save_key)
menu_cles.add_command(label="Importer", command = self.loadKey)
menu_cles.add_separator()
menu_cles.add_command(label="Regénérer", command = self.new_keys)
menu_cles.add_command(label="Afficher", command = self.print_keys)
# menu Aide
menu_aide = Menu(barre,tearoff=0)
menu_aide.add_command(label="À propos de Krypto RSA", command = self.about)
barre.add_cascade(label="Fichier", menu=menu_fichier)
barre.add_cascade(label="Clés", menu=menu_cles)
barre.add_cascade(label="Aide", menu=menu_aide)
self.root.config(menu=barre)
self.root.mainloop()
#minimum required version python 3.7.0
import rsa, menu
codificacao = rsa.RSA()
submenus = {
'Gerar chave publica': codificacao.input_public_key,
'Encriptar': codificacao.input_encrypt,
'Desencriptar': codificacao.input_decrypt,
}
menu = menu.Menu(submenus)
menu.run()
#! /usr/bin/python
#-*- coding: utf-8 -*-
"""Execute this file to work on this challenge.
"""
import rsa
import utils
import time
if __name__ == '__main__':
print("Factoring RSA modulus with weak prime factors\n")
print("Loading RSA keys")
rsa_obj = rsa.RSA(a=0,
b=16219340638145739814556409984455971733340322034588741,
n=19674270149491236515870218329564212980341362732018899)
print(rsa_obj)
print("Factoring the modulus...")
start = time.time()
factors = utils.factors_decomposition(rsa_obj.modulus)
phi = (p - 1) * (q - 1)
# guess what are p and q ?
end = time.time()
print("Factorisation done in {} seconds\n".format(end - start))
print(str(rsa_obj.modulus) + " = " + \
" * ".join([str(i) for i in factors]) + \
" = n * q ")
print("Phi =", phi, "= (n - 1) * (q -1)")
private = utils.inv_modulo(rsa_obj.public, phi)
print("Private key: {}\n".format(private))
def setUp(self):
self.alice = agent.Agent()
self.bob = agent.Agent()
self.r = crypto.RSA(8, verbose=True)
self.pg = rp.RandomPrimeGenerator()