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 receive(self, message=""): """Receive email message (read it from stdin)""" if not message: message = sys.stdin.read() email_message = parse_email(message) sender = email_message["from"][1] body = email_message["body"][0] if sender and body: return Message.from_raw(sender, self.encoder.decode(body.encode("ascii")))
def receive(self, message=''): """Receive email message (read it from stdin)""" if not message: message = sys.stdin.read() email_message = parse_email(message) sender = email_message['from'][1] body = email_message['body'][0] if sender and body: return Message.from_raw(sender, self.encoder.decode(body.encode('ascii')))
def receive(self, message=""): """Receive message (read it from terminal)""" if not message: print("RECEIVE:") sender = input("From: ") body = input("Encrypted message: ") print() else: sender, body = message.strip().split(None, maxsplit=1) if sender and body: return Message.from_raw(sender, self.encoder.decode(body.encode("ascii")))
def receive(self, message=''): """Receive message (read it from terminal)""" if not message: print('RECEIVE:') sender = input('From: ') body = input('Encrypted message: ') print() else: sender, body = message.strip().split(None, maxsplit=1) if sender and body: return Message.from_raw(sender, self.encoder.decode(body.encode('ascii')))
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!')