def init_key_exchange(self, recipient):
"""Send initial key exchange message to recipient"""
logger.info(
'Sending initial key exchange message to {}...'.format(recipient))
sessionBuilder = self.getSessionBuilder(recipient)
keyExchangeMessage = sessionBuilder.processInitKeyExchangeMessage()
return Message(recipient, keyExchangeMessage.serialize(),
MessageType.KEY)
def send(self, recipient, plaintext):
"""Send encrypted message to recipient"""
if self.store.containsSession(recipient, self.DEFAULT_DEVICE_ID):
if not self.store.sessionStore.hasPendingKeyExchange(
recipient, self.DEFAULT_DEVICE_ID):
logger.info(
'Sending encrypted message to {}...'.format(recipient))
sessionCipher = self.getSessionCipher(recipient)
whisperMessage = sessionCipher.encrypt(plaintext)
return Message(recipient, whisperMessage.serialize(),
MessageType.SECURE)
else:
raise PendingKeyExchangeException(
'Session is in pending key exchange state, '
'wait for KeyExchangeMessage reply!')
else:
raise NoSessionException('Session doesn\'t exists, '
'send initial KeyExchangeMessage first!')
def handle_KeyExchangeMessage(self, message):
"""Handle received key exchange message"""
#if self.store.containsSession(message.identity, self.DEFAULT_DEVICE_ID):
# raise RuntimeError('KeyExchangeMessage received, but session already exists!')
sessionBuilder = self.getSessionBuilder(message.identity)
keyExchangeMessage = sessionBuilder.processKeyExchangeMessage(
KeyExchangeMessage(serialized=message.message))
if keyExchangeMessage:
logger.info('Received initial KeyExchangeMessage from {}, '
'sending response...'.format(message.identity))
return Message(message.identity, keyExchangeMessage.serialize(),
MessageType.KEY)
else:
logger.info(
'Received response from {} to initial KeyExchangeMessage, '
'key exchange completed.'.format(message.identity))
def end_session(self, recipient):
"""Send end session message to recipient and delete session"""
if self.store.containsSession(recipient, self.DEFAULT_DEVICE_ID):
endSessionMessage = None
if not self.store.sessionStore.hasPendingKeyExchange(
recipient, self.DEFAULT_DEVICE_ID):
logger.info(
'Sending end session message to {}...'.format(recipient))
sessionCipher = self.getSessionCipher(recipient)
endSessionMessage = sessionCipher.encrypt('TERMINATE')
logger.info(
'Deleting session for recipient {}...'.format(recipient))
self.store.deleteSession(recipient, self.DEFAULT_DEVICE_ID)
if endSessionMessage:
return Message(recipient, endSessionMessage.serialize(),
MessageType.END_SESSION)
else:
raise NoSessionException('Session doesn\'t exists!')
