def test_encode(p, q_set):
for __ in range(100):
_, public_key = generate_keys(p=p, q_set=q_set)
x = get_coprime_integer(public_key.p)
message = random.randint(1, 1000)
bx = pow(public_key.b, x, public_key.p)
b1 = public_key.p + bx
assert (message*b1) % public_key.p == (message*bx) % public_key.p
def generate_keypair(self):
cs = self.cipher_suite
scheme = cs.scheme
if scheme == "Paillier":
sk, pk = paillier.generate_keypair(cs.modulus_length)
# print(pk.n)
elif scheme == "ElGamal":
sk, pk = elgamal.generate_keys(cs.modulus_length)
# print(pk.p)
return sk, pk
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 menu(cls):
elGamalKeys = elgamal.generate_keys()
key = RSA.generate(2048)
public_key = key.publickey().export_key()
file_out = open("receiver.pem", "wb")
file_out.write(public_key)
file_out.close()
private_key = key.export_key()
file_out = open("private.pem", "wb")
file_out.write(private_key)
file_out.close()
print("-----------------------------------------------")
print("--------CRYPTAGE DECRYPTAGE ASYMETRIQUE--------")
print("-----------------------------------------------")
while (True):
print('\n')
choice = pyip.inputMenu(['Crypter un message', 'Quitter'])
if (choice == 'Crypter un message'):
method = pyip.inputMenu(['RSA', 'ElGamal'])
print(method)
if (method == 'RSA'):
choice, signature = AsymmetricEncryption.encrypt(
public_key, elGamalKeys, key, method=method)
else:
choice, cipher = AsymmetricEncryption.encrypt(
public_key, elGamalKeys, key, method=method)
print('\nVoulez-vous decrypter votre message ? ')
decrypt = pyip.inputMenu(['oui', 'non'])
if (decrypt == 'non'):
continue
elif (method == 'RSA'):
AsymmetricEncryption.decrypt(key, elGamalKeys, method,
choice, signature)
elif (method == 'ElGamal'):
AsymmetricEncryption.decrypt(key, elGamalKeys, method,
choice, cipher)
else:
return
def menu(cls):
elGamalKeys = elgamal.generate_keys()
key = RSA.generate(2048)
public_key = key.publickey().export_key()
file_out = open("receiver.pem", "wb")
file_out.write(public_key)
file_out.close()
private_key = key.export_key()
file_out = open("private.pem", "wb")
file_out.write(private_key)
file_out.close()
ascii_banner = pyfiglet.figlet_format("ASYMMETRIC ENCRYPTION")
print(ascii_banner)
while (True):
print('\n')
choice = pyip.inputMenu(['encryption', 'quit'])
if (choice == 'encryption'):
method = pyip.inputMenu(['RSA', 'ElGamal'])
print(method)
if (method == 'RSA'):
choice, signature = AsymmetricEncryption.encrypt(
public_key, elGamalKeys, key, method=method)
else:
choice, cipher = AsymmetricEncryption.encrypt(
public_key, elGamalKeys, key, method=method)
print('\nFor decryption : ')
decrypt = pyip.inputMenu(['yes', 'no'])
if (decrypt == 'no'):
continue
elif (method == 'RSA'):
AsymmetricEncryption.decrypt(key, elGamalKeys, method,
choice, signature)
elif (method == 'ElGamal'):
AsymmetricEncryption.decrypt(key, elGamalKeys, method,
choice, cipher)
else:
return
def create_genesis_block():
cipher = elgamal.generate_keys(seed=0xffffffffffffff, iNumBits=18)
return Block(0, time.time(), {"transactions": None}, cipher, 18)
def mine(a, blockchain, node_pending_transactions):
BLOCKCHAIN = blockchain
NODE_PENDING_TRANSACTIONS = node_pending_transactions
while True:
"""Mining is the only way that new coins can be created.
In order to prevent too many coins to be created, the process
is slowed down by a proof of work algorithm.
"""
# Get the last proof of work
last_block = BLOCKCHAIN[-1]
if last_block.index == 0:
time.sleep(1)
if (last_block.index + 2) % term == 2:
difficulty = Calculate_Difficulty(last_block.public_key_size)
NODE_PENDING_TRANSACTIONS = requests.get(MINER_NODE_URL +
"/txion?update=" +
MINER_ADDRESS).content
NODE_PENDING_TRANSACTIONS = json.loads(NODE_PENDING_TRANSACTIONS)
NODE_PENDING_TRANSACTIONS.append({
"from": "network",
"to": MINER_ADDRESS,
"amount": 1
})
new_block_data = {"transactions": list(NODE_PENDING_TRANSACTIONS)}
new_block_index = last_block.index + 2
new_block_timestamp = time.time()
before_header_hash_ = BLOCKCHAIN[-1].hash_header()
before_public = BLOCKCHAIN[-1].next_public
cipher = elgamal.generate_keys(
iNumBits=difficulty,
seed=int(before_public.p + before_public.g + before_public.h))
new_block_next_public = cipher
candidate_block = Block(new_block_index,
new_block_timestamp,
new_block_data,
new_block_next_public,
difficulty,
before_header_hash=before_header_hash_)
# Find the proof of work for the current block being mined
# Note: The program will hang here until a new proof of work is found
proof = proof_of_work(last_block, candidate_block, BLOCKCHAIN)
# If we didn't guess the proof, start mining again
if not proof[0]:
# Update blockchain and save it to file
BLOCKCHAIN = proof[1]
a.send(BLOCKCHAIN)
continue
else:
# Once we find a valid proof of work, we know we can mine a block so
# ...we reward the miner by adding a transaction
# First we load all pending transactions sent to the node server
'''
# Then we add the mining reward
NODE_PENDING_TRANSACTIONS.append({
"from": "network",
"to": MINER_ADDRESS,
"amount": 1})
# Now we can gather the data needed to create the new block
'''
# Empty transaction list
NODE_PENDING_TRANSACTIONS = []
# Now create the new block
BLOCKCHAIN.append(proof[0])
# print("before_public_key = " + str(proof[0].key.p * proof[0].key.q))
print(
json.dumps(
{
"index":
str(proof[0].index),
"timestamp":
str(proof[0].timestamp),
"header_hash":
str(proof[0].hash_header()),
"difficult":
str(proof[0].difficult),
"public_key_size":
str(proof[0].public_key_size),
"before_header_hash":
str(proof[0].before_header_hash),
"next_public":
"( " + str(hex(proof[0].next_public.g)) + ", " +
str(hex(proof[0].next_public.h)) + ", " +
str(hex(proof[0].next_public.p)) + " )",
"nonce":
"( " + str(proof[0].nonce) + " )",
"data":
proof[0].data
},
indent=4) + "\n")
a.send(BLOCKCHAIN)
requests.get(MINER_NODE_URL + "/blocks?update=" + MINER_ADDRESS)
if __name__ == "__main__":
args = get_args()
bitLen = int(args.bit_lenght)
if args.type == 'rsa':
(e, n), (d, n) = rsa.generate_keys(bitLen)
with open(args.key_name + '_public', 'w') as p:
p.write(str(e) + "\n")
p.write(str(n))
with open(args.key_name + '_private', 'w') as p:
p.write(str(d) + "\n")
p.write(str(n))
print "keys {0}_public and {0}_private {1} succesfully generated".format(args.key_name, bitLen)
if args.type == 'elgamal':
(p, g, y), (p, x) = elgamal.generate_keys(bitLen)
with open(args.key_name + '_public', 'w') as f:
f.write(str(p) + "\n")
f.write(str(g) + "\n")
f.write(str(y))
with open(args.key_name + '_private', 'w') as f:
f.write(str(p) + "\n")
f.write(str(x))
print "keys {0}_public and {0}_private {1} succesfully generated".format(args.key_name, bitLen)
if args.type == 'f_s':
(n, v), (n, s) = f_s.generate_keys(bitLen)
with open(args.key_name + '_public', 'w') as f:
f.write(str(n) + "\n")
f.write(str(v))
with open(args.key_name + '_private', 'w') as f:
""" Testing the elgamal module """
if __name__ == "__main__":
# Documents to sign
msgs = ["ECRYP", "kwojakow", "ElGamal Digital Signature", "lorem ipsum", "dorime interimo adapare dorime ameno ameno latire latiremo dorime"]
# Hash function
hfun = sha256()
# Bit Length
N = 32
# Testing the signatures for the documents
for msg in msgs:
print("Message:")
print(msg)
elgsys = elgamal.generate_system(N, hfun)
print("Generated system:")
print(elgsys)
keys = elgamal.generate_keys(elgsys)
print("Generated key pair (x, y):")
print(keys)
sig = elgamal.sign(elgsys, msg, keys[0])
print("Generated signature pair (r, s):")
print(sig)
is_valid = elgamal.verify(elgsys, msg, sig, keys[1])
print("Is signature valid?")
print(is_valid)
random.shuffle(C)
return C
def IsAliceRicher(C, sk):
ansTemp = 0
for c in C:
if elgamal.decrypt(sk, c) == 1:
ansTemp = 1 # x >y
return ansTemp
## works for numbers greter than 0 and less than < 1024
if __name__ == '__main__':
sk, pk = elgamal.generate_keys(256)
n = 11
# Alice has x
# x -->[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0]
x = [random.randint(0, 1) for i in range(n)]
y = [random.randint(0, 1) for i in range(n)]
GT = -1
for i in range(n):
if x[i] > y[i]:
GT = 1
break
elif x[i] < y[i]:
GT = 0
import socket
import sys
import elgamal
import os
import pickle
dicc = elgamal.generate_keys()
publicKey = dicc['publicKey']
privateKey = dicc['privateKey']
pickled_data = pickle.dumps(publicKey)
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Bind the socket to the port
server_address = ('localhost', 10000)
print('starting up on {} port {}'.format(*server_address))
sock.bind(server_address)
# Listen for incoming connections
sock.listen(1)
while True:
# Wait for a connection
print('waiting for a connection')
print('Esprando solicitud...')
connection, client_address = sock.accept()
try:
print('connection from', client_address)
# Receive the data in small chunks and retransmit it
hex_lenth = len(str(hashlib.sha512(repr(data).encode('ascii')).hexdigest()))
return data + str(hashlib.sha512(repr(data).encode('ascii')).hexdigest())
def verify_signature(data, signature):
return signature == create_signature(data)
print("Create your dyplom")
my_diplom = input()
data_lenth = len(my_diplom)
signature = create_signature(my_diplom)
print("Dyplom with hsa512 injection:")
print(signature)
########################################
keys = elgamal.generate_keys(128)
pub = keys['privateKey']
priv = keys['publicKey']
true_mesg = elgamal.encrypt(priv, signature)
print("Encrypted dyplom:")
print(true_mesg)
print("\0")
########################################
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:")
def generate_keys():
n = 0
c = 0
n = int(input(" give N: "))
c = int(input(" give C: "))
return elgamal.generate_keys(n, c)
# sender generates message signature
s = rsa.sign(keys['n'], keys['d'], message)
print("Signature:", s)
# receiver verifies the signiature and message
verified = rsa.verify_signature(keys['n'], keys['e'], s, message)
print("Message matches signature:", verified)
# ElGamal #############################################################
print("ElGamal digital signature demo.\n")
message = 4567
# sender generate keys
keys = elgamal.generate_keys(7331, 3411, 41)
print("Keys:", keys, "\n")
# sender chooses random int k, where 0 > k > p-1, and gcd(k, p-1) = 1
k = 919
print("Randomly chosen int k:", k)
# sender generates message signature
s = elgamal.sign(keys['g'], k, keys['p'], keys['x'], message)
print("Generated signature:", s)
# receiver verifies the signiature and message
verify = elgamal.verify_signature(keys['g'], keys['y'], keys['p'], s['r'],
s['s'], message)
print("\nVerification params v, w:", verify['v'], verify['w'],
"\nMessage matches signature:", verify['result'])
def test_encode_decode():
private_key, public_key = generate_keys()
cryptogram = encode(public_key, ord('m'))
message = decode(cryptogram, private_key)
assert message == ord('m')
# server.py
import socket
import elgamal
import pickle
#elgamal
keys=elgamal.generate_keys()
key_for_server=keys.copy()
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)
def generateWalletKeys():
return elgamal.generate_keys()
