def test_multiple_eth_accounts(self):
sra1 = msg_factories.tasks.SubtaskResultsAcceptedFactory(
**self.gen_ttc_kwargs(
'task_to_compute__',
),
task_to_compute__provider_ethereum_public_key=encode_key_id(
cryptography.ECCx(None).raw_pubkey
),
payment_ts=int(time.time()) - 3600*24,
)
sra1.sign_message(self.requestor_priv_key)
sra2 = msg_factories.tasks.SubtaskResultsAcceptedFactory(
**self.gen_ttc_kwargs(
'task_to_compute__',
),
task_to_compute__provider_ethereum_public_key=encode_key_id(
cryptography.ECCx(None).raw_pubkey
),
payment_ts=int(time.time()) - 3600*24,
)
sra2.sign_message(self.requestor_priv_key)
fp = message.concents.ForcePayment(
subtask_results_accepted_list=[
sra1, sra2,
],
)
print(fp)
response = self.provider_load_response(self.provider_send(fp))
self.assertIsInstance(response, message.concents.ServiceRefused)
class TaskToComputeFactory(helpers.MessageFactory):
class Meta:
model = tasks.TaskToCompute
requestor_id = factory.SelfAttribute('requestor_public_key')
provider_id = factory.SelfAttribute('provider_public_key')
compute_task_def = factory.SubFactory(ComputeTaskDefFactory)
provider_public_key = factory.LazyFunction(
lambda: encode_key_id(cryptography.ECCx(None).raw_pubkey))
provider_ethereum_public_key = factory.SelfAttribute('provider_public_key')
requestor_public_key = factory.LazyFunction(
lambda: encode_key_id(cryptography.ECCx(None).raw_pubkey))
requestor_ethereum_public_key = factory.SelfAttribute(
'requestor_public_key')
compute_task_def = factory.SubFactory(ComputeTaskDefFactory)
package_hash = factory.LazyFunction(lambda: 'sha1:' + faker.Faker().sha1())
size = factory.Faker('random_int', min=1 << 20, max=10 << 20)
price = factory.Faker('random_int', min=1 << 20, max=10 << 20)
@classmethod
def past_deadline(cls, *args, **kwargs):
past_deadline = calendar.timegm(time.gmtime()) - \
int(datetime.timedelta(days=1).total_seconds())
kwargs.update({'compute_task_def__deadline': past_deadline})
return cls(*args, **kwargs)
def test_message_sig(self):
"""Signed message inside a signed message"""
concent_keys = cryptography.ECCx(None)
provider_keys = cryptography.ECCx(None)
requestor_keys = cryptography.ECCx(None)
report_computed_task = factories.tasks.ReportComputedTaskFactory()
# Dump TaskToCompute to make it signed
s_rct = shortcuts.dump(
report_computed_task,
requestor_keys.raw_privkey,
provider_keys.raw_pubkey,
)
# Load TaskToCompute back to its original format
# Task TaskToCompute is verified correctly
report_computed_task = shortcuts.load(
s_rct,
provider_keys.raw_privkey,
requestor_keys.raw_pubkey,
)
first_sig = report_computed_task.sig
first_hash = report_computed_task.get_short_hash()
force_report = message.ForceReportComputedTask()
force_report.report_computed_task = report_computed_task
s_force_report = shortcuts.dump(
force_report,
provider_keys.raw_privkey,
concent_keys.raw_pubkey,
)
force_report = shortcuts.load(
s_force_report,
concent_keys.raw_privkey,
provider_keys.raw_pubkey,
)
second_sig = force_report.report_computed_task.sig
second_hash = force_report.report_computed_task.get_short_hash()
self.assertEqual(first_sig, second_sig)
self.assertEqual(first_hash, second_hash)
# Now, attached TaskToCompute should still be verified using
# original key. ecdsa_verify will raise InvalidSignature on
# failure.
cryptography.ecdsa_verify(
requestor_keys.raw_pubkey,
force_report.report_computed_task.sig,
force_report.report_computed_task.get_short_hash(),
)
def test_validate_owner_requestor(self):
requestor_keys = cryptography.ECCx(None)
arct = self.FACTORY(
report_computed_task__task_to_compute__requestor_public_key=encode_hex(requestor_keys.raw_pubkey), # noqa pylint:disable=line-too-long
sign__privkey=requestor_keys.raw_privkey,
)
self.assertTrue(arct.validate_ownership())
def setUp(self):
# Avoid warnings caused by previous tests leaving handlers
library._handlers = {}
super().setUp()
self.task_server = taskserver_factories.TaskServer(
client=self.client, )
history.MessageHistoryService()
# received_handler.TaskServerMessageHandler is instantiated
# in TaskServer.__init__
self.cf_transfer = self.client.concent_filetransfers.transfer
self.provider_keys = cryptography.ECCx(None)
self.concent_keys = cryptography.ECCx(None)
self.requestor_keys = cryptography.ECCx(None)
self.client.concent_variant = {'pubkey': self.concent_keys.raw_pubkey}
def test_validate_owner_concent(self):
concent_keys = cryptography.ECCx(None)
arct = self.FACTORY(
sign__privkey=concent_keys.raw_privkey,
)
self.assertTrue(
arct.validate_ownership(
concent_public_key=concent_keys.raw_pubkey))
def setUp(self):
super().setUp()
self.keys = cryptography.ECCx(None)
self.different_keys = cryptography.ECCx(None)
self.msg = factories.tasks.TaskToComputeFactory()
self.msg._fake_sign()
self.msg.want_to_compute_task.sign_message(self.keys.raw_privkey) # noqa pylint: disable=no-member
self.task_session = tasksession.TaskSession(mock.MagicMock())
self.task_session.task_server.keys_auth.ecc.raw_pubkey = \
self.keys.raw_pubkey
self.task_session.task_server.task_keeper\
.task_headers[self.msg.task_id]\
.subtasks_count = 10
self.task_session.task_server.client.transaction_system\
.get_available_gnt.return_value = self.msg.price * 10
self.task_session.task_server.client.transaction_system\
.concent_balance.return_value = (self.msg.price * 10) * 2
self.task_session.task_server.client.transaction_system\
.concent_timelock.return_value = 0
def setUp(self):
super().setUp()
self.requestor_keys = cryptography.ECCx(None)
self.msg = factories.tasks.WantToComputeTaskFactory()
self.msg._fake_sign()
self.task_session = tasksession.TaskSession(mock.MagicMock())
self.task_session.key_id = 'unittest_key_id'
self.task_session.task_server.keys_auth._private_key = \
self.requestor_keys.raw_privkey
self.task_session.task_server.keys_auth.public_key = \
self.requestor_keys.raw_pubkey
def test_multiple_requestors(self):
"""Test requestor sameness
Concent service verifies wether all messages from LAR are signed by
the same Requestor and are have the same Ethereum address. Otherwise
Concent responds with ServiceRefused "invalid message".
LAR - list of acceptances in request
"""
sra1 = msg_factories.tasks.SubtaskResultsAcceptedFactory(
**self.gen_ttc_kwargs(
'task_to_compute__',
),
payment_ts=int(time.time()) - 3600*24,
)
sra1.sign_message(self.requestor_priv_key)
requestor2_keys = cryptography.ECCx(None)
ttc2_kwargs = self.gen_ttc_kwargs('task_to_compute__')
ttc2_kwargs.update(
{'task_to_compute__sign__privkey': requestor2_keys.raw_privkey}
)
sra2 = msg_factories.tasks.SubtaskResultsAcceptedFactory(
**ttc2_kwargs,
payment_ts=int(time.time()) - 3600*24,
)
sra2.sign_message(requestor2_keys.raw_privkey)
fp = message.concents.ForcePayment(
subtask_results_accepted_list=[
sra1, sra2,
],
)
print(fp)
self.assertTrue(
fp.subtask_results_accepted_list[0].verify_signature( # noqa pylint:disable=no-member
self.requestor_pub_key
)
)
self.assertTrue(
fp.subtask_results_accepted_list[1].verify_signature( # noqa pylint:disable=no-member
requestor2_keys.raw_pubkey
)
)
response = self.provider_load_response(self.provider_send(fp))
self.assertIsInstance(response, message.concents.ServiceRefused)
def setUp(self):
super().setUp()
self.keys = cryptography.ECCx(None)
self.keys2 = cryptography.ECCx(None)
def _fake_keys():
return cryptography.ECCx(None)
def test_message_sig(self):
"""Signed message inside a signed message"""
concent_keys = cryptography.ECCx(None)
provider_keys = cryptography.ECCx(None)
requestor_keys = cryptography.ECCx(None)
task_to_compute = message.TaskToCompute()
ctd = message.ComputeTaskDef({
'task_id': 20,
})
task_to_compute.compute_task_def = ctd
# Dump TaskToCompute to make it signed
s_task_to_compute = shortcuts.dump(
task_to_compute,
requestor_keys.raw_privkey,
provider_keys.raw_pubkey,
)
# Load TaskToCompute back to its original format
task_to_compute = shortcuts.load(
s_task_to_compute,
provider_keys.raw_privkey,
requestor_keys.raw_pubkey,
)
first_sig = task_to_compute.sig
first_hash = task_to_compute.get_short_hash()
# Task TaskToCompute is verified correctly
cryptography.ecdsa_verify(
requestor_keys.raw_pubkey,
task_to_compute.sig,
task_to_compute.get_short_hash(),
)
force_report = message.ForceReportComputedTask()
force_report.task_to_compute = task_to_compute
s_force_report = shortcuts.dump(
force_report,
provider_keys.raw_privkey,
concent_keys.raw_pubkey,
)
force_report = shortcuts.load(
s_force_report,
concent_keys.raw_privkey,
provider_keys.raw_pubkey,
)
second_sig = force_report.task_to_compute.sig
second_hash = force_report.task_to_compute.get_short_hash()
self.assertEqual(first_sig, second_sig)
self.assertEqual(first_hash, second_hash)
# Now, attached TaskToCompute should still be verified using
# original key. ecdsa_verify will raise InvalidSignature on
# failure.
cryptography.ecdsa_verify(
requestor_keys.raw_pubkey,
force_report.task_to_compute.sig,
force_report.task_to_compute.get_short_hash(),
)
