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
