def run_merkle_hellman():
action = get_action()
print("* Seed *")
seed = input("Set Seed [enter for random]: ")
import random
if not seed:
random.seed()
else:
random.seed(seed)
print("* Building private key...")
private_key = generate_private_key()
public_key = create_public_key(private_key)
if action == 'E': # Encrypt
data = get_input(binary=True)
print("* Transform *")
chunks = encrypt_mh(data, public_key)
output = ' '.join(map(str, chunks))
else: # Decrypt
data = get_input(binary=False)
chunks = [int(line.strip()) for line in data.split() if line.strip()]
print("* Transform *")
output = decrypt_mh(chunks, private_key)
set_output(output)
def testMessaging(self):
self.message = 'hello'
encrypted_message = crypto.encrypt_mh(self.message, self.PUBLIC_KEY)
decrypted_message = crypto.decrypt_mh(encrypted_message,
self.PRIVATE_KEY)
self.assertEqual(self.message, decrypted_message)
def communicate_with_client(clientId):
clientPubKey = getPublicKeyOfUser(clientId)
s = sendHello(clientId, clientPubKey)
halfSecret = crypto.generate_random_secret()
sendHalfSecret(s, halfSecret, clientPubKey)
print('Sending halfSecret', halfSecret)
# Getting the other half of the secret
mess = recieve(s)
mess = deserializeStringList(mess)
secretPartTwo = crypto.decrypt_mh(mess, PRIVATE_KEY)
print('Got the other half secret', secretPartTwo)
# generate_common_secret, init deck
common_secret = crypto.generate_common_secret(halfSecret, secretPartTwo)
print('Generated the common secret', common_secret)
deck = crypto.init_deck(common_secret)
print('Inited deck with common secret, inited deck:', deck)
base_deck = deck.copy()
# communicating with the other one
myoffset = 0
messageFromOther = ''
while (messageFromOther != 'bye'):
# Message to the other
message = input('Message to ' + str(clientId) + ": ")
encr_message, deck, myoffset = crypto.encrypt_message_solitaire(
message, deck, myoffset)
mess = str.encode(str(myoffset - len(message)) + ':' + encr_message)
s.send(mess)
# Response message
print('Encrypted message from ' + str(clientId))
messageFromOther = recieve(s).split(':')
offset = int(messageFromOther[0])
encMess = messageFromOther[1]
concreteMessage, deck, myoffset = crypto.decrypt_message_solitaire(
encMess, deck, base_deck, offset, myoffset)
print('Message From ' + str(clientId) + ": " + concreteMessage)
messageFromOther = concreteMessage
if messageFromOther == 'bye' and message != 'bye':
message = 'bye'
encr_message, deck, myoffset = crypto.encrypt_message_solitaire(
message, deck, myoffset)
mess = str.encode(
str(myoffset - len(message)) + ':' + encr_message)
s.send(mess)
def sendHello(clientId, clientPubKey):
print(" Sending hello to user", clientId, ", with Public key",
clientPubKey)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TCP_IP, clientId))
mess = crypto.encrypt_mh('Hello from ' + str(PRIVATE_TCP_PORT),
clientPubKey)
mess = str.encode(str(mess))
s.send(mess)
mess = recieve(s)
mess = deserializeStringList(mess)
mess = crypto.decrypt_mh(mess, PRIVATE_KEY)
print("mess", mess)
return s
def testKnapsackMessage():
print("1---KNAPSACK TEST FOR MESSAGE ENCRYPTION---")
pk1 = Knapsack.generate_private_key()
pubkey1 = Knapsack.create_public_key(pk1)
pk2 = Knapsack.generate_private_key()
pubkey2 = Knapsack.create_public_key(pk2)
str1 = "Volt egyszer egy Elek ugy hivtak hogy Teszt Elek aki szerette a teszt eseteket"
print("Message that will be encrypted=" + str1)
encripteduzenet = Knapsack.encrypt_mh(str1, pubkey2)
print("Encrypted message=" + str(encripteduzenet))
decriptaltuzenet = Knapsack.decrypt_mh(encripteduzenet, pk2)
print("Decrypted message= " + str(decriptaltuzenet))
print("-----------------------------------------------\n")
def testKnapsackDeck():
print("2---KNAPSACK TEST FOR DECK ENCRYPTION---")
pk1 = Knapsack.generate_private_key()
pubkey1 = Knapsack.create_public_key(pk1)
pk2 = Knapsack.generate_private_key()
pubkey2 = Knapsack.create_public_key(pk2)
str1 = ' '.join(
str(e) for e in [
4, 19, 24, 18, 21, 25, 26, 5, 6, 20, 2, 23, 12, 17, 13, 27, 16, 8,
10, 14, 1, 22, 7, 11, 9, 15, 3
])
print("Message that will be encrypted=" + str([
4, 19, 24, 18, 21, 25, 26, 5, 6, 20, 2, 23, 12, 17, 13, 27, 16, 8, 10,
14, 1, 22, 7, 11, 9, 15, 3
]))
encripteduzenet = Knapsack.encrypt_mh(str1, pubkey2)
print("Encrypted message=" + str(encripteduzenet))
decriptaltuzenet = Knapsack.decrypt_mh(encripteduzenet, pk2)
print("Decrypted message= " + str(decriptaltuzenet))
print("-----------------------------------------------\n")
def run_merkle_hellman(encrypting, data):
"""Run the Merkle-Hellman knapsack cryptosystem."""
action = get_action()
print("* Seed *")
seed = input("Set Seed [enter for random]: ")
if not seed:
random.seed()
else:
random.seed(seed)
print("* Building private key...")
private_key = generate_private_key()
public_key = create_public_key(private_key)
if encrypting: # Encrypt
print("* Transform *")
chunks = encrypt_mh(data, public_key)
return ' '.join(map(str, chunks))
else: # Decrypt
chunks = [int(line.strip()) for line in data.split() if line.strip()]
print("* Transform *")
return decrypt_mh(chunks, private_key)
def listening_for_communication():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TCP_IP, PRIVATE_TCP_PORT))
s.listen(1)
conn, addr = s.accept()
mess = recieve_as_server(conn)
mess = deserializeStringList(mess)
mess = crypto.decrypt_mh(mess, PRIVATE_KEY)
print("mess", mess)
clientId = 0
if mess.split(' ')[0] == "Hello":
clientId = int(mess.split(' ')[2])
clientPubKey = getPublicKeyOfUser(clientId)
mess = crypto.encrypt_mh('Hello from ' + str(PRIVATE_TCP_PORT),
clientPubKey)
mess = str.encode(str(mess))
conn.send(mess)
# Generate random secret, getting secret from the other party
halfSecret = crypto.generate_random_secret()
mess = recieve_as_server(conn)
mess = deserializeStringList(mess)
secretPartOne = crypto.decrypt_mh(mess, PRIVATE_KEY)
print('Got halfSecret', secretPartOne)
# Sending the other part of the secret to the other one
print('Sending halfSecret', halfSecret)
mess = crypto.encrypt_mh(halfSecret, clientPubKey)
mess = str.encode(str(mess))
conn.send(mess)
# generate_common_secret, init deck
common_secret = crypto.generate_common_secret(secretPartOne,
halfSecret)
print('Generated the common secret', common_secret)
deck = crypto.init_deck(common_secret)
print('Inited deck with common secret, inited deck:', deck)
base_deck = deck.copy()
# communicating with the other one
myoffset = 0
messageFromOther = ''
while (messageFromOther != 'bye'):
# Response message
print('Encrypted message from ' + str(clientId))
messageFromOther = recieve_as_server(conn).split(':')
offset = int(messageFromOther[0])
encMess = messageFromOther[1]
concreteMessage, deck, myoffset = crypto.decrypt_message_solitaire(
encMess, deck, base_deck, offset, myoffset)
print('Message From ' + str(clientId) + ": " + concreteMessage)
messageFromOther = concreteMessage
if concreteMessage == 'bye':
message = 'bye'
encr_message, deck, myoffset = crypto.encrypt_message_solitaire(
message, deck, myoffset)
mess = str.encode(
str(myoffset - len(message)) + ':' + encr_message)
conn.send(mess)
break
# Message to the other
message = input('Message to ' + str(clientId) + ": ")
encr_message, deck, myoffset = crypto.encrypt_message_solitaire(
message, deck, myoffset)
mess = str.encode(
str(myoffset - len(message)) + ':' + encr_message)
conn.send(mess)
if message == 'bye':
print('Encrypted message from ' + str(clientId))
messageFromOther = recieve_as_server(conn).split(':')
offset = int(messageFromOther[0])
encMess = messageFromOther[1]
concreteMessage, deck, myoffset = crypto.decrypt_message_solitaire(
encMess, deck, base_deck, offset, myoffset)
if concreteMessage == 'bye':
messageFromOther = concreteMessage
break
except Exception as e:
print(e)
def decrypthelper(self, messageToDecrypt):
print("Encrypted message= "+messageToDecrypt)
convertToList = json.loads(messageToDecrypt)
recievedMsg = Knapsack.decrypt_mh(convertToList, self.clientPrivateKey)
return recievedMsg
