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 receive():
"""Recebimento de mensagens"""
while True:
try:
data = client_socket.recv(BUFSIZ)
msg = pickle.loads(data)
print("Essa é a msg recebida cifrada :", msg)
for i in range(len(chaves_rec)):
chaves_rec.pop()
rec = msg[1] #vetor de chaves publicas recebida
if len(rec) == 0:
pass
else:
chaves_rec.append(rec)
print("Chaves publicas recebidas nessa rodada:", chaves_rec)
if msg[3] == 'servidor':
msg_list.insert(tkinter.END, msg[0])
else:
private_key = (msg[2], k, p)
print("minha chave privada", private_key)
dr_msg = decrypt(msg[0], private_key)
dmsg = ''.join(dr_msg)
print("Mensagem decifrada :", dmsg)
nome = msg[3]
msg_exibida = str(nome) + str(dmsg)
msg_list.insert(tkinter.END, msg_exibida)
print("nome socket ",
client_socket.getsockname()) # minha porta
#print("recebe esse nº %i de chaves", len(chaves_rec))
except OSError: # Possibilidade do cliente deixar o chat.
break
def attack_elgamal(_primitive_root, _public_key, _prime, header, message):
l = discrete_log(prime=_prime,
primitive_root=_primitive_root,
public_key=_public_key)
decrypted_message = decrypt(message, header, l, _prime)
return decrypted_message
pass
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 compute_GT(self, sk, pk, C):
scheme = self.cipher_suite.scheme
if scheme == "Paillier":
for c in C:
if paillier.decrypt(sk, pk, c) == 0:
return 1 # x > y
else:
return 0 # x <= y
elif scheme == "ElGamal":
for c in C:
if elgamal.decrypt(sk, c) == 1:
return 1 # x > y
else:
return 0 # x <= y
def receive():
"""Recebimento de mensagens"""
while True:
try:
data = client_socket.recv(BUFSIZ)
msg = pickle.loads(data)
print("Essa é a msg recebida :", msg)
for i in range(len(chaves_rec)):
chaves_rec.pop()
rec = msg[1] #vetor de chaves publicas recebida
if len(rec) == 0:
pass
else:
chaves_rec.append(rec)
print("Chaves recebidas nessa rodada:", chaves_rec)
# decifra
print("mgs possui : ", len(msg))
print("mgs q chegou :", msg)
if msg[3] == 'servidor':
msg_list.insert(tkinter.END, msg[0])
else:
private_key = (msg[2], k, p)
dr_msg = decrypt(msg[0], private_key)
dmsg = ''.join(dr_msg)
print("Decrypted Message :", dmsg)
nome = msg[3]
msg_exibida = str(nome) + str(dmsg)
msg_list.insert(tkinter.END, msg_exibida)
#print(msg[0])
# a msg é um vetor de 2 posições [ msg , lista de chaves]
#chaves_rec.append(msg)
#print(chaves_rec)
######## DECIFRA A MSG RECEBIDA ###############
#original msg = client_socket.recv(BUFSIZ)
print("nome socket ", client_socket.getsockname())
# nessa parte acredito que pode ocorrer a decifragem
######## DECIFRA A MSG RECEBIDA ###############
print("recebe esse nº %i de chaves", len(chaves_rec))
#msg_list.insert(tkinter.END, msg[0])
except OSError: # Possibilidade do cliente deixar o chat.
break
def recover(self, x1, x2):
# Attempt to recover the coin private key
p = x1 + hash_to_scalar(x2 * self.R, self.i)
if not p * G == self.P:
raise ValueError('Failed to recover coin!')
# Recover the coin value
v = elgamal.decrypt(self.enc_v, p)
# Confirm the commitment is valid
if not com(v,
hash_to_scalar('mask', hash_to_scalar(x2 * self.R,
self.i))) == self.C:
raise ValueError('Coin commitment does not match!')
self.p = p
self.v = v
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 gamald(privateKey):
for i in range(5):
for j in range(2):
aux2 = ('decrypt%s%s.txt' % (i + 1, j + 1))
aux1 = ('elgamal%s%s.txt' % (i + 1, j + 1))
tiempo_inicial = time()
with open(aux1, "r") as f:
file = open(aux2, "w")
file.write('INSERT INTO dgamal%s%s' % (i + 1, j + 1) +
' (decrypt)\n')
for linea in f.readlines():
linea = linea.rstrip("\n")
plaintext = elgamal.decrypt(privateKey, linea)
file.write('VALUES' + ' ("' + plaintext + '"), ' + '\n')
file.close()
tiempo_final = time()
tiempo_ejecucion = tiempo_final - tiempo_inicial
print(' Duracion Decrypt El Gamal h%s%s' % (i + 1, j + 1),
tiempo_ejecucion)
def test_attack_elgamal(self):
#Alice
p = 1009
b = 101
c = 482
l = discrete_log(prime=p,
primitive_root=b,
public_key=c)
#Bob
x = 559
r = 291
c_to_the_r = fast_exponentiation(c, r, p)
encrypted_message = x * c_to_the_r % p
header = fast_exponentiation(b, r, p)
decrypted_message = decrypt(encrypted_message, header, l, p)
print attack_elgamal(_primitive_root=b,
_public_key=c,
_prime=p,
message=encrypted_message,
header=header)
abort = False
#on verifie que le destinataire a une clef
info_pk = generateurKeystore.exportSec(args.user_id)
if info_pk < 0:
abort = True
print "Destinaire n'a pas de clef"
fichier = open(args.in_info, "r")
lines=fichier.readlines()
cle_enc = ''.join(lines[:1])
message_crypte = ''.join(lines[1:])
fichier.close()
if abort is False and message_crypte == "":
abort = True
print "Le message crypté est vide"
if not abort:
sess_key = elgamal.decrypt(info_pk[2], cle_enc)
message_dec = aescrypt.decrypt(sess_key,message_crypte, "genereiv".encode('hex'))
fichier_out=open(args.out_info, "w")
fichier_out.write(message_dec)
fichier_out.close()
print "Message décrypté écrit dans "+args.out_info
else :
print("commande imcomprise")
#we wait for an aes key
pubKey, privKey = elg.p1getKeys(256)
sock.connect((HOST, PORT))
sock.sendall(bytes('%d\n' % pubKey.p + '%d\n' % pubKey.g +
'%d' % pubKey.x))
print('1')
#serKey = str(sock.recv(1024)).strip()
#encKey = str(sock.recv(1024)).strip()
serKey = sock.recv(1024)
encKey = sock.recv(1024)
#after receiving the key we can convert it back to
#its original form and begin communicated via aes with
#the server
print('2')
aesInt = elg.decrypt(int(serKey), privKey, int(encKey), pubKey.p)
aesHex = "%08x" % aesInt
aesKey = aesHex.strip().decode('hex')
print('3')
obj = AES.new(aesKey, AES.MODE_CFB, 'This is an IV456')
message = 'hey whats up?'
ciphertext = obj.encrypt(pad(message))
print
print 'plaintext: ' + message
sock.sendall(bytes(ciphertext))
print 'sent: ' + ciphertext
reply = str(sock.recv(1024)).strip()
print
print 'received: ' + reply
print 'plaintext: ' + obj.decrypt(reply).rstrip(padding)
import elgamal
import time
k = elgamal.generate_keys()
#returns a dictionary {'privateKey': privateKeyObject, 'publicKey': publicKeyObject}
print (k['publicKey'])
#elgamal.generate_keys(n, t)
fp = open("150kb")
text = []
for line in fp:
text.append(line)
text = "".join(text)
start_time = time.time()
cipher = elgamal.encrypt(k['publicKey'],text)
print("---150kb Encryption %s seconds ---" % (time.time() - start_time))
#returns a string
f = open ('encryption150.txt', 'w')
f.write(str(cipher)) #write ciphertext to file
f.close()
start_time = time.time()
plaintext = elgamal.decrypt(k['privateKey'], cipher)
print("---150kb Decryption %s seconds ---" % (time.time() - start_time))
#returns the message passed to elgamal.encrypt()
f = open ('decryption150.txt', 'w')
f.write(str(plaintext)) #write ciphertext to file
f.close()
def IsAliceRicher(C, sk):
ansTemp = 0
for c in C:
if elgamal.decrypt(sk, c) == 1:
ansTemp = 1 # x >y
return ansTemp
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()
def decrypt(prkey: elgamal.PrivateKey):
string = input("Give the text to decrypt ")
res = elgamal.decrypt(prkey, string)
print(res)
def elgamaDecrypt(cls, cipher, elGamalKeys):
plaintext = elgamal.decrypt(elGamalKeys['privateKey'], cipher)
print(plaintext)
# 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)
result = re.match(r'\((\d+),(\d+)\)', l)
c = int(result.group(1))
d = int(result.group(2))
#Add extracted cipher
ciphers.append(elgamal.CipherBlock(c,d))
keyFile = open("K2", 'r')
p = int(keyFile.readline())
g = int(keyFile.readline())
x = int(keyFile.readline())
keyFile.close()
key = elgamal.PrivateKey(p,g,x)
blocks = []
#Generate a list of decrypted blocks
for c in ciphers:
blocks.append(elgamal.decrypt(c, key))
#Set the blocklength for the decoder
encoder.BLOCKLENGTH = int(sys.argv[1])
#Decode the blocks to a string
message = encoder.decode(blocks)
#Write out
textFile = open("Plaintext", 'w')
textFile.write(message)
textFile.close()
print("City is becoming sleep")
print("...")
print("Mafia awakes")
print("Change that diplom, Johny")
another_dyplom = input()
weird_signature = create_signature(another_dyplom)
print("false dyplom with hsa512 injection:")
print(weird_signature)
bad_keys = elgamal.generate_keys(128)
bad_priv = bad_keys['publicKey']
false_mesg = elgamal.encrypt(bad_priv, signature)
print("Encrypted false dyplom:")
print(true_mesg)
print("\0")
receiver_1 = elgamal.decrypt(pub, false_mesg.encode(encoding='UTF-16'))
receiver_2 = elgamal.decrypt(pub, true_mesg.encode(encoding='UTF-16'))
print("Decrypted true dyplom:")
print(signature)
print("Decrypted false dyplom:")
print(weird_signature)
print("\0")
#if(receiver_1 == receiver_2):
#print("First step was passed,Johny")
#else:
#print("He found your mistake,Johny")
wrong_msg = receiver_1[0:data_lenth]
right_msg = receiver_2[0:data_lenth]
#if(verify_signature(wrong_msg, receiver_1)):
import elgamal keys = elgamal.generate_keys() priv = keys['privateKey'] pub = keys['publicKey'] message = "ya popochka" print(message) cipher = elgamal.encrypt(pub, message) print(cipher) plain = elgamal.decrypt(priv, cipher) print(plain)
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
