def _recover(data: bytes, signature: bytes) -> Address:
""" Use eth_sign compatible hasher to recover address from signed data """
return signing.recover_address(
data,
signature=signature,
hasher=eth_sign_sha3,
)
def decode(cls, data):
packed = messages.wrap(data)
if packed is None:
return None
# signature must be at the end
message_type = type(packed)
signature = message_type.fields_spec[-1]
assert signature.name == 'signature', 'signature is not the last field'
message_data = data[:-signature.size_bytes]
message_signature = data[-signature.size_bytes:]
message_hash = sha3(message_data)
data_that_was_signed = pack_signing_data(
message_type.get_bytes_from(data, 'nonce'),
message_type.get_bytes_from(data, 'transferred_amount'),
# Locked amount should get signed when smart contracts change to include it
# message_type.get_bytes_from(data, 'locked_amount'),
message_type.get_bytes_from(data, 'channel'),
message_type.get_bytes_from(data, 'locksroot'),
message_hash,
)
address = signing.recover_address(data_that_was_signed, message_signature)
if address is None:
return None
message = cls.unpack(packed) # pylint: disable=no-member
message.sender = address
return message
def _recover(data: bytes, signature: bytes) -> Address:
""" Use eth_sign compatible hasher to recover address from signed data """
return signing.recover_address(
data,
signature=signature,
hasher=eth_sign_sha3,
)
def _validate_userid_signature(user: User) -> bool:
# display_name should be an address present in the user_id
recovered = signing.recover_address(user.user_id.encode(),
signature=data_decoder(
user.get_display_name()),
hasher=eth_sign_sha3)
return address_encoder(recovered).lower() in user.user_id
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 sender(self) -> Optional[Address]:
if not self.signature:
return None
data_that_was_signed = self._data_to_sign()
message_signature = self.signature
address = signing.recover_address(data_that_was_signed, message_signature)
if address is None:
return None
return address
def sender(self) -> Optional[Address]:
if not self.signature:
return None
data_that_was_signed = self._data_to_sign()
message_signature = self.signature
address = signing.recover_address(data_that_was_signed, message_signature)
if address is None:
return None
return address
def sender(self) -> Optional[Address]:
# TODO: Add chain id as properties of all messages and remove this hack
chain_id = NETWORKNAME_TO_ID['tests']
if not self.signature:
return None
data_that_was_signed = self._data_to_sign(chain_id)
message_signature = self.signature
address = signing.recover_address(data_that_was_signed,
message_signature)
if address is None:
return None
return address
def decode(cls, data):
packed = messages.wrap(data)
if packed is None:
return None
# signature must be at the end
message_type = type(packed)
signature = message_type.fields_spec[-1]
assert signature.name == 'signature', 'signature is not the last field'
data_that_was_signed = data[:-signature.size_bytes]
message_signature = data[-signature.size_bytes:]
address = signing.recover_address(data_that_was_signed, message_signature)
if address is None:
return None
message = cls.unpack(packed) # pylint: disable=no-member
message.sender = address
return message
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,
)
