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 testOffsetDifference(self):
self.offset1 = 0
self.offset2 = 0
message = 'szia'
# Simulating that he transferred 3 character, but the other did not get it
encr_mess, self.deck2, self.offset2 = crypto.encrypt_message_solitaire('asd', self.deck2, self.offset2)
print(encr_mess)
# Encrypting the message by the second participant
encr_mess, self.deck2, self.offset2 = crypto.encrypt_message_solitaire(message, self.deck2, self.offset2)
print(encr_mess)
# Decrypting by the first(the offset will not be okey,
# myofset(self.offset1) will be less than needed)
plain_text, self.deck1, self.offset1 = crypto.decrypt_message_solitaire(encr_mess,
self.deck1, self.base_deck, self.offset2 - len(encr_mess), self.offset1)
print(plain_text)
# Check if the other one decrypted it properly
self.assertEqual(plain_text, message)
def testMessaging(self):
message = 'szia'
# Encrypting the message
encr_mess, self.deck1, self.offset1 = crypto.encrypt_message_solitaire(message, self.deck1, self.offset1)
print(encr_mess)
# Decrypting
plain_text, self.deck2, self.offset2 = crypto.decrypt_message_solitaire(encr_mess,
self.deck2, self.base_deck, self.offset2, self.offset1 - len(encr_mess))
print(plain_text)
# Check if the other one decrypted it properly
self.assertEqual(plain_text, message)
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)