def _handle_message(self, room, event):
""" Handle text messages sent to listening rooms """
if event['type'] != 'm.room.message' or event['content'][
'msgtype'] != 'm.text':
# Ignore non-messages and non-text messages
return
sender_id = event['sender']
if sender_id == self._client.user_id:
# Ignore our own messages
return
user = self._client.get_user(sender_id)
peer_address = self._userids_to_address.get(sender_id)
if not peer_address:
try:
# recover displayname signature
peer_address = signing.recover_address(
sender_id.encode(),
signature=data_decoder(user.get_display_name()),
hasher=eth_sign_sha3)
except AssertionError:
log.warning('INVALID MESSAGE', sender_id=sender_id)
return
node_address_hex = address_encoder(peer_address)
if node_address_hex.lower() not in sender_id:
log.warning('INVALID SIGNATURE',
peer_address=node_address_hex,
sender_id=sender_id)
return
self._userids_to_address[sender_id] = peer_address
data = event['content']['body']
if data.startswith('0x'):
message = message_from_bytes(data_decoder(data))
else:
message_dict = json.loads(data)
log.trace('MESSAGE_DATA', data=message_dict)
message = message_from_dict(message_dict)
if isinstance(message, SignedMessage) and not message.sender:
# FIXME: This can't be right
message.sender = peer_address
if isinstance(message, Delivered):
self._receive_delivered(message)
elif isinstance(message, Ping):
log.warning(
'Not required Ping received',
message=data,
)
elif isinstance(message, SignedMessage):
self._receive_message(message)
elif log.isEnabledFor(logging.ERROR):
log.error(
'Invalid message',
message=data,
)
def _handle_message(self, room, event):
""" Handle text messages sent to listening rooms """
if (
event['type'] != 'm.room.message' or
event['content']['msgtype'] != 'm.text' or
not self._running
):
# Ignore non-messages and non-text messages
return
sender_id = event['sender']
if sender_id == self._client.user_id:
# Ignore our own messages
return
user = self._client.get_user(sender_id)
peer_address = self._validate_userid_signature(user)
if not peer_address:
self.log.debug(
'INVALID SIGNATURE',
user=user,
name=user.get_display_name(),
)
return
data = event['content']['body']
if data.startswith('0x'):
message = message_from_bytes(decode_hex(data))
if not message:
return
else:
try:
message_dict = json.loads(data)
self.log.debug('MESSAGE_DATA', data=message_dict)
message = message_from_dict(message_dict)
except (UnicodeDecodeError, JSONDecodeError) as ex:
self.log.warning(
"Can't parse message data JSON",
message_data=data,
peer_address=pex(peer_address),
exception=ex,
)
return
if isinstance(message, Delivered):
self._receive_delivered(message)
elif isinstance(message, Ping):
self.log.warning(
'Not required Ping received',
message=data,
)
elif isinstance(message, SignedMessage):
self._receive_message(message)
else:
self.log.error(
'Invalid message',
message=data,
)
def test_our_signed_msg():
# Signed data
dict_msg = {
"type":
"LockedTransfer",
"chain_id":
33,
"message_identifier":
12248562144413481135,
"payment_identifier":
11640634370223461850,
"payment_hash_invoice":
"0x",
"nonce":
1,
"token_network_address":
"0x877ec5961d18d3413fabbd67696b758fe95408d6",
"token":
"0xff10e500973a0b0071e2263421e4af60425834a6",
"channel_identifier":
1,
"transferred_amount":
0,
"locked_amount":
100000000000000,
"recipient":
"0x29021129f5d038897f01bd4bc050525ca01a4758",
"locksroot":
"0x3985b475b7e3af72cdbcd2e41b22951c168b0e2ff41bcc9548ee98d14ec86784",
"lock": {
"type":
"Lock",
"amount":
100000000000000,
"expiration":
195730,
"secrethash":
"0x3e6d58ba381898cf1a0ff6fbe65a3805419063ea9eb6ff6bc6f0dde45032d0dc"
},
"target":
"0x29021129f5d038897f01bd4bc050525ca01a4758",
"initiator":
"0x09fcbe7ceb49c944703b4820e29b0541edfe7e82",
"fee":
0,
"signature":
"0x68b12d6de97e2be66a5d013a7118264ab696a45ebe7f9ef590c88286ba7804154e0a1418d78712d4aa227c33af23ebae2ff8114a7e3f3d9efb7e342235eba5941b"
}
# Construct message from dict (this includes and creates a sender field according to signature)
message = message_from_dict(dict_msg)
assert message.signature == decode_hex(
"0x68b12d6de97e2be66a5d013a7118264ab696a45ebe7f9ef590c88286ba7804154e0a1418d78712d4aa227c33af23ebae2ff8114a7e3f3d9efb7e342235eba5941b"
)
# TODO this assert condition.
assert recover(message._data_to_sign(),
message.signature) != to_canonical_address(
"0x09fcbe7ceb49c944703b4820e29b0541edfe7e82")
def test_working_raiden():
# Signed data
dict_msg = {
"type":
"LockedTransfer",
"chain_id":
33,
"message_identifier":
1492744266262786169,
"payment_identifier":
5037359832394936637,
"payment_hash_invoice":
"0x",
"nonce":
9,
"token_network_address":
"0x877ec5961d18d3413fabbd67696b758fe95408d6",
"token":
"0xff10e500973a0b0071e2263421e4af60425834a6",
"channel_identifier":
3,
"transferred_amount":
100000000000000000,
"locked_amount":
200000000000000000,
"recipient":
"0x5fd79c7dd13a67361f22dafdd3127c4ae639ec3b",
"locksroot":
"0x277d40c5b54433ce56255ca389d11207cc8ce64cac9fc2725cd30d0d1ce624a9",
"lock": {
"type":
"Lock",
"amount":
200000000000000000,
"expiration":
252207,
"secrethash":
"0xde3a845acb01d53d24d0848ccc420e4f700e0bc67f007b7aa098880ab9fa131a"
},
"target":
"0x5fd79c7dd13a67361f22dafdd3127c4ae639ec3b",
"initiator":
"0xa358b95b3ee75e426d89f91d65a27e8d83bbf995",
"fee":
0,
"signature":
"0x6f6ca17a6660dc4203409e3671dd7dc653d6ac01bc53cf5ba0259adb7766333b1a0850d4adff075735a2f7e4c6a20cb3271fbc86af5ad9ad87fe8752002bf9401b"
}
# Construct message from dict (this includes and creates a sender field according to signature)
message = message_from_dict(dict_msg)
assert message.signature == decode_hex(
"0x6f6ca17a6660dc4203409e3671dd7dc653d6ac01bc53cf5ba0259adb7766333b1a0850d4adff075735a2f7e4c6a20cb3271fbc86af5ad9ad87fe8752002bf9401b"
)
assert recover(message._data_to_sign(),
message.signature) == to_canonical_address(
"0xa358b95B3ee75e426d89F91d65a27E8d83bBF995")
def _handle_message(self, room, event):
""" Handle text messages sent to listening rooms """
if (event['type'] != 'm.room.message'
or event['content']['msgtype'] != 'm.text'
or not self._running):
# Ignore non-messages and non-text messages
return
sender_id = event['sender']
if sender_id == self._client.user_id:
# Ignore our own messages
return
user = self._get_user(sender_id)
peer_address = self._validate_userid_signature(user)
if not peer_address:
# invalid user displayName signature
return
old_room = self._get_room_id_for_address(peer_address)
if old_room != room.room_id:
self.log.debug(
'received message triggered new room for peer',
peer_user=user.user_id,
peer_address=to_checksum_address(peer_address),
old_room=old_room,
room=room,
)
self._set_room_id_for_address(peer_address, room.room_id)
if peer_address not in self._address_to_userids:
# user not start_health_check'ed
return
data = event['content']['body']
if data.startswith('0x'):
try:
message = message_from_bytes(decode_hex(data))
assert message
except (DecodeError, AssertionError) as ex:
self.log.warning(
"Can't parse message binary data",
message_data=data,
peer_address=pex(peer_address),
exception=ex,
)
return
else:
try:
message_dict = json.loads(data)
self.log.debug('MESSAGE_DATA', data=message_dict)
message = message_from_dict(message_dict)
except (UnicodeDecodeError, JSONDecodeError) as ex:
self.log.warning(
"Can't parse message data JSON",
message_data=data,
peer_address=pex(peer_address),
exception=ex,
)
return
if isinstance(message, Delivered):
self._receive_delivered(message)
elif isinstance(message, Ping):
self.log.warning(
'Not required Ping received',
message=data,
)
elif isinstance(message, SignedMessage):
if message.sender != peer_address:
self.log.warning(
'Message not signed by sender!',
message=message,
signer=message.sender,
peer_address=peer_address,
)
return
self._receive_message(message)
else:
self.log.error(
'Invalid message',
message=data,
)
def _handle_message(self, room, event):
""" Handle text messages sent to listening rooms """
if (
event['type'] != 'm.room.message' or
event['content']['msgtype'] != 'm.text' or
not self._running
):
# Ignore non-messages and non-text messages
return
sender_id = event['sender']
if sender_id == self._client.user_id:
# Ignore our own messages
return
user = self._client.get_user(sender_id)
peer_address = self._userids_to_address.get(sender_id)
if not peer_address:
try:
# recover displayname signature
peer_address = signing.recover_address(
sender_id.encode(),
signature=data_decoder(user.get_display_name()),
hasher=eth_sign_sha3,
)
except AssertionError:
self.log.warning('INVALID MESSAGE', sender_id=sender_id)
return
node_address_hex = to_normalized_address(peer_address)
if node_address_hex.lower() not in sender_id:
self.log.warning(
'INVALID SIGNATURE',
peer_address=node_address_hex,
sender_id=sender_id,
)
return
self._userids_to_address[sender_id] = peer_address
data = event['content']['body']
if data.startswith('0x'):
message = message_from_bytes(data_decoder(data))
else:
try:
message_dict = json.loads(data)
except (UnicodeDecodeError, JSONDecodeError) as ex:
self.log.warning(
"Can't parse message data JSON",
message_data=data,
peer_address=pex(peer_address),
exception=ex,
)
return
self.log.debug('MESSAGE_DATA', data=message_dict)
message_dict = json.loads(data)
self.log.debug('MESSAGE_DATA', data=message_dict)
message = message_from_dict(message_dict)
if isinstance(message, SignedMessage) and not message.sender:
# FIXME: This can't be right
message.sender = peer_address
if isinstance(message, Delivered):
self._receive_delivered(message)
elif isinstance(message, Ping):
self.log.warning(
'Not required Ping received',
message=data,
)
elif isinstance(message, SignedMessage):
self._receive_message(message)
else:
self.log.error(
'Invalid message',
message=data,
)
def validate_and_parse_message(data, peer_address) -> List[Message]:
messages = list()
if not isinstance(data, str):
log.warning(
"Received ToDevice Message body not a string",
message_data=data,
peer_address=pex(peer_address),
)
return []
if data.startswith("0x"):
try:
message = message_from_bytes(decode_hex(data))
if not message:
raise InvalidProtocolMessage
except (DecodeError, AssertionError) as ex:
log.warning(
"Can't parse ToDevice Message binary data",
message_data=data,
peer_address=pex(peer_address),
_exc=ex,
)
return []
except InvalidProtocolMessage as ex:
log.warning(
"Received ToDevice Message binary data is not a valid message",
message_data=data,
peer_address=pex(peer_address),
_exc=ex,
)
return []
else:
messages.append(message)
else:
for line in data.splitlines():
line = line.strip()
if not line:
continue
try:
message_dict = json.loads(line)
message = message_from_dict(message_dict)
except (UnicodeDecodeError, json.JSONDecodeError) as ex:
log.warning(
"Can't parse ToDevice Message data JSON",
message_data=line,
peer_address=pex(peer_address),
_exc=ex,
)
continue
except InvalidProtocolMessage as ex:
log.warning(
"ToDevice Message data JSON are not a valid ToDevice Message",
message_data=line,
peer_address=pex(peer_address),
_exc=ex,
)
continue
if not isinstance(message, SignedMessage):
log.warning(
"ToDevice Message not a SignedMessage!",
message=message,
peer_address=pex(peer_address),
)
continue
if message.sender != peer_address:
log.warning(
"ToDevice Message not signed by sender!",
message=message,
signer=message.sender,
peer_address=pex(peer_address),
)
continue
messages.append(message)
return messages
def _handle_message(self, room, event):
""" Handle text messages sent to listening rooms """
if (
event['type'] != 'm.room.message' or
event['content']['msgtype'] != 'm.text' or
not self._running
):
# Ignore non-messages and non-text messages
return
sender_id = event['sender']
if sender_id == self._client.user_id:
# Ignore our own messages
return
user = self._get_user(sender_id)
peer_address = self._validate_userid_signature(user)
if not peer_address:
# invalid user displayName signature
return
old_room = self._get_room_id_for_address(peer_address)
if old_room != room.room_id:
self.log.debug(
'received message triggered new room for peer',
peer_user=user.user_id,
peer_address=to_checksum_address(peer_address),
old_room=old_room,
room=room,
)
self._set_room_id_for_address(peer_address, room.room_id)
if peer_address not in self._address_to_userids:
# user not start_health_check'ed
return
data = event['content']['body']
if data.startswith('0x'):
try:
message = message_from_bytes(decode_hex(data))
assert message
except (DecodeError, AssertionError) as ex:
self.log.warning(
"Can't parse message binary data",
message_data=data,
peer_address=pex(peer_address),
exception=ex,
)
return
else:
try:
message_dict = json.loads(data)
self.log.debug('MESSAGE_DATA', data=message_dict)
message = message_from_dict(message_dict)
except (UnicodeDecodeError, JSONDecodeError) as ex:
self.log.warning(
"Can't parse message data JSON",
message_data=data,
peer_address=pex(peer_address),
exception=ex,
)
return
if isinstance(message, Delivered):
self._receive_delivered(message)
elif isinstance(message, Ping):
self.log.warning(
'Not required Ping received',
message=data,
)
elif isinstance(message, SignedMessage):
if message.sender != peer_address:
self.log.warning(
'Message not signed by sender!',
message=message,
signer=message.sender,
peer_address=peer_address,
)
return
self._receive_message(message)
else:
self.log.error(
'Invalid message',
message=data,
)
def _handle_message(self, room, event) -> bool:
""" Handle text messages sent to listening rooms """
if (event['type'] != 'm.room.message'
or event['content']['msgtype'] != 'm.text'
or self._stop_event.ready()):
# Ignore non-messages and non-text messages
return False
sender_id = event['sender']
if sender_id == self._user_id:
# Ignore our own messages
return False
user = self._get_user(sender_id)
peer_address = self._validate_userid_signature(user)
if not peer_address:
self.log.debug(
'message from invalid user displayName signature',
peer_user=user.user_id,
room=room,
)
return False
# don't proceed if user isn't healthchecked (yet)
if peer_address not in self._address_to_userids:
# user not start_health_check'ed
self.log.debug(
'message from non-healthchecked peer - ignoring',
sender=user,
sender_address=pex(peer_address),
room=room,
)
return False
# rooms we created and invited user, or were invited specifically by them
room_ids = self._get_room_ids_for_address(peer_address)
if room.room_id not in room_ids:
# this should not happen, but is not fatal, as we may not know user yet
if bool(room.invite_only) < self._private_rooms:
reason = 'required private room, but received message in a public'
else:
reason = 'unknown room for user'
self.log.debug(
'received peer message in an invalid room - ignoring',
peer_user=user.user_id,
peer_address=pex(peer_address),
room=room,
reason=reason,
)
return False
if not room_ids or room.room_id != room_ids[0]:
self.log.debug(
'received message triggered new comms room for peer',
peer_user=user.user_id,
peer_address=pex(peer_address),
known_user_rooms=room_ids,
room=room,
)
self._set_room_id_for_address(peer_address, room.room_id)
data = event['content']['body']
if not isinstance(data, str):
self.log.warning(
'Received message body not a string',
peer_user=user.user_id,
peer_address=to_checksum_address(peer_address),
room=room,
)
return False
if data.startswith('0x'):
try:
message = message_from_bytes(decode_hex(data))
if not message:
raise InvalidProtocolMessage
except (DecodeError, AssertionError) as ex:
self.log.warning(
"Can't parse message binary data",
message_data=data,
peer_address=pex(peer_address),
_exc=ex,
)
return False
except InvalidProtocolMessage as ex:
self.log.warning(
"Received message binary data is not a valid message",
message_data=data,
peer_address=pex(peer_address),
_exc=ex,
)
return False
else:
try:
message_dict = json.loads(data)
message = message_from_dict(message_dict)
except (UnicodeDecodeError, json.JSONDecodeError) as ex:
self.log.warning(
"Can't parse message data JSON",
message_data=data,
peer_address=pex(peer_address),
_exc=ex,
)
return False
except InvalidProtocolMessage as ex:
self.log.warning(
"Message data JSON are not a valid message",
message_data=data,
peer_address=pex(peer_address),
_exc=ex,
)
return False
self.log.debug(
'MESSAGE_DATA',
data=data,
sender=pex(peer_address),
sender_user=user,
room=room,
)
if isinstance(message, Ping):
self.log.warning(
'Not required Ping received',
message=data,
)
return False
elif isinstance(message, SignedMessage):
if message.sender != peer_address:
self.log.warning(
'Message not signed by sender!',
message=message,
signer=message.sender,
peer_address=peer_address,
)
return False
if isinstance(message, Delivered):
self._receive_delivered(message)
else:
self._receive_message(message)
else:
self.log.warning(
'Received Invalid message',
message=data,
)
return False
return True
