def test_general(self): bob_pubkey = elgamal.public_key(3761, 1891, 1864, elgamal.calcNumBits(3761)) alice_privkey = elgamal.private_key(3761, 1891, 1299, elgamal.calcNumBits(3761)) alice_pubkey = elgamal.public_key(3761, 1891, 3478, elgamal.calcNumBits(3761)) bob_privkey = elgamal.private_key(3761, 1891, 3722, elgamal.calcNumBits(3761)) message = "hello how are you" encrypted_msg = elgamal.encrypt(bob_pubkey, alice_privkey, message) plain_text_msg = elgamal.decrypt(alice_pubkey, bob_privkey, encrypted_msg) self.assertEqual(message, plain_text_msg) bob_pubkey = elgamal.public_key(449, 322, 100, elgamal.calcNumBits(449)) alice_privkey = elgamal.private_key(449, 322, 123, elgamal.calcNumBits(449)) alice_pubkey = elgamal.public_key(449, 322, 321, elgamal.calcNumBits(449)) bob_privkey = elgamal.private_key(449, 322, 122, elgamal.calcNumBits(449)) message = "jqerbu34 qaqfbiq23 2if892u" encrypted_msg = elgamal.encrypt(bob_pubkey, alice_privkey, message) plain_text_msg = elgamal.decrypt(alice_pubkey, bob_privkey, encrypted_msg) self.assertEqual(message, plain_text_msg) bob_pubkey = elgamal.public_key(1753, 391, 62, elgamal.calcNumBits(1753)) alice_privkey = elgamal.private_key(1753, 391, 1400, elgamal.calcNumBits(1753)) alice_pubkey = elgamal.public_key(1753, 391, 514, elgamal.calcNumBits(1753)) bob_privkey = elgamal.private_key(1753, 391, 999, elgamal.calcNumBits(1753)) message = "kjbeivb8999 n9u2ewn how are you" encrypted_msg = elgamal.encrypt(bob_pubkey, alice_privkey, message) plain_text_msg = elgamal.decrypt(alice_pubkey, bob_privkey, encrypted_msg) self.assertEqual(message, plain_text_msg) bob_pubkey = elgamal.public_key(5791, 760, 1277, elgamal.calcNumBits(5791)) alice_privkey = elgamal.private_key(5791, 760, 5123, elgamal.calcNumBits(5791)) alice_pubkey = elgamal.public_key(5791, 760, 4848, elgamal.calcNumBits(5791)) bob_privkey = elgamal.private_key(5791, 760, 4444, elgamal.calcNumBits(5791)) message = "hello how kn wsijvnij iowenfinwf e9w8u98y23 f9uh29f you" encrypted_msg = elgamal.encrypt(bob_pubkey, alice_privkey, message) plain_text_msg = elgamal.decrypt(alice_pubkey, bob_privkey, encrypted_msg) self.assertEqual(message, plain_text_msg)
def test_reshuffle(self): m = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() n = ed25519.scalar_random() self.assertEqual( elgamal.encrypt(m,y,r).reshuffle(n), elgamal.encrypt(m*n,y,r*n) )
def test_rerandomization(self): m = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() s = ed25519.scalar_random() self.assertEqual( elgamal.encrypt(m,y,r).rerandomize(s), elgamal.encrypt(m,y,r+s) )
def test_rekey(self): m = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() k = ed25519.scalar_random() self.assertEqual( elgamal.encrypt(m,y,r).rekey(k), elgamal.encrypt(m,y*k,ed25519.scalar_inv(k)*r) )
def get_TMatrix(x, pk): n = len(x) T = [[0] * n for i in range(2)] for j in range(n): T[x[j]][j] = elgamal.encrypt(pk, 1) T[1 - x[j]][j] = elgamal.random_cipher(pk) return T
def test_triples_pack_and_unpack(self): n = 5 triples = [ elgamal.encrypt( ed25519.Point.random(), ed25519.Point.random(), ed25519.scalar_random()) for i in range(n) ] cbuf1 = ristretto.ffi.new("unsigned char[]", n*96) for i in range(n): ristretto.ffi.memmove(cbuf1 + 96*i, triples[i].pack(), 96) ctriples = ristretto.ffi.new("elgamal_triple[]", n) cerror_codes = ristretto.ffi.new("int[]", n) ristretto.lib.elgamal_triples_unpack(ctriples, cbuf1, cerror_codes, n) for i in range(n): self.assertEqual(cerror_codes[i], 0) cbuf2 = ristretto.ffi.new("unsigned char[]", n*96) ristretto.lib.elgamal_triples_pack(cbuf2, ctriples, n) self.assertEqual( [ cbuf1[i] for i in range(96*n) ], [ cbuf2[i] for i in range(96*n) ])
def test_rsk(self): N = 5 n = ed25519.scalar_random() k = ed25519.scalar_random() r = [ed25519.scalar_random() for i in range(N)] target = ed25519.Point.random() triples = [ elgamal.encrypt(ed25519.Point.random(), target) for i in range(N) ] pseudonyms = [pep3_pb2.Pseudonymizable() for i in range(N)] for i in range(N): pseudonyms[i].data = triples[i].pack() self.pu.rsk(pseudonyms, k, n, r) for i in range(N): triples[i] = triples[i].rsk(k, n, r[i]) self.assertEqual( [triples[i] for i in range(N)], [elgamal.Triple.unpack(pseudonyms[i].data) for i in range(N)])
def send(event=None): # evento é passado por binders. """Envio de mensagens.""" #MANDA #[ [vetor_msg] , chave_p , [vetor_P(gamma)] , nome] cliente-> servidor #[ msg , [chaves_p ], p(nulo) , servidor] servidor-> cliente (msg privadas) #[ [vetor_msg][i] , [VETOR_CHAVES] , [vetor_P(gamma)][i] , NOME] servidor msg = my_msg.get() my_msg.set("") # Limpa o campo de entrada. ########## VETOR DE MSG CIFFRADA N VEZES ############### # a msg é um vetor de 2 posições [ vetor de msg , chave_p] #CHAVE PUBLICA DO USUÁRIO chave_p = (p, r, g) print("olha mantem chaves", len(chaves_rec)) print("chaves q tenho total", chaves_rec) if (len(marco_zero) == 0): print("Cadastro") msgs = [msg, chave_p, 0] marco_zero.append(0) print("ZIIIIIIIIIIICaAAAA") else: print("entrou 1") msgs_cif = [] #msgs cifradas gammas = [] #gamma de cada msg que incorpora a chave privada for i in range(len(chaves_rec[0])): en_msg, gamma = encrypt(msg, chaves_rec[0][i]) msgs_cif.append(en_msg) gammas.append(gamma) print("msg cifrada", msgs_cif) print("gammas", gammas) msgs = [msgs_cif, chave_p, gammas] #decifra # private_key=(gammas[0],k,p) #dr_msg = decrypt(msgs_cif[0], private_key) #dmsg = ''.join(dr_msg) #print("Decrypted Message :", dmsg) print("olha mantem chaves", len(chaves_rec[0])) print("chaves q tenho", chaves_rec[0]) lista_msg = [] for i in range(len(chaves_rec)): lista_msg.append(i) #msgs=[lista_msg,chave_p,0] msg_tratada = pickle.dumps(msgs) client_socket.send(msg_tratada) for i in range(len(chaves_rec)): chaves_rec.pop() if msg == "{quit}": client_socket.close() top.quit()
def test_pack(self): M = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() n = ed25519.scalar_random() triple_in = elgamal.encrypt(M, y) rsp, triple_out = schnorr.RSProof.create(triple_in, n, r) self.assertEqual(rsp, schnorr.RSProof.unpack(rsp.pack()))
def encrypt(pukey: elgamal.PublicKey): ok = False string = "" while not ok: string = input("Give the text to encrypt ") ok = verify(string) if not ok: print("Invalid Input! please use only letters and spaces") string = string.lower() res = elgamal.encrypt(pukey, string) print(res)
def test_create(self): M = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() n = ed25519.scalar_random() triple_in = elgamal.encrypt(M, y) rsp, triple_out = schnorr.RSProof.create(triple_in, n, r) self.assertEqual(triple_out, triple_in.rerandomize(r).reshuffle(n)) self.assertTrue( rsp.is_valid_proof_for(triple_in, ed25519.Point.B_times(n), triple_out))
def test_rsk(self): m = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() n = ed25519.scalar_random() k = ed25519.scalar_random() r2 = ed25519.scalar_random() triple = elgamal.encrypt(m,y,r) self.assertEqual( triple.rsk(k,n,r2), triple.rekey(k).reshuffle(n).rerandomize(r2) )
def test_triple_decrypt(self): key = ed25519.scalar_random() t = elgamal.encrypt( ed25519.Point.random(), ed25519.Point.B_times(key)) ckey = scalar_to_c(key) ct = triple_to_c(t) cresult = point_to_c(ed25519.Point.Zero()) ristretto.lib.elgamal_triple_decrypt(cresult, ct, ckey) result = point_from_c(cresult) self.assertEqual(result, t.decrypt(key))
def main(): with open("files/initial.txt", "r") as file: data = file.read() public_key, private_key = elgamal.generate_keys() print("\nPublic Key: {}\nPrivate Key: {}\n".format( public_key, private_key)) encrypted_data = elgamal.encrypt(data, public_key) write_to_file("files/encrypted.txt", encrypted_data) print("\nencrypted data:\n{}".format(encrypted_data)) decrypted_data = elgamal.decrypt(encrypted_data, private_key) write_to_file("files/decrypted.txt", decrypted_data) print("\ndecrypted data:\n{}".format(decrypted_data))
def test_triple_encrypt(self): a = ed25519.Point.random() t = ed25519.Point.random() r = ed25519.scalar_random() ca = point_to_c(a) ct = point_to_c(t) cr = scalar_to_c(r) ctriple = ristretto.ffi.new("elgamal_triple*") ristretto.lib.elgamal_triple_encrypt(ctriple, ca, ct, cr) triple = triple_from_c(ctriple) self.assertEqual(triple, elgamal.encrypt(a,t,r))
def gamaltop(msg): print("Original Message :", msg) p = randint(pow(10, 20), pow(10, 50)) # numero primo g = randint(2, p) k = gen_key(p) # chave privada r = power(g, k, p) # calcula a congruencia pra fazer algo print("g used : ", g) print("g^a used : ", r) public_key = (p, r, g) en_msg, gamma = encrypt(msg, public_key) private_key = (gamma, k, p) dr_msg = decrypt(en_msg, private_key) dmsg = ''.join(dr_msg) print("Decrypted Message :", dmsg)
def encode_x(self, pk, x): N = len(x) scheme = self.cipher_suite.scheme T = [[0] * N for i in range(2)] if scheme == "Paillier": for j in range(N): T[x[j]][j] = paillier.encrypt(pk, 0) # r = random.randint(0, pk.n-1) T[1 - x[j]][j] = paillier.random_cipher(pk) elif scheme == "ElGamal": for j in range(N): T[x[j]][j] = elgamal.encrypt(pk, 1) T[1 - x[j]][j] = elgamal.random_cipher(pk) return T
def send(event=None): # evento é passado por binders. """Envio de mensagens.""" msg = my_msg.get() my_msg.set("") # Limpa o campo de entrada. #CHAVE PUBLICA DO USUÁRIO chave_p = (p, r, g) print("Chaves q tenho", chaves_rec) if (len(marco_zero) == 0): print("Cadastro") msgs = [msg, chave_p, 0] marco_zero.append(0) else: if (msg != "{quit}"): print("Cifrar") msgs_cif = [] #msgs cifradas gammas = [] #gamma de cada msg que incorpora a chave privada for i in range(len(chaves_rec[0])): en_msg, gamma = encrypt(msg, chaves_rec[0][i]) msgs_cif.append(en_msg) gammas.append(gamma) print("vetor de msgs cifrada", msgs_cif) print(" vetor de gammas", gammas) msgs = [msgs_cif, chave_p, gammas] #lista_msg=[] #for i in range(len(chaves_rec)): #lista_msg.append(i) #msgs=[lista_msg,chave_p,0] if (msg == "{quit}"): msgs = [msg, chave_p, 7] msg_tratada = pickle.dumps(msgs) client_socket.send(msg_tratada) for i in range(len(chaves_rec)): chaves_rec.pop() if msg == "{quit}": client_socket.close() top.quit()
def gamal(publicKey): for i in range(5): for j in range(2): aux1 = ('h%s%s.txt' % (i + 1, j + 1)) aux2 = ('elgamal%s%s.txt' % (i + 1, j + 1)) tiempo_inicial = time() with open(aux1, "r") as f: file = open(aux2, "w") for linea in f.readlines(): linea = linea.rstrip("\n") cipher = elgamal.encrypt(publicKey, linea) file.write(cipher + '\n') # plaintext = elgamal.decrypt(privateKey, cipher) # print(plaintext) file.close() tiempo_final = time() tiempo_ejecucion = tiempo_final - tiempo_inicial print(' Duracion Encrypt El Gamal Archivo h%s%s' % (i + 1, j + 1), tiempo_ejecucion)
def test_triple_rsk(self): m = ed25519.Point.random() y = ed25519.Point.random() r = ed25519.scalar_random() s = ed25519.scalar_random() k = ed25519.scalar_random() r2 = ed25519.scalar_random() triple = elgamal.encrypt(m,y,r2) ctriple = ristretto.ffi.new("elgamal_triple*") ck = ristretto.ffi.new("group_scalar*") cs = ristretto.ffi.new("group_scalar*") cr = ristretto.ffi.new("group_scalar*") ristretto.lib.elgamal_triple_unpack(ctriple, triple.blinding.pack() + triple.core.pack() + triple.target.pack()) ristretto.lib.group_scalar_unpack(ck, ed25519.scalar_pack(k)) ristretto.lib.group_scalar_unpack(cs, ed25519.scalar_pack(s)) ristretto.lib.group_scalar_unpack(cr, ed25519.scalar_pack(r)) ristretto.lib.elgamal_triple_rsk(ctriple, ctriple, ck, cs, cr) cbuf = ristretto.ffi.new("unsigned char []", 96) ristretto.lib.elgamal_triple_pack(cbuf, ctriple) buf = ristretto.ffi.buffer(cbuf) triple2 = elgamal.Triple( ed25519.Point.unpack(buf[0:32]), ed25519.Point.unpack(buf[32:64]), ed25519.Point.unpack(buf[64:96])) triple = triple.rsk(k,s,r) self.assertEqual(triple.blinding, triple2.blinding) self.assertEqual(triple.core, triple2.core) self.assertEqual(triple.target, triple2.target)
def __init__(self, v, X1, X2, r, i): # Sanity checks if not isinstance(v, Scalar): raise TypeError('Invalid coin value!') if v > Scalar(2)**BITS - Scalar(1): raise ValueError('Value is out of range!') if not isinstance(X1, Point) or not isinstance(X2, Point): raise TypeError('Invalid destination address!') if not isinstance(r, Scalar): raise TypeError('Invalid recovery private key!') # Deterministic commitment mask mask = hash_to_scalar('mask', hash_to_scalar(r * X2, i)) # Coin data self.P = X1 + hash_to_scalar(r * X2, i) * G self.R = r * G self.C = com(v, mask) self.enc_v = elgamal.encrypt(v, self.P) self.i = i self.p = None self.v = None self.mask = mask # private data
def test_invalid_decryption(self): m = ed25519.Point.random() x = ed25519.scalar_random() y = ed25519.Point.B() * x with self.assertRaises(elgamal.WrongPrivateKey): elgamal.encrypt(m,y).decrypt(x+1)
keys = elgamal.generate_keys() key_for_client = keys.copy() del key_for_client['privateKey'] key_client = pickle.dumps(key_for_client, -1) # create a socket object s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host = socket.gethostname() port = 8000 s.connect((host, port)) s.send(key_client) key_server = s.recv(1024) key_server = pickle.loads(key_server) msg = " " while msg != "bye": msg = input("Client : ") cipher = elgamal.encrypt(key_server['publicKey'], msg) #returns a string print("Client(enc) : %s" % cipher) s.send(cipher.encode('ascii')) smsg = s.recv(1024) #.decode('ascii') plaintext = elgamal.decrypt( keys['privateKey'], smsg) #returns the message passed to elgamal.encrypt() print("Server(enc) : %s" % smsg) print("Server : %s" % plaintext) s.close()
del key_for_server['privateKey'] key_server=pickle.dumps(key_for_server,-1) # create a socket object serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host = socket.gethostname() port = 8001 serversocket.bind(('', port)) serversocket.listen(5) clientsocket,addr = serversocket.accept() print("Got a connection from %s" % str(addr)) msg=" " key_client=clientsocket.recv(1024) clientsocket.send(key_server) key_client=pickle.loads(key_client) while msg!="bye": smsg=clientsocket.recv(1024)#.decode('ascii') plaintext = elgamal.decrypt(keys['privateKey'],smsg) #returns the message passed to elgamal.encrypt() print("Client(enc) : %s" % smsg) print("Client : %s" % plaintext) msg=input("Server : ") cipher = elgamal.encrypt(key_client['publicKey'],msg) #returns a string print("Server(enc) : %s" % cipher) clientsocket.send(cipher.encode('ascii')) clientsocket.close()
while True: amount_received = 0 amount_expected = len(message) data = b'solicitando clave publica' print(data) sock.sendall(data) while amount_received < amount_expected: data = sock.recv(300) print(data) if data: restored = sock.recv(1024) key = pickle.loads(restored) file = open('cifrado1.txt', 'w') with open('salida1.txt', 'r') as j: for linea in j: data = elgamal.encrypt(key, linea) file.write(data) print('cifrado el archivo1') file2 = open('cifrado2.txt', 'w') with open('salida2.txt', 'r') as j: for linea in j: data = elgamal.encrypt(key, linea) file2.write(data) print('cifrado el archivo2') file3 = open('cifrado3.txt', 'w') with open('salida3.txt', 'r') as j: for linea in j: data = elgamal.encrypt(key, linea) file3.write(data) print('cifrado el archivo3') file4 = open('cifrado4.txt', 'w')
def elgamalEncrypt(cls, msg, elGamalKeys): cipher = elgamal.encrypt(elGamalKeys['publicKey'], msg) print(cipher) return cipher
# https://github.com/RyanRiddle/elgamal import sys import elgamal message = input("Ingrese el mensaje que desea cifrar con ElGamal: \n") # Por defecto genera llaves de 256 bits keys = elgamal.generate_keys() publicKey = keys['publicKey'] print("Prirmo: ", publicKey.p) print("Public: ", publicKey.h) privateKey = keys['privateKey'] print("Generador: ", privateKey.g) print("Private: ", privateKey.x) cipher = elgamal.encrypt(publicKey, message) print(cipher, "\n") plaintext = elgamal.decrypt(privateKey, cipher) print(plaintext)
def test_encryption(self): m = ed25519.Point.random() x = ed25519.scalar_random() y = ed25519.Point.B() * x self.assertEqual(m, elgamal.encrypt(m, y).decrypt(x))
from elgamal import keygen, encrypt, decrypt f, h, q, g, a = keygen() print f, h, q, g, a m = 65 ctxt, p = encrypt(m, f, h, q, g) print ctxt ptxt = decrypt(ctxt, f, h, q, g, p, a) print ptxt #shared_key2 = _keyX_2(sk2, s1a, mod) #print " " #print shared_key1 #print " " #print shared_key2
lines = messageFile.readlines() messageFile.close() #Load the lines of the meassage file to a string for l in lines: message += l; #Set the block length for the encoder encoder.BLOCKLENGTH = int(sys.argv[2]) blocks = encoder.encode(message) #Encode to a list of integers #Read the Public Key keyFile = open("K1", 'r') p = int(keyFile.readline()) g = int(keyFile.readline()) h = int(keyFile.readline()) keyFile.close(); key = elgamal.PublicKey(p,g,h) #Encrypt each block and write to file cipherFile = open("Cipher", 'w') for b in blocks: c = elgamal.encrypt(b, key) cipherFile.write("%s\n" % c) cipherFile.close()
abort = True print "Destinaire n'a pas de clef" fichier = open(args.in_info, "r") message = fichier.read() fichier.close() if abort is False and message == "": abort = True print "Le message est vide" if not abort: sess_key=random_key = base64.encodestring(urandom(16)) cle_enc = elgamal.encrypt(info_pk[2], sess_key) message_enc = aescrypt.encrypt(sess_key, message, "genereiv".encode('hex')) fichier_out=open(args.out_info, "w") fichier_out.write(cle_enc.decode()+"\n"+message_enc) fichier_out.close() print("Message encrypté écrit dans "+args.out_info) # ecctool -dec -id alice -in secret.crypt -out secret.txt elif args.dec: action = 0 if action != -1 and args.user_id: action = 2