def main():
aliceStore = InMemoryAxolotlStore()
aliceSessionBuilder = SessionBuilder(aliceStore, aliceStore, aliceStore,
aliceStore, BOB_RECIPIENT_ID, 1)
raw_ke = input("Enter key exchange: ")
response = handle_keyexchange(aliceStore, BOB_RECIPIENT_ID,
raw_ke.rstrip())
print
print
print("RESPONSE >>>", response)
raw_message = input("Enter raw message: ")
print
print
handle_data_msg(aliceStore, BOB_RECIPIENT_ID, raw_message.rstrip())
def test_basicKeyExchange(self):
aliceStore = InMemoryAxolotlStore()
aliceSessionBuilder = SessionBuilder(aliceStore, aliceStore, aliceStore, aliceStore, self.__class__.BOB_RECIPIENT_ID, 1)
bobStore = InMemoryAxolotlStore()
bobSessionBuilder = SessionBuilder(bobStore, bobStore, bobStore, bobStore, self.__class__.ALICE_RECIPIENT_ID, 1)
aliceKeyExchangeMessage = aliceSessionBuilder.processInitKeyExchangeMessage()
self.assertTrue(aliceKeyExchangeMessage != None)
aliceKeyExchangeMessageBytes = aliceKeyExchangeMessage.serialize()
bobKeyExchangeMessage = bobSessionBuilder.processKeyExchangeMessage(KeyExchangeMessage(serialized=aliceKeyExchangeMessageBytes))
self.assertTrue(bobKeyExchangeMessage != None)
bobKeyExchangeMessageBytes = bobKeyExchangeMessage.serialize()
response = aliceSessionBuilder.processKeyExchangeMessage(KeyExchangeMessage(serialized=bobKeyExchangeMessageBytes))
self.assertTrue(response == None)
self.assertTrue(aliceStore.containsSession(self.__class__.BOB_RECIPIENT_ID, 1))
self.assertTrue(bobStore.containsSession(self.__class__.ALICE_RECIPIENT_ID, 1))
self.runInteraction(aliceStore, bobStore)
aliceStore = InMemoryAxolotlStore()
aliceSessionBuilder = SessionBuilder(aliceStore, aliceStore, aliceStore, aliceStore, self.__class__.BOB_RECIPIENT_ID, 1)
aliceKeyExchangeMessage = aliceSessionBuilder.processInitKeyExchangeMessage()
try:
bobKeyExchangeMessage = bobSessionBuilder.processKeyExchangeMessage(aliceKeyExchangeMessage)
raise AssertionError("This identity shouldn't be trusted!")
except UntrustedIdentityException as uie:
bobStore.saveIdentity(self.__class__.ALICE_RECIPIENT_ID, aliceKeyExchangeMessage.getIdentityKey())
bobKeyExchangeMessage = bobSessionBuilder.processKeyExchangeMessage(aliceKeyExchangeMessage)
self.assertTrue(aliceSessionBuilder.processKeyExchangeMessage(bobKeyExchangeMessage) == None)
self.runInteraction(aliceStore, bobStore)
def runInteraction(self, aliceSessionRecord, bobSessionRecord):
aliceStore = InMemoryAxolotlStore()
bobStore = InMemoryAxolotlStore()
aliceStore.storeSession(2, 1, aliceSessionRecord)
bobStore.storeSession(3, 1, bobSessionRecord)
aliceCipher = SessionCipher(aliceStore, aliceStore, aliceStore, aliceStore, 2, 1)
bobCipher = SessionCipher(bobStore, bobStore, bobStore, bobStore, 3, 1)
alicePlaintext = "This is a plaintext message."
message = aliceCipher.encrypt(alicePlaintext)
bobPlaintext = bobCipher.decryptMsg(WhisperMessage(serialized=message.serialize()))
self.assertEqual(alicePlaintext, bobPlaintext)
bobReply = "This is a message from Bob."
reply = bobCipher.encrypt(bobReply)
receivedReply = aliceCipher.decryptMsg(WhisperMessage( serialized=reply.serialize()))
self.assertEqual(bobReply, receivedReply)
aliceCiphertextMessages = []
alicePlaintextMessages = []
for i in range(0, 50):
alicePlaintextMessages.append("смерть за смерть %s" % i)
aliceCiphertextMessages.append(aliceCipher.encrypt("смерть за смерть %s" % i))
#shuffle(aliceCiphertextMessages)
#shuffle(alicePlaintextMessages)
for i in range(0, int(len(aliceCiphertextMessages)/2)):
receivedPlaintext = bobCipher.decryptMsg(WhisperMessage(serialized=aliceCiphertextMessages[i].serialize()))
self.assertEqual(receivedPlaintext, alicePlaintextMessages[i])
"""
def test_basicPreKeyV3(self):
aliceStore = InMemoryAxolotlStore()
aliceSessionBuilder = SessionBuilder(aliceStore, aliceStore, aliceStore, aliceStore, self.__class__.BOB_RECIPIENT_ID, 1)
bobStore = InMemoryAxolotlStore()
bobPreKeyPair = Curve.generateKeyPair()
bobSignedPreKeyPair = Curve.generateKeyPair()
bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
bobSignedPreKeyPair.getPublicKey().serialize())
bobPreKey = PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
31337, bobPreKeyPair.getPublicKey(),
22, bobSignedPreKeyPair.getPublicKey(),
bobSignedPreKeySignature,
bobStore.getIdentityKeyPair().getPublicKey())
aliceSessionBuilder.processPreKeyBundle(bobPreKey)
self.assertTrue(aliceStore.containsSession(self.__class__.BOB_RECIPIENT_ID, 1))
self.assertTrue(aliceStore.loadSession(self.__class__.BOB_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3)
originalMessage = "L'homme est condamné à être libre"
aliceSessionCipher = SessionCipher(aliceStore, aliceStore, aliceStore, aliceStore, self.__class__.BOB_RECIPIENT_ID, 1)
outgoingMessage = aliceSessionCipher.encrypt(originalMessage)
self.assertTrue(outgoingMessage.getType() == CiphertextMessage.PREKEY_TYPE)
incomingMessage = PreKeyWhisperMessage(serialized=outgoingMessage.serialize())
bobStore.storePreKey(31337, PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair))
bobStore.storeSignedPreKey(22, SignedPreKeyRecord(22, int(time.time() * 1000), bobSignedPreKeyPair, bobSignedPreKeySignature))
bobSessionCipher = SessionCipher(bobStore, bobStore, bobStore, bobStore, self.__class__.ALICE_RECIPIENT_ID, 1)
plaintext = bobSessionCipher.decryptPkmsg(incomingMessage)
self.assertEqual(originalMessage, plaintext)
# @@TODO: in callback assertion
# self.assertFalse(bobStore.containsSession(self.__class__.ALICE_RECIPIENT_ID, 1))
self.assertTrue(bobStore.containsSession(self.__class__.ALICE_RECIPIENT_ID, 1))
self.assertTrue(bobStore.loadSession(self.__class__.ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3)
self.assertTrue(bobStore.loadSession(self.__class__.ALICE_RECIPIENT_ID, 1).getSessionState().getAliceBaseKey() != None)
self.assertEqual(originalMessage, plaintext)
bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage)
self.assertTrue(bobOutgoingMessage.getType() == CiphertextMessage.WHISPER_TYPE)
alicePlaintext = aliceSessionCipher.decryptMsg(WhisperMessage(serialized=bobOutgoingMessage.serialize()))
self.assertEqual(alicePlaintext, originalMessage)
self.runInteraction(aliceStore, bobStore)
aliceStore = InMemoryAxolotlStore()
aliceSessionBuilder = SessionBuilder(aliceStore, aliceStore, aliceStore, aliceStore, self.__class__.BOB_RECIPIENT_ID, 1)
aliceSessionCipher = SessionCipher(aliceStore, aliceStore, aliceStore, aliceStore, self.__class__.BOB_RECIPIENT_ID, 1)
bobPreKeyPair = Curve.generateKeyPair()
bobSignedPreKeyPair = Curve.generateKeyPair()
bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(), bobSignedPreKeyPair.getPublicKey().serialize())
bobPreKey = PreKeyBundle(bobStore.getLocalRegistrationId(),
1, 31338, bobPreKeyPair.getPublicKey(),
23, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
bobStore.getIdentityKeyPair().getPublicKey())
bobStore.storePreKey(31338, PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair))
bobStore.storeSignedPreKey(23, SignedPreKeyRecord(23, int(time.time() * 1000), bobSignedPreKeyPair, bobSignedPreKeySignature))
aliceSessionBuilder.processPreKeyBundle(bobPreKey)
outgoingMessage = aliceSessionCipher.encrypt(originalMessage)
try:
plaintext = bobSessionCipher.decryptPkmsg(PreKeyWhisperMessage(serialized=outgoingMessage))
raise AssertionError("shouldn't be trusted!")
except Exception:
bobStore.saveIdentity(self.__class__.ALICE_RECIPIENT_ID, PreKeyWhisperMessage(serialized=outgoingMessage.serialize()).getIdentityKey())
plaintext = bobSessionCipher.decryptPkmsg(PreKeyWhisperMessage(serialized=outgoingMessage.serialize()))
self.assertEqual(plaintext, originalMessage)
bobPreKey = PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
31337, Curve.generateKeyPair().getPublicKey(),
23, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
aliceStore.getIdentityKeyPair().getPublicKey())
try:
aliceSessionBuilder.process(bobPreKey)
raise AssertionError("shouldn't be trusted!")
except Exception:
#good
pass
