def apply(self, transaction, state):
txn_header = TransactionHeader()
txn_header.ParseFromString(transaction.header)
pubkey = txn_header.signer_pubkey
val_reg_payload = ValidatorRegistryPayload()
val_reg_payload.ParseFromString(transaction.payload)
# Check name
validator_name = val_reg_payload.name
if len(validator_name) > 64:
raise InvalidTransaction(
'Illegal validator name {}'.format(validator_name))
# Check registering validator matches transaction signer.
validator_id = val_reg_payload.id
if validator_id != pubkey:
raise InvalidTransaction(
'Signature mismatch on validator registration with validator'
' {} signed by {}'.format(validator_id, pubkey))
public_key_hash = hashlib.sha256(pubkey.encode()).hexdigest()
signup_info = val_reg_payload.signup_info
try:
self._verify_signup_info(
signup_info=signup_info,
originator_public_key_hash=public_key_hash,
val_reg_payload=val_reg_payload,
state=state)
except ValueError as error:
raise InvalidTransaction(
'Invalid Signup Info: {0}, Reason: {1}'.format(
signup_info,
error))
validator_info = ValidatorInfo(
registered="registered",
name=validator_name,
id=validator_id,
signup_info=val_reg_payload.signup_info,
transaction_id=transaction.signature
)
_update_validator_state(state,
validator_id,
signup_info.anti_sybil_id,
validator_info.SerializeToString())
def test_invalid_report_key_pem(self):
"""
Testing validator registry unable to succcessfully parse the report
public key PEM from the config setting.
"""
signup_info = self.factory.create_signup_info(
self.factory.public_key_hash, "000")
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with empty report key PEM
self.validator.respond(
self.factory.create_get_response_report_key_pem(pem='invalid'),
received)
# Expect that the transaction will be rejected
self._expect_invalid_transaction()
def test_invalid_poet_pubkey(self):
"""
Test that a transaction without a poet_public_key returns an invalid
transaction.
"""
signup_info = self.factory.create_signup_info(
self.factory.pubkey_hash, "000")
signup_info.poet_public_key = "bad"
payload = ValidatorRegistryPayload(
verb="reg",
name="val_1",
id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with simulator report key PEM
self.validator.respond(
self.factory.create_get_response_simulator_report_key_pem(),
received)
self._expect_invalid_transaction()
def _test_bad_signup_info(self, signup_info):
payload = ValidatorRegistryPayload(verb="reg",
name="val_1",
id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
self._expect_invalid_transaction()
def test_missing_enclave_basenames(self):
"""
Testing validator registry unable to retrieve the valid enclave
basenames from the config setting.
"""
signup_info = self.factory.create_signup_info(
self.factory.public_key_hash, "000")
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with the simulator report key PEM
self.validator.respond(
self.factory.create_get_response_simulator_report_key_pem(),
received)
# Expect Request for the address for valid enclave measurements
received = self.validator.expect(
self.factory.create_get_request_enclave_measurements())
# Respond with simulator valid enclave measurements
self.validator.respond(
self.factory.create_get_response_simulator_enclave_measurements(),
received)
# Expect Request for the address for valid enclave basenames
received = self.validator.expect(
self.factory.create_get_request_enclave_basenames())
# Respond with empty enclave basenames
self.validator.respond(
self.factory.create_get_response_enclave_basenames(),
received)
# Expect that the transaction will be rejected
self._expect_invalid_transaction()
def test_invalid_id(self):
"""
Test that a transaction with an id that does not match the
signer_pubkey returns an invalid transaction.
"""
signup_info = self.factory.create_signup_info(self.factory.pubkey_hash,
"000")
# The idea should match the signer_pubkey in the transaction_header
payload = ValidatorRegistryPayload(verb="reg",
name="val_1",
id="bad",
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
self._expect_invalid_transaction()
def test_invalid_poet_pubkey(self):
"""
Test that a transaction without a poet_public_key returns an invalid
transaction.
"""
signup_info = self.factory.create_signup_info(self.factory.pubkey_hash,
"000")
signup_info.poet_public_key = "bad"
payload = ValidatorRegistryPayload(verb="reg",
name="val_1",
id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
self._expect_invalid_transaction()
def _test_bad_signup_info(self, signup_info, expect_config=True):
payload = ValidatorRegistryPayload(
verb="reg",
name="val_1",
id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
if expect_config:
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with simulator report key PEM
self.validator.respond(
self.factory.create_get_response_simulator_report_key_pem(),
received)
# Expect Request for the address for valid enclave measurements
received = self.validator.expect(
self.factory.create_get_request_enclave_measurements())
# Respond with the simulator valid enclave measurements
self.validator.respond(
self.factory.
create_get_response_simulator_enclave_measurements(),
received)
# Expect Request for the address for valid enclave basenames
received = self.validator.expect(
self.factory.create_get_request_enclave_basenames())
# Respond with the simulator valid enclave basenames
self.validator.respond(
self.factory.create_get_response_simulator_enclave_basenames(),
received)
self._expect_invalid_transaction()
def test_invalid_name(self):
"""
Test that a transaction with an invalid name returns an invalid
transaction.
"""
signup_info = self.factory.create_signup_info(
self.factory.pubkey_hash, "000")
# The name is longer the 64 characters
payload = ValidatorRegistryPayload(
verb="reg",
name="val_11111111111111111111111111111111111111111111111111111111"
"11111",
id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.tester.send(
self.factory.create_tp_process_request(payload.id, payload))
self._expect_invalid_transaction()
def test_valid_signup_info(self):
"""
Testing valid validator_registry transaction. This includes sending new
signup info for a validator that has already been registered.
"""
signup_info = self.factory.create_signup_info(
self.factory.pubkey_hash, "000")
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.tester.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the ValidatorMap
received = self.tester.expect(
self.factory.create_get_request_validator_map())
# Respond with a empty validator Map
self.tester.respond(
self.factory.create_get_empty_response_validator_map(), received)
# Expect a set the new validator to the ValidatorMap
received = self.tester.expect(
self.factory.create_set_request_validator_map())
# Respond with the ValidatorMap address
self.tester.respond(self.factory.create_set_response_validator_map(),
received)
# Expect a request to set ValidatorInfo for val_1
received = self.tester.expect(
self.factory.create_set_request_validator_info("val_1",
"registered"))
# Respond with address for val_1
# val_1 address is derived from the validators id
# val id is the same as the pubkey for the factory
self.tester.respond(self.factory.create_set_response_validator_info(),
received)
self._expect_ok()
# --------------------------
signup_info = self.factory.create_signup_info(
self.factory.pubkey_hash, "000")
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.tester.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the ValidatorMap
received = self.tester.expect(
self.factory.create_get_request_validator_map())
# Respond with a validator Map
self.tester.respond(self.factory.create_get_response_validator_map(),
received)
# Expect to receive a validator_info request
received = self.tester.expect(
self.factory.create_get_request_validator_info())
# Respond with the ValidatorInfo
self.tester.respond(
self.factory.create_get_response_validator_info("val_1"), received)
# Expect a request to set ValidatorInfo for val_1
received = self.tester.expect(
self.factory.create_set_request_validator_info("val_1", "revoked"))
# Respond with address for val_1
# val_1 address is derived from the validators id
# val id is the same as the pubkey for the factory
self.tester.respond(
self.factory.create_set_response_validator_info(), received)
# Expect a request to set ValidatorInfo for val_1
received = self.tester.expect(
self.factory.create_set_request_validator_info("val_1",
"registered"))
# Respond with address for val_1
# val_1 address is derived from the validators id
# val id is the same as the pubkey for the factory
self.tester.respond(self.factory.create_set_response_validator_info(),
received)
self._expect_ok()
def _test_valid_signup_info(self, signup_info):
"""
Testing valid validator_registry transaction.
"""
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
transaction_message =\
self.factory.create_tp_process_request(payload.id, payload)
transaction_id = transaction_message.signature
self.validator.send(
transaction_message)
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with simulator report key PEM
self.validator.respond(
self.factory.create_get_response_simulator_report_key_pem(),
received)
# Expect Request for the address for valid enclave measurements
received = self.validator.expect(
self.factory.create_get_request_enclave_measurements())
# Respond with the simulator valid enclave measurements
self.validator.respond(
self.factory.create_get_response_simulator_enclave_measurements(),
received)
# Expect Request for the address for valid enclave basenames
received = self.validator.expect(
self.factory.create_get_request_enclave_basenames())
# Respond with the simulator valid enclave basenames
self.validator.respond(
self.factory.create_get_response_simulator_enclave_basenames(),
received)
# Expect Request for the ValidatorMap
received = self.validator.expect(
self.factory.create_get_request_validator_map())
# Respond with a empty validator Map
self.validator.respond(
self.factory.create_get_empty_response_validator_map(), received)
# Expect a set the new validator to the ValidatorMap
received = self.validator.expect(
self.factory.create_set_request_validator_map())
# Respond with the ValidatorMap address
self.validator.respond(
self.factory.create_set_response_validator_map(),
received)
# Expect a request to set ValidatorInfo for val_1
received = self.validator.expect(
self.factory.create_set_request_validator_info(
"val_1", transaction_id, signup_info))
# Respond with address for val_1
# val_1 address is derived from the validators id
# val id is the same as the public_key for the factory
self.validator.respond(
self.factory.create_set_response_validator_info(),
received)
self._expect_ok()
def test_valid_signup_info(self):
"""
Testing valid validator_registry transaction. This includes sending new
signup info for a validator that has already been registered.
"""
signup_info = self.factory.create_signup_info(
self.factory.pubkey_hash, "000")
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with simulator report key PEM
self.validator.respond(
self.factory.create_get_response_simulator_report_key_pem(),
received)
# Expect Request for the address for valid enclave measurements
received = self.validator.expect(
self.factory.create_get_request_enclave_measurements())
# Respond with the simulator valid enclave measurements
self.validator.respond(
self.factory.create_get_response_simulator_enclave_measurements(),
received)
# Expect Request for the address for valid enclave basenames
received = self.validator.expect(
self.factory.create_get_request_enclave_basenames())
# Respond with the simulator valid enclave basenames
self.validator.respond(
self.factory.create_get_response_simulator_enclave_basenames(),
received)
# Expect Request for the ValidatorMap
received = self.validator.expect(
self.factory.create_get_request_validator_map())
# Respond with a empty validator Map
self.validator.respond(
self.factory.create_get_empty_response_validator_map(), received)
# Expect a set the new validator to the ValidatorMap
received = self.validator.expect(
self.factory.create_set_request_validator_map())
# Respond with the ValidatorMap address
self.validator.respond(
self.factory.create_set_response_validator_map(),
received)
# Expect a request to set ValidatorInfo for val_1
received = self.validator.expect(
self.factory.create_set_request_validator_info("val_1"))
# Respond with address for val_1
# val_1 address is derived from the validators id
# val id is the same as the pubkey for the factory
self.validator.respond(
self.factory.create_set_response_validator_info(),
received)
self._expect_ok()
# --------------------------
signup_info = self.factory.create_signup_info(
self.factory.pubkey_hash, "000")
payload = ValidatorRegistryPayload(
verb="reg", name="val_1", id=self.factory.public_key,
signup_info=signup_info)
# Send validator registry payload
self.validator.send(
self.factory.create_tp_process_request(payload.id, payload))
# Expect Request for the address for report key PEM
received = self.validator.expect(
self.factory.create_get_request_report_key_pem())
# Respond with simulator report key PEM
self.validator.respond(
self.factory.create_get_response_simulator_report_key_pem(),
received)
# Expect Request for the address for valid enclave measurements
received = self.validator.expect(
self.factory.create_get_request_enclave_measurements())
# Respond with the simulator valid enclave measurements
self.validator.respond(
self.factory.create_get_response_simulator_enclave_measurements(),
received)
# Expect Request for the address for valid enclave basenames
received = self.validator.expect(
self.factory.create_get_request_enclave_basenames())
# Respond with the simulator valid enclave basenames
self.validator.respond(
self.factory.create_get_response_simulator_enclave_basenames(),
received)
# Expect Request for the ValidatorMap
received = self.validator.expect(
self.factory.create_get_request_validator_map())
# Respond with a validator Map
self.validator.respond(
self.factory.create_get_response_validator_map(),
received)
# Clear the validator info for the address
# Expect del validator info
received = self.validator.expect(
self.factory.create_del_request_validator_info())
# Respond with an empty data message
self.validator.respond(
self.factory.create_del_response_validator_info(), received)
# Set the Map
# Expect set request ValidatorMap
received = self.validator.expect(
self.factory.create_set_request_validator_map())
# Respond with the ValidatorMap address
self.validator.respond(
self.factory.create_set_response_validator_map(),
received)
# Set the validator address
# Expect a request to set ValidatorInfo for val_1
received = self.validator.expect(
self.factory.create_set_request_validator_info("val_1"))
# Respond with address for val_1
# val_1 address is derived from the validators id
# val id is the same as the pubkey for the factory
self.validator.respond(
self.factory.create_set_response_validator_info(),
received)
self._expect_ok()
