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(), )