def evaluation_arguments(self) -> Tuple:
return (bytes(self.task.capsule),
bytes(self.task.cfrag),
bytes(self.task.cfrag_signature),
bytes(self.task.signature),
get_coordinates_as_bytes(self.bob_verifying_key),
get_coordinates_as_bytes(self.ursula_pubkey),
bytes(self.ursula_identity_evidence),
self.precompute_values()
)
def evaluation_arguments(self) -> Tuple:
return (
bytes(self.task.capsule),
bytes(self.task.cfrag),
bytes(self.task.cfrag_signature),
bytes(self.task.signature),
get_coordinates_as_bytes(self.bob_pubkey),
get_coordinates_as_bytes(self.ursula_pubkey),
None, # FIXME: bytes memory _minerPublicKeySignature #962
self.precompute_values())
def test_coordinates_as_bytes():
pubkey = UmbralPrivateKey.gen_key().pubkey
point = pubkey.point_key
stamp = SignatureStamp(verifying_key=pubkey)
x, y = point.to_affine()
x = x.to_bytes(32, 'big')
y = y.to_bytes(32, 'big')
for p in (point, pubkey, stamp):
assert get_coordinates_as_bytes(p) == x + y
assert get_coordinates_as_bytes(p, x_coord=False) == y
assert get_coordinates_as_bytes(p, y_coord=False) == x
with pytest.raises(ValueError):
_ = get_coordinates_as_bytes(p, x_coord=False, y_coord=False)
def generate_args_for_slashing(testerchain,
ursula,
account,
corrupt_cfrag: bool = True):
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=corrupt_cfrag)
# Sign Umbral public key using eth-key
miner_umbral_public_key_hash = sha256_hash(
get_coordinates_as_bytes(ursula.stamp))
provider = testerchain.interface.provider
address = to_canonical_address(account)
sig_key = provider.ethereum_tester.backend._key_lookup[address]
signed_miner_umbral_public_key = bytes(
sig_key.sign_msg_hash(miner_umbral_public_key_hash))
args = list(evidence.evaluation_arguments())
args[-2] = signed_miner_umbral_public_key # FIXME #962
return args
def precompute_values(self) -> bytes:
capsule = self.task.capsule
cfrag = self.task.cfrag
umbral_params = default_params()
e, v, _ = capsule.components()
e1 = cfrag.point_e1
v1 = cfrag.point_v1
e2 = cfrag.proof.point_e2
v2 = cfrag.proof.point_v2
u = umbral_params.u
u1 = cfrag.proof.point_kfrag_commitment
u2 = cfrag.proof.point_kfrag_pok
metadata = cfrag.proof.metadata
h = self.get_proof_challenge_scalar()
e1h = h * e1
v1h = h * v1
u1h = h * u1
z = cfrag.proof.bn_sig
ez = z * e
vz = z * v
uz = z * u
only_y_coord = dict(x_coord=False, y_coord=True)
# E points
e_y = get_coordinates_as_bytes(e, **only_y_coord)
ez_xy = get_coordinates_as_bytes(ez)
e1_y = get_coordinates_as_bytes(e1, **only_y_coord)
e1h_xy = get_coordinates_as_bytes(e1h)
e2_y = get_coordinates_as_bytes(e2, **only_y_coord)
# V points
v_y = get_coordinates_as_bytes(v, **only_y_coord)
vz_xy = get_coordinates_as_bytes(vz)
v1_y = get_coordinates_as_bytes(v1, **only_y_coord)
v1h_xy = get_coordinates_as_bytes(v1h)
v2_y = get_coordinates_as_bytes(v2, **only_y_coord)
# U points
uz_xy = get_coordinates_as_bytes(uz)
u1_y = get_coordinates_as_bytes(u1, **only_y_coord)
u1h_xy = get_coordinates_as_bytes(u1h)
u2_y = get_coordinates_as_bytes(u2, **only_y_coord)
# Get hashed KFrag validity message
hash_function = hashes.Hash(hashes.SHA256(), backend=backend)
kfrag_id = cfrag.kfrag_id
precursor = cfrag.point_precursor
delegating_pubkey = self.delegating_pubkey
receiving_pubkey = self.receiving_pubkey
validity_input = (kfrag_id, delegating_pubkey, receiving_pubkey, u1, precursor)
kfrag_validity_message = bytes().join(bytes(item) for item in validity_input)
hash_function.update(kfrag_validity_message)
hashed_kfrag_validity_message = hash_function.finalize()
# Get KFrag signature's v value
kfrag_signature_v = get_signature_recovery_value(message=hashed_kfrag_validity_message,
signature=cfrag.proof.kfrag_signature,
public_key=self.verifying_pubkey,
is_prehashed=True)
cfrag_signature_v = get_signature_recovery_value(message=bytes(cfrag),
signature=self.task.cfrag_signature,
public_key=self.ursula_pubkey)
metadata_signature_v = get_signature_recovery_value(message=self.task.signature,
signature=metadata,
public_key=self.ursula_pubkey)
specification = self.task.get_specification(ursula_pubkey=self.ursula_pubkey,
alice_address=self.alice_address,
blockhash=self.blockhash,
ursula_identity_evidence=self.ursula_identity_evidence)
specification_signature_v = get_signature_recovery_value(message=specification,
signature=self.task.signature,
public_key=self.bob_verifying_key)
ursula_pubkey_prefix_byte = bytes(self.ursula_pubkey)[0:1]
# Bundle everything together
pieces = (
e_y, ez_xy, e1_y, e1h_xy, e2_y,
v_y, vz_xy, v1_y, v1h_xy, v2_y,
uz_xy, u1_y, u1h_xy, u2_y,
hashed_kfrag_validity_message,
self.alice_address,
# The following single-byte values are interpreted as a single bytes5 variable by the Solidity contract
kfrag_signature_v,
cfrag_signature_v,
metadata_signature_v,
specification_signature_v,
ursula_pubkey_prefix_byte,
)
return b''.join(pieces)
