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)