def test_deserializer_from_activate():
# To test deserialization - we need to start with a different message-type and then convert
# back to a generic message...
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
x = pySRUPLib.SRUP_Activate()
y = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
assert x.sign(keyfile) is True
z = x.serialize()
assert y.deserialize(z) is True
# Remember we can't verify the generic message...
assert y.verify(pubkeyfile) is False
assert y.sender_id == send_id
assert y.sequence_id == seq_id
assert y.token == token
def test_generic_serializer():
# Similarly we can't serialize a generic message...
x = pySRUPLib.SRUP_Generic()
x.token = "TOKEN12345"
x.sequence_id = 0x1234567890ABCDEF
x.sender_id = 0x5F5F5F5F5F5F5F5F
assert x.sign(keyfile) is False
def test_deserializer_from_data():
# To test deserialization - we need to start with a different message-type and then convert
# back to a generic message...
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
data = "This is some data that I might store in the data field"
data_id = "A string"
x = pySRUPLib.SRUP_Data()
y = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.bytes_data = data
x.data_id = data_id
assert x.sign(keyfile) is True
z = x.serialize()
assert y.deserialize(z) is True
# Remember we can't verify the generic message...
assert y.verify(pubkeyfile) is False
assert y.sender_id == send_id
assert y.sequence_id == seq_id
assert y.token == token
def test_deserializer_from_init():
# To test deserialization - we need to start with a different message-type and then convert
# back to a generic message...
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
url = "https://google.com"
digest = "THIS IS A TEST VALUE FOR THE DIGEST"
target = 0x7F7F7F7F7F7F7F7F
x = pySRUPLib.SRUP_Initiate()
y = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.url = url
x.digest = digest
x.target = target
assert x.sign(keyfile) is True
z = x.serialize()
assert y.deserialize(z) is True
# Remember we can't verify the generic message...
assert y.verify(pubkeyfile) is False
assert y.sender_id == send_id
assert y.sequence_id == seq_id
assert y.token == token
def test_ID_request_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
x = pySRUPLib.SRUP_ID_Request()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__id_request_message_type()
def test_syndicated_terminate_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
x = pySRUPLib.SRUP_Syndicated_Terminate()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndicated_terminate_message_type()
def action_test_generic_deserializer():
token = "TOKEN12345"
action_id = 7
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
x = pySRUPLib.SRUP_Action()
i = pySRUPLib.SRUP_Generic()
x.action_id = action_id
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__action_message_type()
def test_generic_signing():
# Note: the protocol standard says we can't sign a generic message
# (i.e. as we'd never send a generic message we'd sign the real message
# and interpret as a generic on receipt
blank = ""
x = pySRUPLib.SRUP_Generic()
assert x.sign(blank) is False
assert x.sign(keyfile) is False
x.token = "TOKEN12345"
assert x.sign(keyfile) is False
x.sequence_id = 0x1234567890ABCDEF
assert x.sign(keyfile) is False
x.sender_id = 0x5F5F5F5F5F5F5F5F
assert x.sign(blank) is False
assert x.sign(keyfile) is False
def test_syndicated_dev_count_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
count = 0x12345678
x = pySRUPLib.SRUP_Syndicated_Device_Count()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.count = count
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndicated_device_count_message_type()
def test_syndication_request_generic_deserializer_keystring():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
data = "0123456789ABCDEF"
x = pySRUPLib.SRUP_Syndication_Request()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.encrypt_keystring(data, pub_keystring)
assert x.sign_keystring(priv_keystring) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndication_request_message_type()
def test_join_request_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
data = "0123456789ABCDEF"
x = pySRUPLib.SRUP_Human_Join_Response()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.encrypt(data, pubkeyfile)
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__human_join_response_message_type()
def test_join_command_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
dev_id = 0x8383838383838383
x = pySRUPLib.SRUP_Join_Command()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.device_id = dev_id
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__join_command_message_type()
def test_initiate_generic_deserializer():
token = "TOKEN12345"
action_id = 7
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
status = pySRUPLib.SRUP_Response().srup_response_status_update_fail_file()
x = pySRUPLib.SRUP_Response()
i = pySRUPLib.SRUP_Generic()
x.action_id = action_id
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.status = status
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__response_message_type()
def test_syndicated_action_request_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
target_id = 0x76543210FEDCBA98
action = 0x43
x = pySRUPLib.SRUP_Syndicated_Action()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.target_id = target_id
x.action_id = action
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndicated_action_message_type()
def test_syndication_init_generic_deserializer_keystring():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
data = "0123456789ABCDEF"
url = "http://www.really-long-url.example.com/longpath/to/the/files/we_might/need.py"
x = pySRUPLib.SRUP_Syndication_Init()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.url = url
x.encrypt_keystring(data, pub_keystring)
assert x.sign_keystring(priv_keystring) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndication_init_message_type()
def test_join_request_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
data = "0123456789ABCDEF"
joining_device_id = 0xABCF5F5F5F5F5F5F
x = pySRUPLib.SRUP_Observation_Request()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.joining_device_id = joining_device_id
x.encrypt(data, pubkeyfile)
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__observation_request_message_type()
def test_generic_seqid():
MAX_SEQID = 0xFFFFFFFFFFFFFFFF
ZERO_SEQID = 0x00
VALID_SEQID = 0x7FFFFFFFFFFFFFE7
x = pySRUPLib.SRUP_Generic()
x.sequence_id = MAX_SEQID
assert x.sequence_id == MAX_SEQID
x.sequence_id = VALID_SEQID
assert x.sequence_id == VALID_SEQID
x.sequence_id = ZERO_SEQID
assert x.sequence_id == ZERO_SEQID
with pytest.raises(OverflowError):
x.sequence_id = MAX_SEQID + 1
with pytest.raises(OverflowError):
x.sequence_id = ZERO_SEQID - 1
def test_generic_sender():
MAX_SENDER = 0xFFFFFFFFFFFFFFFF
ZERO_SENDER = 0x00
VALID_SENDER = 0x7FFFFFFFFFFFFFE7
x = pySRUPLib.SRUP_Generic()
x.sender_id = MAX_SENDER
assert x.sender_id == MAX_SENDER
x.sender_id = VALID_SENDER
assert x.sender_id == VALID_SENDER
x.sender_id = ZERO_SENDER
assert x.sender_id == ZERO_SENDER
with pytest.raises(OverflowError):
x.sender_id = MAX_SENDER + 1
with pytest.raises(OverflowError):
x.sender_id = ZERO_SENDER - 1
def test_syndicated_dev_list_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
dev_seq = 0x12345678
dev_id = 0x7765412340ABCDEF
x = pySRUPLib.SRUP_Syndicated_Device_List()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.device_sequence = dev_seq
x.device_id = dev_id
assert x.sign(keyfile) is True
z = x.serialize()
assert z is not None
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndicated_device_list_message_type()
def test_data_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
data_id = "Text"
data = "This is some text ..."
x = pySRUPLib.SRUP_Data()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.data_id = data_id
x.bytes_data = data
assert x.sign(keyfile) is True
z = x.serialize()
assert z is not None
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__data_message_type()
def test_initiate_generic_deserializer():
token = "TOKEN12345"
action_id = 7
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
digest = "8317c2d45ef7d42d7abe4f2eb5f53787e158b78680d67e99615b8799ef9936eb"
url = "http://www.really-long-url.example.com/longpath/to/the/files/we_might/need.py"
x = pySRUPLib.SRUP_Initiate()
i = pySRUPLib.SRUP_Generic()
x.action_id = action_id
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.digest = digest
x.url = url
assert x.sign(keyfile) is True
z = x.serialize()
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__initiate_message_type()
def test_c2_req_generic_deserializer():
token = "TOKEN12345"
seq_id = 0x1234567890ABCDEF
send_id = 0x5F5F5F5F5F5F5F5F
req_id = 0xF8
data = "This is some text ..."
source = 0x00011187643212356
x = pySRUPLib.SRUP_Syndicated_C2_Request()
i = pySRUPLib.SRUP_Generic()
x.token = token
x.sequence_id = seq_id
x.sender_id = send_id
x.req_id = req_id
x.bytes_data = data
x.source_id = source
assert x.sign(keyfile) is True
z = x.serialize()
assert z is not None
assert i.deserialize(z) is True
assert i.msg_type == pySRUPLib.__syndicated_c2_request_message_type()
def __on_message(self, client, userdata, msg):
# First check if the message is even for us...
# Remembering that server's are wild...
topic = None
ch_topic = msg.topic
if ch_topic[0:5] == 'SRUP/':
topic = ch_topic[5:]
# First check if the message is for us (or if we're a server read it anyway)
if topic == self.__device_id or self.__isServer:
SRUP_generic_message = pySRUPLib.SRUP_Generic()
# if if deserializes then it's probably a SRUP message...
if SRUP_generic_message.deserialize(msg.payload):
# Did we send it? If so, ignore it...
if SRUP_generic_message.sender_id != int(self.__device_id, 16):
# Check to see if we've had a message from this sender before (creating a counter if we haven't)
if SRUP_generic_message.sender_id not in self.__seq_id:
self.__seq_id.update(
{SRUP_generic_message.sender_id: 0})
# Get current sequence ID for this sender...
s = self.__seq_id[SRUP_generic_message.sender_id]
# Check to see the sequence ID of the message is greater than the last received message
# to avoid replay attack...
if SRUP_generic_message.sequence_id > s:
# Update the "last received" sequence ID for this sender...
self.__seq_id[
SRUP_generic_message.
sender_id] = SRUP_generic_message.sequence_id
msg_type = SRUP_generic_message.msg_type
if msg_type == SRUP_ACTION_MESSAGE_TYPE:
SRUP_action_message = pySRUPLib.SRUP_Action()
SRUP_action_message.deserialize(msg.payload)
if SRUP_action_message.verify(
self.__remote_public_key):
self.__on_action(SRUP_action_message)
else:
# TODO: THROW A CUSTOM EXCEPTION
print("Message did not verify using {}".format(
self.__remote_public_key))
elif msg_type == SRUP_DATA_MESSAGE_TYPE:
SRUP_data_message = pySRUPLib.SRUP_Data()
SRUP_data_message.deserialize(msg.payload)
if SRUP_data_message.verify(
self.__remote_public_key):
self.__on_data(SRUP_data_message)
else:
# TODO: THROW A CUSTOM EXCEPTION
print("Message did not verify using {}".format(
self.__remote_public_key))
elif msg_type == SRUP_INITIATE_MESSAGE_TYPE:
# Devices can't send init messages – so skip this if we're a server...
if not self.__isServer:
SRUP_initiate_message = pySRUPLib.SRUP_Initiate(
)
SRUP_initiate_message.deserialize(msg.payload)
if SRUP_initiate_message.verify(
self.__remote_public_key):
self.__on_initiate(SRUP_initiate_message)
else:
# TODO: THROW A CUSTOM EXCEPTION
print("Message did not verify using {}".
format(self.__remote_public_key))
elif msg_type == SRUP_RESPONSE_MESSAGE_TYPE:
SRUP_response_message = pySRUPLib.SRUP_Response()
SRUP_response_message.deserialize(msg.payload)
if SRUP_response_message.verify(
self.__remote_public_key):
self.__on_response(SRUP_response_message)
else:
# TODO: THROW A CUSTOM EXCEPTION
print("Message did not verify using {}".format(
self.__remote_public_key))
elif msg_type == SRUP_ACTIVATE_MESSAGE_TYPE:
# Devices can't send activate messages either – so again, we'll skip if we're a server.
if not self.__isServer:
SRUP_activate_message = pySRUPLib.SRUP_Activate(
)
SRUP_activate_message.deserialize(msg.payload)
if SRUP_activate_message.verify(
self.__remote_public_key):
self.__on_activate(SRUP_activate_message)
else:
# TODO: THROW A CUSTOM EXCEPTION
print("Message did not verify using {}".
format(self.__remote_public_key))
else:
# We have received a message type that we can't handle...
# TODO: THROW A CUSTOM EXCEPTION
print("Invalid message type or format")
print(SRUP_generic_message.sequence_id)
else:
# TODO: THROW A CUSTOM EXCEPTION
print("Sequence ID 0x{:02X} is invalid".format(
SRUP_generic_message.sequence_id))
# print("Message Type: {}".format(SRUP_generic_message.msg_type))
else:
pass
# This is our own message – so ignore it...
else:
pass
# TODO: Not a SRUP Message ...
else:
pass
def test_generic_token():
x = pySRUPLib.SRUP_Generic()
assert x.token is None
x.token = "TEST_TOKEN"
assert x.token == "TEST_TOKEN"
def test_invalid_deserialize():
x = pySRUPLib.SRUP_Generic()
junk = "12345".encode()
q = x.deserialize(junk)
assert q is False
def test_empty_object():
x = pySRUPLib.SRUP_Generic()
assert x.token is None
assert x.sequence_id is None
assert x.sender_id is None
def test_version():
"""Test the version returns the current version"""
x = pySRUPLib.SRUP_Generic()
assert x.version == pySRUPLib.__version()
def test_response_type():
x = pySRUPLib.SRUP_Generic()
assert x.msg_type == pySRUPLib.__generic_message_type()
