def get_default_auth_rule(self):
action = AuthActionEdit(txn_type=AUTH_RULE,
field='*',
old_value='*',
new_value='*')
constraint = auth_map.auth_map.get(action.get_action_id())
operation = generate_auth_rule_operation(auth_action=EDIT_PREFIX,
auth_type=AUTH_RULE,
field='*',
old_value='*',
new_value='*',
constraint=constraint.as_dict)
return sdk_gen_request(operation, identifier=self.new_default_wallet[1])
def get_default_auth_rule(self):
action = AuthActionEdit(txn_type=AUTH_RULE,
field='*',
old_value='*',
new_value='*')
constraint = auth_map.auth_map.get(action.get_action_id())
return build_auth_rule_request_json(self.looper,
self.new_default_wallet[1],
auth_action=EDIT_PREFIX,
auth_type=AUTH_RULE,
field='*',
old_value='*',
new_value='*',
constraint=constraint.as_dict)
def dynamic_validation(self, request: Request):
self._validate_request_type(request)
rev_reg_tags = request.operation[REVOC_REG_DEF_ID]
author_did, req_id, operation = get_request_data(request)
current_entry, revoc_def = self._get_current_revoc_entry_and_revoc_def(
author_did=author_did,
revoc_reg_def_id=operation[REVOC_REG_DEF_ID],
req_id=req_id)
rev_ref_def_author_did = rev_reg_tags.split(":", 1)[0]
is_owner = rev_ref_def_author_did == author_did
if current_entry:
self.write_req_validator.validate(request, [
AuthActionEdit(txn_type=REVOC_REG_ENTRY,
field='*',
old_value='*',
new_value='*',
is_owner=is_owner)
])
else:
self.write_req_validator.validate(request, [
AuthActionAdd(txn_type=REVOC_REG_ENTRY,
field='*',
value='*',
is_owner=is_owner)
])
validator_cls = self.get_revocation_strategy(
revoc_def[VALUE][ISSUANCE_TYPE])
validator = validator_cls(self.state)
validator.validate(current_entry, request)
def dynamic_validation(self, request: Request, req_pp_time: Optional[int]):
# we can not add a Claim Def with existent ISSUER_DID
# sine a Claim Def needs to be identified by seqNo
self._validate_request_type(request)
identifier, req_id, operation = get_request_data(request)
ref = operation[REF]
try:
txn = self.ledger.get_by_seq_no_uncommitted(ref)
except KeyError:
raise InvalidClientRequest(identifier,
req_id,
"Mentioned seqNo ({}) doesn't exist.".format(ref))
if txn['txn']['type'] != SCHEMA:
raise InvalidClientRequest(identifier,
req_id,
"Mentioned seqNo ({}) isn't seqNo of the schema.".format(ref))
signature_type = get_write_claim_def_signature_type(request)
schema_ref = get_write_claim_def_schema_ref(request)
tag = get_write_claim_def_tag(request)
path = self.make_state_path_for_claim_def(identifier, schema_ref, signature_type, tag)
claim_def, _, _ = self.get_from_state(path, is_committed=False)
if claim_def:
self.write_req_validator.validate(request,
[AuthActionEdit(txn_type=CLAIM_DEF,
field='*',
old_value='*',
new_value='*')])
else:
self.write_req_validator.validate(request,
[AuthActionAdd(txn_type=CLAIM_DEF,
field='*',
value='*')])
def additional_dynamic_validation(self, request: Request,
req_pp_time: Optional[int]):
self._validate_request_type(request)
self.write_req_validator.validate(request, [
AuthActionEdit(
txn_type=AUTH_RULE, field="*", old_value="*", new_value="*")
])
def authorize(self, request):
self.write_req_validator.validate(request, [
AuthActionEdit(txn_type=LEDGERS_FREEZE,
field='*',
old_value='*',
new_value='*')
])
def dynamic_validation(self, request: Request):
self._validate_request_type(request)
operation = request.operation
cred_def_id = operation.get(CRED_DEF_ID)
revoc_def_type = operation.get(REVOC_TYPE)
revoc_def_tag = operation.get(TAG)
assert cred_def_id
assert revoc_def_tag
assert revoc_def_type
revoc_def_id = RevocRegDefHandler.make_state_path_for_revoc_def(
request.identifier, cred_def_id, revoc_def_type, revoc_def_tag)
revoc_def, _, _ = self.get_from_state(revoc_def_id)
if revoc_def is None:
self.write_req_validator.validate(
request,
[AuthActionAdd(txn_type=REVOC_REG_DEF, field='*', value='*')])
else:
self.write_req_validator.validate(request, [
AuthActionEdit(txn_type=REVOC_REG_DEF,
field='*',
old_value='*',
new_value='*')
])
cred_def, _, _ = self.get_from_state(cred_def_id)
if cred_def is None:
raise InvalidClientRequest(
request.identifier, request.reqId,
"There is no any CRED_DEF by path: {}".format(cred_def_id))
def get_default_auth_rules(self):
action = AuthActionEdit(txn_type=AUTH_RULES,
field='*',
old_value='*',
new_value='*')
constraint = auth_map.auth_map.get(action.get_action_id())
rules = [generate_auth_rule(auth_action=EDIT_PREFIX,
auth_type=AUTH_RULES,
field='*',
old_value='*',
new_value='*',
constraint=constraint.as_dict)]
operation = {RULES: rules,
TXN_TYPE: AUTH_RULES}
request = sdk_gen_request(operation, identifier=self.new_default_wallet[1])
return json.dumps(request.as_dict)
def dynamic_validation(self, request: Request):
self._validate_request_type(request)
self.write_req_validator.validate(request,
[AuthActionEdit(txn_type=AUTH_RULES,
field="*",
old_value="*",
new_value="*")])
def test_node_wrong_new_service_name(write_request_validation, req, is_owner):
assert not write_request_validation(req,
[AuthActionEdit(txn_type=NODE,
field=SERVICES,
old_value='[]',
new_value='aaa',
is_owner=is_owner)])
def test_schema_editing(write_request_validation, req, is_owner):
assert not write_request_validation(req,
[AuthActionEdit(txn_type=SCHEMA,
field='some_field',
old_value='old_value',
new_value='new_value',
is_owner=is_owner)])
def test_remove_trust_anchor(write_request_validation, req, is_owner):
authorized = (req.identifier == "trustee_identifier")
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=TRUST_ANCHOR,
new_value='',
is_owner=is_owner)])
def test_context_editing(write_request_validation, req, is_owner):
assert not write_request_validation(req, [
AuthActionEdit(txn_type=SET_CONTEXT,
field='some_field',
old_value='old_value',
new_value='new_value',
is_owner=is_owner)
])
def test_same_role_steward(write_request_validation, req, is_owner):
authorized = is_owner
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=STEWARD,
new_value=STEWARD,
is_owner=is_owner)])
def test_same_role_network_monitor(write_request_validation, req, is_owner):
authorized = is_owner
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=NETWORK_MONITOR,
new_value=NETWORK_MONITOR,
is_owner=is_owner)])
def test_same_role_trustee(write_request_validation, req, is_owner):
authorized = is_owner
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=TRUSTEE,
new_value=TRUSTEE,
is_owner=is_owner)])
def test_change_verkey(write_request_validation, req, is_owner):
authorized = is_owner
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=VERKEY,
old_value="_verkey".format(req.identifier),
new_value='new_value',
is_owner=is_owner)])
def test_remove_network_monitor(write_request_validation, req, is_owner):
authorized = req.identifier in ("trustee_identifier", "steward_identifier")
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=NETWORK_MONITOR,
new_value='',
is_owner=is_owner)])
def test_remove_steward(write_request_validation, req, is_owner):
authorized = (req.identifier == "trustee_identifier")
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=STEWARD,
new_value='',
is_owner=is_owner)])
def test_node_change_bls_keys(write_request_validation, req, is_owner):
authorized = (req.identifier == "steward_identifier" and is_owner)
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NODE,
field=BLS_KEY,
old_value='old_value',
new_value='new_value',
is_owner=is_owner)])
def test_node_change_alias(write_request_validation, req, is_owner):
authorized = False # alias can not be changed
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NODE,
field=ALIAS,
old_value='old_value',
new_value='new_value',
is_owner=is_owner)])
def test_node_change_client_port(write_request_validation, req, is_owner):
authorized = (req.identifier == "steward_identifier" and is_owner)
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NODE,
field=CLIENT_PORT,
old_value='old_value',
new_value='new_value',
is_owner=is_owner)])
def test_node_demote(write_request_validation, req, is_owner):
authorized = (req.identifier == "steward_identifier" and is_owner) or (req.identifier == "trustee_identifier")
assert authorized == write_request_validation(req,
[AuthActionEdit(txn_type=NODE,
field=SERVICES,
old_value='[\'VALIDATOR\']',
new_value='[]',
is_owner=is_owner)])
def _validateAttrib(self, req: Request):
origin = req.identifier
op = req.operation
if not (not op.get(TARGET_NYM) or
self.hasNym(op[TARGET_NYM], isCommitted=False)):
raise InvalidClientRequest(origin, req.reqId,
'{} should be added before adding '
'attribute for it'.
format(TARGET_NYM))
is_owner = self.idrCache.getOwnerFor(op[TARGET_NYM],
isCommitted=False) == origin
field = None
value = None
for key in (RAW, ENC, HASH):
if key in op:
field = key
value = op[key]
break
if field is None or value is None:
raise LogicError('Attribute data cannot be empty')
get_key = None
if field == RAW:
try:
get_key = attrib_raw_data_serializer.deserialize(value)
if len(get_key) == 0:
raise InvalidClientRequest(origin, req.reqId,
'"row" attribute field must contain non-empty dict'.
format(TARGET_NYM))
get_key = next(iter(get_key.keys()))
except JSONDecodeError:
raise InvalidClientRequest(origin, req.reqId,
'Attribute field must be dict while adding it as a row field'.
format(TARGET_NYM))
else:
get_key = value
if get_key is None:
raise LogicError('Attribute data must be parsed')
old_value, seq_no, _, _ = self.getAttr(op[TARGET_NYM], get_key, field, isCommitted=False)
if seq_no is not None:
self.write_req_validator.validate(req,
[AuthActionEdit(txn_type=ATTRIB,
field=field,
old_value=old_value,
new_value=value,
is_owner=is_owner)])
else:
self.write_req_validator.validate(req,
[AuthActionAdd(txn_type=ATTRIB,
field=field,
value=value,
is_owner=is_owner)])
def test_pool_upgrade_cancel(write_request_validation, is_owner, req):
authorized = req.identifier == "trustee_identifier"
assert authorized == write_request_validation(req, [
AuthActionEdit(txn_type=POOL_UPGRADE,
field=ACTION,
old_value='start',
new_value='cancel',
is_owner=is_owner)
])
def test_change_trustee_to_endorser(write_request_validation, req, is_owner):
authorized = (req.identifier == "trustee_identifier")
assert authorized == write_request_validation(req, [
AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=TRUSTEE,
new_value=ENDORSER,
is_owner=is_owner)
])
def test_change_endorser_to_endorser(write_request_validation, req, is_owner):
authorized = is_owner
assert authorized == write_request_validation(req, [
AuthActionEdit(txn_type=NYM,
field=ROLE,
old_value=ENDORSER,
new_value=ENDORSER,
is_owner=is_owner)
])
def test_pool_upgrade_cancel_wrong_old_value(write_request_validation,
is_owner, req):
assert not write_request_validation(req, [
AuthActionEdit(txn_type=POOL_UPGRADE,
field=ACTION,
old_value='not_start',
new_value='cancel',
is_owner=is_owner)
])
def dynamic_validation(self, request: Request):
self._validate_request_type(request)
action = '*'
status = '*'
self.write_request_validator.validate(request,
[AuthActionEdit(txn_type=self.txn_type,
field=ACTION,
old_value=status,
new_value=action)])
def test_rev_reg_def_editing(write_request_validation, req, is_owner):
authorized = is_owner
assert authorized == write_request_validation(req, [
AuthActionEdit(txn_type=REVOC_REG_DEF,
field='some_field',
old_value='old_value',
new_value='new_value',
is_owner=is_owner)
])
