def test_deserialization_with_time_verification(self, vft_mock): msg = message.Ping() payload = golem_messages.dump(msg, self.ecc.raw_privkey, self.ecc.raw_pubkey) self.assertEqual(vft_mock.call_count, 0) golem_messages.load(payload, self.ecc.raw_privkey, self.ecc.raw_pubkey) self.assertEqual(vft_mock.call_count, 1)
def test_slots_reselialization_optimization(self, dumps_mock): """Don't reserialize message slots immediately after deserialization""" msg = message.p2p.Tasks() # Choose msg type with SIGN = True payload = golem_messages.dump(msg, self.ecc.raw_privkey, self.ecc.raw_pubkey) # One call for slots and second for hash_header self.assertEqual(dumps_mock.call_count, 2) dumps_mock.reset_mock() golem_messages.load(payload, self.ecc.raw_privkey, self.ecc.raw_pubkey) # One call for hash_header dumps_mock.assert_called_once_with(mock.ANY)
def test_hello_version_verify(self, v_mock): msg = message.Hello() serialized = golem_messages.dump( msg, self.ecc.raw_privkey, self.ecc.raw_pubkey, ) golem_messages.load( serialized, self.ecc.raw_privkey, self.ecc.raw_pubkey, ) v_mock.assert_called_once_with(golem_messages.__version__)
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset self.compute_task_def = ComputeTaskDefFactory() self.compute_task_def['deadline'] = message_timestamp want_to_compute_task = WantToComputeTaskFactory( provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), ) want_to_compute_task = sign_message(want_to_compute_task, PROVIDER_PRIVATE_KEY) task_to_compute = tasks.TaskToComputeFactory( compute_task_def=self.compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), requestor_ethereum_public_key=encode_hex( REQUESTOR_ETHERUM_PUBLIC_KEY), want_to_compute_task=want_to_compute_task, price=1, ) task_to_compute.generate_ethsig(REQUESTOR_ETHEREUM_PRIVATE_KEY) task_to_compute.sign_all_promissory_notes( deposit_contract_address=settings.GNT_DEPOSIT_CONTRACT_ADDRESS, private_key=REQUESTOR_ETHEREUM_PRIVATE_KEY, ) self.task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) report_computed_task = tasks.ReportComputedTaskFactory( task_to_compute=self.task_to_compute) self.report_computed_task = load( dump( report_computed_task, PROVIDER_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, PROVIDER_PUBLIC_KEY, check_time=False, ) self.force_report_computed_task = message.concents.ForceReportComputedTask( report_computed_task=self.report_computed_task) self.force_get_task_result = message.concents.ForceGetTaskResult( report_computed_task=self.report_computed_task)
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset compute_task_def = message.ComputeTaskDef() compute_task_def['task_id'] = '8' compute_task_def['subtask_id'] = '8' compute_task_def['deadline'] = message_timestamp task_to_compute = tasks.TaskToComputeFactory( compute_task_def=compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), price=0, ) task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) report_computed_task = tasks.ReportComputedTaskFactory( task_to_compute=task_to_compute) self.force_report_computed_task = message.ForceReportComputedTask( report_computed_task=report_computed_task)
def _test_response(self, response, status, key, message_type=None, fields=None, nested_message_verifiable_by=None): self.assertEqual(response.status_code, status) if message_type: message_from_concent = load(response.content, key, settings.CONCENT_PUBLIC_KEY, check_time=False) self.assertIsInstance(message_from_concent, message_type) if fields: for field_name, field_value in fields.items(): self.assertEqual( functools.reduce(getattr, field_name.split('.'), message_from_concent), field_value) else: self.assertEqual(len(response.content), 0) if nested_message_verifiable_by is not None: assert isinstance(nested_message_verifiable_by, dict) for nested_message, public_key in nested_message_verifiable_by.items( ): nested_message = functools.reduce(getattr, nested_message.split('.'), message_from_concent) self.assertTrue( Message.verify_signature(nested_message, public_key))
def test_dump_load(self): msg = message.Ping() payload = golem_messages.dump(msg, self.ecc.raw_privkey, self.ecc.raw_pubkey) msg2 = golem_messages.load(payload, self.ecc.raw_privkey, self.ecc.raw_pubkey) self.assertEqual(msg, msg2)
def _load_message(self, data): msg = golem_messages.load(data, None, None) logger.debug( 'BasicProtocol._load_message(): received %r', msg, ) return msg
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset compute_task_def = message.ComputeTaskDef() compute_task_def['task_id'] = '8' compute_task_def['subtask_id'] = '8' compute_task_def['deadline'] = message_timestamp compute_task_def['extra_data'] = { 'frames': [1], 'output_format': 'PNG', 'scene_file': 'kitten.blend', } task_to_compute = tasks.TaskToComputeFactory( compute_task_def=compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), price=0, ) task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) report_computed_task = tasks.ReportComputedTaskFactory( task_to_compute=task_to_compute) report_computed_task = load( dump( report_computed_task, PROVIDER_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, PROVIDER_PUBLIC_KEY, check_time=False, ) self.force_report_computed_task = message.ForceReportComputedTask( report_computed_task=report_computed_task)
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset self.compute_task_def = ComputeTaskDefFactory() self.compute_task_def['deadline'] = message_timestamp want_to_compute_task = WantToComputeTaskFactory( provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), ) want_to_compute_task = sign_message(want_to_compute_task, PROVIDER_PRIVATE_KEY) task_to_compute = tasks.TaskToComputeFactory( compute_task_def=self.compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), want_to_compute_task=want_to_compute_task, price=1, ) self.task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) report_computed_task = tasks.ReportComputedTaskFactory( task_to_compute=self.task_to_compute) self.report_computed_task = load( dump( report_computed_task, PROVIDER_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, PROVIDER_PUBLIC_KEY, check_time=False, ) self.force_report_computed_task = message.concents.ForceReportComputedTask( report_computed_task=self.report_computed_task) self.force_get_task_result = message.concents.ForceGetTaskResult( report_computed_task=self.report_computed_task)
def _prepare_subtask_results_verify(self, serialized_subtask_results_verify): subtask_results_verify = load( serialized_subtask_results_verify, CONCENT_PRIVATE_KEY, self.PROVIDER_PUBLIC_KEY, check_time=False, ) subtask_results_verify.encrypted = False return subtask_results_verify
def _load_message(self, data): msg = golem_messages.load( data, self.session.my_private_key, self.session.theirs_public_key, ) logger.debug( 'SafeProtocol._load_message(): received %r', msg, ) return msg
def setUp(self): super().setUp() compute_task_def = message.ComputeTaskDef() task_to_compute = tasks.TaskToComputeFactory( compute_task_def=compute_task_def ) serialized_task_to_compute = dump(task_to_compute, REQUESTOR_PRIVATE_KEY, PROVIDER_PUBLIC_KEY) deserialized_task_to_compute = load(serialized_task_to_compute, PROVIDER_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False) self.ack_report_computed_task = message.tasks.AckReportComputedTask() self.ack_report_computed_task.report_computed_task = message.ReportComputedTask( task_to_compute=deserialized_task_to_compute )
def test_hello_version_signature(self): msg = message.Hello() serialized = golem_messages.dump( msg, self.ecc.raw_privkey, self.ecc.raw_pubkey, ) msg = golem_messages.load( serialized, self.ecc.raw_privkey, self.ecc.raw_pubkey, ) msg._version = 'haxior' with self.assertRaises(exceptions.InvalidSignature): self.ecc.verify(msg.sig, msg.get_short_hash())
def setUp(self): self.request_factory = RequestFactory() self.want_to_compute = message.WantToComputeTask( node_name=1, task_id=2, perf_index=3, price=4, max_resource_size=5, max_memory_size=6, num_cores=7, ) self.message_to_view = { "node_name": self.want_to_compute.node_name, # pylint: disable=no-member "task_id": self.want_to_compute.task_id, # pylint: disable=no-member "perf_index": self.want_to_compute.perf_index, # pylint: disable=no-member "price": self.want_to_compute.price, # pylint: disable=no-member "max_resource_size": self.want_to_compute.max_resource_size, # pylint: disable=no-member "max_memory_size": self.want_to_compute.max_memory_size, # pylint: disable=no-member "num_cores": self.want_to_compute.num_cores, # pylint: disable=no-member } deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset compute_task_def = tasks.ComputeTaskDefFactory( task_id='8', subtask_id='8', deadline=message_timestamp, ) task_to_compute = tasks.TaskToComputeFactory( compute_task_def=compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), price=0, ) task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) self.force_report_computed_task = message.ForceReportComputedTask() self.force_report_computed_task.report_computed_task = message.tasks.ReportComputedTask( ) self.force_report_computed_task.report_computed_task.task_to_compute = task_to_compute
def test_handle_errors_and_responses_should_return_http_response_with_serialized_message( self): dumped_message = dump(self._create_test_ping_message(), CONCENT_PRIVATE_KEY, self.PROVIDER_PUBLIC_KEY) request = self.request_factory.post( "/dummy-url/", content_type='application/octet-stream', data=dumped_message, HTTP_X_Golem_Messages=settings.GOLEM_MESSAGES_VERSION, ) response = dummy_view_handle_errors_and_responses( request, dumped_message, self.PROVIDER_PUBLIC_KEY) loaded_response = load(response.content, self.PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY) self.assertEqual(response.status_code, 200) self.assertIsInstance(loaded_response, message.Ping)
def test_handle_errors_and_responses_should_return_serialized_message_if_gets_deserialized( self): with freeze_time("2017-12-31 00:00:00"): client_auth = message.concents.ClientAuthorization() client_auth.client_public_key = self.PROVIDER_PUBLIC_KEY request = self.request_factory.post( "/dummy-url/", content_type='application/octet-stream') with freeze_time("2017-12-31 00:00:10"): response = dummy_view_handle_errors_and_responses( request, client_auth, self.PROVIDER_PUBLIC_KEY) loaded_response = load(response.content, self.PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY) # pylint: disable=no-member self.assertEqual(response.status_code, 200) # pylint: disable=no-member self.assertIsInstance(loaded_response, message.concents.ClientAuthorization) self.assertEqual(loaded_response.timestamp, parse_iso_date_to_timestamp("2017-12-31 00:00:00"))
def react_to_concent_message(self, data: typing.Optional[bytes], response_to: message.Message = None): if data is None: logger.debug('Received nothing from Concent') return try: msg = golem_messages.load( data, self.keys_auth.ecc.raw_privkey, self.variant['pubkey'], ) logger.debug('Concent Message received: %s', msg) except golem_messages.exceptions.MessageError as e: logger.warning("Can't deserialize concent message %s:%r", e, data) logger.debug('Problem parsing msg', exc_info=True) return if not response_to: self.received_messages.put(msg) else: self.process_synchronous_response(msg, response_to)
def _load_response(self, response, priv_key): if response is None: return None return golem_messages.load(response, priv_key, self.variant['pubkey'])
def test_serialization(self): msg = self.get_instance() s_msg = golem_messages.dump(msg, None, None) msg2 = golem_messages.load(s_msg, None, None) self.assertEqual(msg, msg2)