def test_keypair_with_umbral_keys():
umbral_privkey = UmbralPrivateKey.gen_key()
umbral_pubkey = umbral_privkey.get_pubkey()
new_keypair_from_priv = keypairs.Keypair(umbral_privkey)
assert new_keypair_from_priv._privkey.bn_key.to_bytes(
) == umbral_privkey.bn_key.to_bytes()
assert new_keypair_from_priv.pubkey.to_bytes() == umbral_pubkey.to_bytes()
new_keypair_from_pub = keypairs.Keypair(public_key=umbral_pubkey)
assert new_keypair_from_pub.pubkey.to_bytes() == umbral_pubkey.to_bytes()
assert new_keypair_from_pub._privkey == PUBLIC_ONLY
def test_address(testerchain, signature_verifier):
# Generate Umbral key and extract "address" from the public key
umbral_privkey = UmbralPrivateKey.gen_key()
umbral_pubkey = umbral_privkey.get_pubkey()
umbral_pubkey_bytes = umbral_pubkey.to_bytes(is_compressed=False)[1:]
signer_address = keccak_digest(umbral_pubkey_bytes)
signer_address = to_normalized_address(signer_address[12:])
# Check extracting address in library
result_address = signature_verifier.functions.toAddress(
umbral_pubkey_bytes).call()
assert signer_address == to_normalized_address(result_address)
def test_umbral_key_to_cryptography_keys():
umbral_priv_key = UmbralPrivateKey.gen_key()
umbral_pub_key = umbral_priv_key.get_pubkey()
crypto_privkey = umbral_priv_key.to_cryptography_privkey()
assert int(umbral_priv_key.bn_key) == crypto_privkey.private_numbers(
).private_value
crypto_pubkey = umbral_pub_key.to_cryptography_pubkey()
umbral_affine = umbral_pub_key.point_key.to_affine()
x, y = crypto_pubkey.public_numbers().x, crypto_pubkey.public_numbers().y
assert umbral_affine == (x, y)
def test_cannot_set_different_keys():
"""
Once a key is set on a Capsule, it can't be changed to a different key.
"""
params = default_params()
capsule = Capsule(params,
point_e=Point.gen_rand(),
point_v=Point.gen_rand(),
bn_sig=CurveBN.gen_rand())
capsule.set_correctness_keys(
delegating=UmbralPrivateKey.gen_key().get_pubkey(),
receiving=UmbralPrivateKey.gen_key().get_pubkey(),
verifying=UmbralPrivateKey.gen_key().get_pubkey())
with pytest.raises(ValueError):
capsule.set_correctness_keys(
delegating=UmbralPrivateKey.gen_key().get_pubkey())
with pytest.raises(ValueError):
capsule.set_correctness_keys(
receiving=UmbralPrivateKey.gen_key().get_pubkey())
with pytest.raises(ValueError):
capsule.set_correctness_keys(
verifying=UmbralPrivateKey.gen_key().get_pubkey())
def test_recover(testerchain, signature_verifier):
message = os.urandom(100)
# Prepare message hash
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(message)
message_hash = hash_ctx.finalize()
# Generate Umbral key and extract "address" from the public key
umbral_privkey = UmbralPrivateKey.gen_key()
umbral_pubkey_bytes = umbral_privkey.get_pubkey().to_bytes(is_compressed=False)
signer_address = bytearray(testerchain.interface.w3.solidityKeccak(['bytes32'], [umbral_pubkey_bytes[1:]]))
signer_address = to_normalized_address(signer_address[12:])
# Sign message using SHA-256 hash (because only 32 bytes hash can be used in the `ecrecover` method)
cryptography_priv_key = umbral_privkey.to_cryptography_privkey()
signature_der_bytes = cryptography_priv_key.sign(message, ec.ECDSA(hashes.SHA256()))
signature = Signature.from_bytes(signature_der_bytes, der_encoded=True)
# Get recovery id (v) before using contract
# If we don't have recovery id while signing than we should try to recover public key with different v
# Only the correct v will match the correct public key
# First try v = 0
recoverable_signature = bytes(signature) + bytes([0])
pubkey_bytes = coincurve.PublicKey.from_signature_and_message(recoverable_signature, message_hash, hasher=None)\
.format(compressed=False)
if pubkey_bytes != umbral_pubkey_bytes:
# Extracted public key is not ours, that means v = 1
recoverable_signature = bytes(signature) + bytes([1])
pubkey_bytes = coincurve.PublicKey.from_signature_and_message(recoverable_signature, message_hash, hasher=None)\
.format(compressed=False)
# Check that recovery was ok
assert umbral_pubkey_bytes == pubkey_bytes
# Check recovery method in the contract
assert signer_address == to_normalized_address(
signature_verifier.functions.recover(message_hash, recoverable_signature).call())
# Also numbers 27 and 28 can be used for v
recoverable_signature = recoverable_signature[0:-1] + bytes([recoverable_signature[-1] + 27])
assert signer_address == to_normalized_address(
signature_verifier.functions.recover(message_hash, recoverable_signature).call())
# Only number 0,1,27,28 are supported for v
recoverable_signature = bytes(signature) + bytes([2])
with pytest.raises((TransactionFailed, ValueError)):
signature_verifier.functions.recover(message_hash, recoverable_signature).call()
# Signature must include r, s and v
recoverable_signature = bytes(signature)
with pytest.raises((TransactionFailed, ValueError)):
signature_verifier.functions.recover(message_hash, recoverable_signature).call()
def generate_doctor_keys(username):
enc_privkey = UmbralPrivateKey.gen_key()
sig_privkey = UmbralPrivateKey.gen_key()
keys = {}
keys['enc'] = enc_privkey.to_bytes().hex()
keys['sig'] = sig_privkey.to_bytes().hex()
enc_pubkey = enc_privkey.get_pubkey()
sig_pubkey = sig_privkey.get_pubkey()
doctor_pubkeys = {
'enc': enc_pubkey.to_bytes().hex(),
'sig': sig_pubkey.to_bytes().hex()
}
BOB_PUBLIC_KEYS = os.path.join(os.getcwd(), 'bob/' + username + '.json')
with open(BOB_PUBLIC_KEYS, 'w') as f:
json.dump(doctor_pubkeys, f)
return json.dumps(keys)
def test_enrico_encrypt(click_runner):
policy_encrypting_key = UmbralPrivateKey.gen_key().get_pubkey().to_bytes(
).hex()
encrypt_args = ('enrico', 'encrypt', '--message', 'to be or not to be',
'--policy-encrypting-key', policy_encrypting_key)
result = click_runner.invoke(nucypher_cli,
encrypt_args,
catch_exceptions=False)
assert result.exit_code == 0
assert policy_encrypting_key in result.output
assert "message_kit" in result.output
assert "signature" in result.output
def test_keypair_with_umbral_keys():
umbral_privkey = UmbralPrivateKey.gen_key()
umbral_pubkey = umbral_privkey.get_pubkey()
new_keypair_from_priv = keypairs.Keypair(umbral_privkey)
assert new_keypair_from_priv._privkey.bn_key.to_bytes(
) == umbral_privkey.bn_key.to_bytes()
assert new_keypair_from_priv.pubkey.to_bytes() == umbral_pubkey.to_bytes()
new_keypair_from_pub = keypairs.Keypair(umbral_pubkey)
assert new_keypair_from_pub.pubkey.to_bytes() == umbral_pubkey.to_bytes()
with pytest.raises(AttributeError):
new_keypair_from_pub._privkey
def test_signature_rs_serialization():
privkey = UmbralPrivateKey.gen_key()
message = b"peace at dawn"
der_sig_bytes = ecdsa_sign(message, privkey)
signature_from_der = Signature.from_bytes(der_sig_bytes, der_encoded=True)
rs_sig_bytes = bytes(signature_from_der)
assert len(rs_sig_bytes) == 64
signature_from_rs = Signature.from_bytes(rs_sig_bytes, der_encoded=False)
assert signature_from_rs == signature_from_der
assert signature_from_rs == der_sig_bytes
assert signature_from_rs.verify(message, privkey.get_pubkey())
def test_generate_alice_keyring(tmpdir):
password = '******' * 16
keyring = NucypherKeyring.generate(password=password,
encrypting=True,
wallet=False,
rest=False,
keyring_root=tmpdir)
enc_pubkey = keyring.encrypting_public_key
assert enc_pubkey is not None
with pytest.raises(NucypherKeyring.KeyringLocked):
_dec_keypair = keyring.derive_crypto_power(DecryptingPower).keypair
keyring.unlock(password)
dec_keypair = keyring.derive_crypto_power(DecryptingPower).keypair
assert enc_pubkey == dec_keypair.pubkey
label = b'test'
delegating_power = keyring.derive_crypto_power(DelegatingPower)
delegating_pubkey = delegating_power.get_pubkey_from_label(label)
bob_pubkey = UmbralPrivateKey.gen_key().get_pubkey()
signer = Signer(UmbralPrivateKey.gen_key())
delegating_pubkey_again, _kfrags = delegating_power.generate_kfrags(
bob_pubkey, signer, label, m=2, n=3)
assert delegating_pubkey == delegating_pubkey_again
another_delegating_power = keyring.derive_crypto_power(DelegatingPower)
another_delegating_pubkey = another_delegating_power.get_pubkey_from_label(
label)
assert delegating_pubkey == another_delegating_pubkey
def test_recover(testerchain, signature_verifier):
message = os.urandom(100)
# Prepare message hash
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(message)
message_hash = hash_ctx.finalize()
# Generate Umbral key and extract "address" from the public key
umbral_privkey = UmbralPrivateKey.gen_key()
umbral_pubkey = umbral_privkey.get_pubkey()
umbral_pubkey_bytes = umbral_privkey.get_pubkey().to_bytes(
is_compressed=False)
signer_address = keccak_digest(umbral_pubkey_bytes[1:])
signer_address = to_normalized_address(signer_address[12:])
# Sign message
signer = Signer(umbral_privkey)
signature = signer(message)
# Get recovery id (v) before using contract
# If we don't have recovery id while signing then we should try to recover public key with different v
# Only the correct v will match the correct public key
v = get_signature_recovery_value(message, signature, umbral_pubkey)
recoverable_signature = bytes(signature) + v
# Check recovery method in the contract
assert signer_address == to_normalized_address(
signature_verifier.functions.recover(message_hash,
recoverable_signature).call())
# Also numbers 27 and 28 can be used for v
recoverable_signature = recoverable_signature[:-1] + bytes(
[recoverable_signature[-1] + 27])
assert signer_address == to_normalized_address(
signature_verifier.functions.recover(message_hash,
recoverable_signature).call())
# Only number 0,1,27,28 are supported for v
recoverable_signature = bytes(signature) + bytes([2])
with pytest.raises((TransactionFailed, ValueError)):
signature_verifier.functions.recover(message_hash,
recoverable_signature).call()
# Signature must include r, s and v
recoverable_signature = bytes(signature)
with pytest.raises((TransactionFailed, ValueError)):
signature_verifier.functions.recover(message_hash,
recoverable_signature).call()
def test_prehashed_message(execution_number):
privkey = UmbralPrivateKey.gen_key()
pubkey = privkey.get_pubkey()
signer = Signer(private_key=privkey)
message = b"peace at dawn"
hash_function = hashes.Hash(DEFAULT_HASH_ALGORITHM(), backend=backend)
hash_function.update(message)
prehashed_message = hash_function.finalize()
signature = signer(message=prehashed_message, is_prehashed=True)
assert signature.verify(message=prehashed_message,
verifying_key=pubkey,
is_prehashed=True)
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 test_generate_alice_keyring(tmpdir):
keyring = NucypherKeyring.generate(checksum_address=FEDERATED_ADDRESS,
password=INSECURE_DEVELOPMENT_PASSWORD,
encrypting=True,
rest=False,
keyring_root=tmpdir)
enc_pubkey = keyring.encrypting_public_key
assert enc_pubkey is not None
with pytest.raises(NucypherKeyring.KeyringLocked):
_dec_keypair = keyring.derive_crypto_power(DecryptingPower).keypair
keyring.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
dec_keypair = keyring.derive_crypto_power(DecryptingPower).keypair
assert enc_pubkey == dec_keypair.pubkey
label = b'test'
delegating_power = keyring.derive_crypto_power(DelegatingPower)
delegating_pubkey = delegating_power.get_pubkey_from_label(label)
bob_pubkey = UmbralPrivateKey.gen_key().get_pubkey()
signer = Signer(UmbralPrivateKey.gen_key())
delegating_pubkey_again, _kfrags = delegating_power.generate_kfrags(
bob_pubkey, signer, label, m=2, n=3)
assert delegating_pubkey == delegating_pubkey_again
another_delegating_power = keyring.derive_crypto_power(DelegatingPower)
another_delegating_pubkey = another_delegating_power.get_pubkey_from_label(
label)
assert delegating_pubkey == another_delegating_pubkey
def test_set_invalid_correctness_keys(alices_keys, capsule, kfrags):
"""
If the three keys do appear together, along with the capsule,
we can attach them all at once.
"""
delegating_privkey, signing_privkey = alices_keys
unrelated_receiving_pubkey = UmbralPrivateKey.gen_key().get_pubkey()
capsule.set_correctness_keys(delegating_privkey.get_pubkey(),
unrelated_receiving_pubkey,
signing_privkey.get_pubkey())
for kfrag in kfrags:
with pytest.raises(KFrag.NotValid):
cfrag = pre.reencrypt(kfrag, capsule)
def generate_accounts(w3: Web3, quantity: int) -> List[str]:
"""
Generate additional unlocked accounts transferring wei_balance to each account on creation.
"""
addresses = list()
insecure_passphrase = 'this-is-not-a-secure-password'
for _ in range(quantity):
umbral_priv_key = UmbralPrivateKey.gen_key()
address = w3.personal.importRawKey(private_key=umbral_priv_key.to_bytes(),
passphrase=insecure_passphrase)
w3.personal.unlockAccount(address, passphrase=insecure_passphrase)
addresses.append(addresses)
return addresses
def test_compute_proof_challenge_scalar(testerchain, reencryption_validator,
mock_ursula_reencrypts):
ursula_privkey = UmbralPrivateKey.gen_key()
ursula_stamp = SignatureStamp(verifying_key=ursula_privkey.pubkey,
signer=Signer(ursula_privkey))
ursula = Mock(stamp=ursula_stamp)
# Bob prepares supporting Evidence
evidence = mock_ursula_reencrypts(ursula)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
capsule_bytes = capsule.to_bytes()
cfrag_bytes = cfrag.to_bytes()
proof_challenge_scalar = int(evidence.get_proof_challenge_scalar())
computeProofChallengeScalar = reencryption_validator.functions.computeProofChallengeScalar
assert proof_challenge_scalar == computeProofChallengeScalar(
capsule_bytes, cfrag_bytes).call()
def test_ecdsa_signature_recovery(execution_number):
privkey = UmbralPrivateKey.gen_key()
pubkey = privkey.get_pubkey()
signer = Signer(private_key=privkey)
message = b"peace at dawn"
signature = signer(message=message)
assert signature.verify(message, pubkey)
v_value = 27
pubkey_bytes = recover_pubkey_from_signature(message=message,
signature=signature,
v_value_to_try=v_value)
if not pubkey_bytes == pubkey.to_bytes():
v_value = 28
pubkey_bytes = recover_pubkey_from_signature(message=message,
signature=signature,
v_value_to_try=v_value)
assert pubkey_bytes == pubkey.to_bytes()
assert bytes([v_value - 27
]) == get_signature_recovery_value(message, signature,
pubkey)
hash_function = hashes.Hash(hashes.SHA256(), backend=backend)
hash_function.update(message)
prehashed_message = hash_function.finalize()
v_value = 27
pubkey_bytes = recover_pubkey_from_signature(message=prehashed_message,
signature=signature,
v_value_to_try=v_value,
is_prehashed=True)
if not pubkey_bytes == pubkey.to_bytes():
v_value = 28
pubkey_bytes = recover_pubkey_from_signature(message=prehashed_message,
signature=signature,
v_value_to_try=v_value,
is_prehashed=True)
assert pubkey_bytes == pubkey.to_bytes()
assert bytes([v_value - 27
]) == get_signature_recovery_value(prehashed_message,
signature,
pubkey,
is_prehashed=True)
def __generate_insecure_unlocked_accounts(self, quantity: int) -> List[str]:
"""
Generate additional unlocked accounts transferring a balance to each account on creation.
"""
addresses = list()
insecure_password = INSECURE_DEVELOPMENT_PASSWORD
for _ in range(quantity):
umbral_priv_key = UmbralPrivateKey.gen_key()
address = self.interface.w3.personal.importRawKey(private_key=umbral_priv_key.to_bytes(),
passphrase=insecure_password)
assert self.interface.unlock_account(address, password=insecure_password, duration=None), 'Failed to unlock {}'.format(address)
addresses.append(address)
self._test_account_cache.append(address)
self.log.info('Generated new insecure account {}'.format(address))
return addresses
def __init__(self,
pubkey: UmbralPublicKey = None,
keypair: keypairs.Keypair = None,
generate_keys_if_needed=True) -> None:
if keypair and pubkey:
raise ValueError(
"Pass keypair or pubkey_bytes (or neither), but not both.")
elif keypair:
self.keypair = keypair
else:
# They didn't pass a keypair; we'll make one with the bytes (if any)
# they provided.
if pubkey:
key_to_pass_to_keypair = pubkey
else:
# They didn't even pass pubkey_bytes. We'll generate a keypair.
key_to_pass_to_keypair = UmbralPrivateKey.gen_key()
self.keypair = self._keypair_class(
umbral_key=key_to_pass_to_keypair)
def __init__(self,
umbral_key: Union[UmbralPrivateKey, UmbralPublicKey]=None,
generate_keys_if_needed=True):
"""
Initalizes a Keypair object with an Umbral key object.
:param umbral_key: An UmbralPrivateKey or UmbralPublicKey
:param generate_keys_if_needed: Generate keys or not?
"""
try:
self.pubkey = umbral_key.get_pubkey()
self._privkey = umbral_key
except NotImplementedError:
self.pubkey = umbral_key
except AttributeError:
# They didn't pass anything we recognize as a valid key.
if generate_keys_if_needed:
self._privkey = UmbralPrivateKey.gen_key()
self.pubkey = self._privkey.get_pubkey()
else:
raise ValueError("Either pass a valid key as umbral_key or, if you want to generate keys, set generate_keys_if_needed to True.")
def new_keypair_bytes():
privkey = UmbralPrivateKey.gen_key(params=params)
return privkey.to_bytes(), privkey.get_pubkey().to_bytes()
def test_evaluate_cfrag(testerchain, escrow, adjudicator_contract):
creator, miner, wrong_miner, investigator, *everyone_else = testerchain.interface.w3.eth.accounts
evaluation_log = adjudicator_contract.events.CFragEvaluated.createFilter(
fromBlock='latest')
worker_stake = 1000
worker_penalty_history = 0
investigator_balance = 0
number_of_evaluations = 0
# Prepare one miner
tx = escrow.functions.setMinerInfo(miner, worker_stake).transact()
testerchain.wait_for_receipt(tx)
# Generate miner's Umbral key
miner_umbral_private_key = UmbralPrivateKey.gen_key()
miner_umbral_public_key_bytes = miner_umbral_private_key.get_pubkey(
).to_bytes(is_compressed=False)
# Sign Umbral public key using eth-key
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(miner_umbral_public_key_bytes)
miner_umbral_public_key_hash = hash_ctx.finalize()
provider = testerchain.interface.provider
address = to_canonical_address(miner)
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))
# Prepare hash of the data
metadata = os.urandom(33)
capsule, cfrag = fragments(metadata)
assert cfrag.verify_correctness(capsule)
capsule_bytes = capsule.to_bytes()
cfrag_bytes = cfrag.to_bytes()
# Bob prepares supporting Evidence
evidence = IndisputableEvidence(capsule, cfrag, ursula=None)
evidence_data = evidence.precompute_values()
assert len(evidence_data) == 20 * 32 + 32 + 20 + 1
# This check is a workaround in order to test the signature validation is correct.
# In reality, this check should be part of the isCapsuleFragCorrect logic,
# but we're facing with "Stack too deep" errors at the moment.
# address = adjudicator_contract.functions.aliceAddress(cfrag_bytes, evidence_data).call()
# assert address == to_checksum_address(evidence_data[-21:-1].hex())
proof_challenge_scalar = int(evidence.get_proof_challenge_scalar())
# computeProofChallengeScalar = adjudicator_contract.functions.computeProofChallengeScalar
# assert proof_challenge_scalar == computeProofChallengeScalar(capsule_bytes, cfrag_bytes).call()
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(capsule_bytes + cfrag_bytes)
data_hash = hash_ctx.finalize()
# This capsule and cFrag are not yet evaluated
assert not adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
# Generate requester's Umbral key
requester_umbral_private_key = UmbralPrivateKey.gen_key()
requester_umbral_public_key_bytes = requester_umbral_private_key.get_pubkey(
).to_bytes(is_compressed=False)
# Sign capsule and cFrag
capsule_signature_by_requester = sign_data(capsule_bytes,
requester_umbral_private_key)
capsule_signature_by_requester_and_miner = sign_data(
capsule_signature_by_requester, miner_umbral_private_key)
cfrag_signature_by_miner = sign_data(cfrag_bytes, miner_umbral_private_key)
# Challenge using good data
args = (capsule_bytes, capsule_signature_by_requester,
capsule_signature_by_requester_and_miner, cfrag_bytes,
cfrag_signature_by_miner, requester_umbral_public_key_bytes,
miner_umbral_public_key_bytes, signed_miner_umbral_public_key,
evidence_data)
assert worker_stake == escrow.functions.minerInfo(miner).call()[0]
tx = adjudicator_contract.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
# Hash of the data is saved and miner was not slashed
assert adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
assert worker_stake == escrow.functions.minerInfo(miner).call()[0]
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert miner == event_args['miner']
assert investigator == event_args['investigator']
assert event_args['correctness']
# Test: Don't evaluate miner with data that already was checked
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(*args).transact()
testerchain.wait_for_receipt(tx)
# Test: Ursula produces incorrect proof:
metadata = os.urandom(34)
capsule, cfrag = fragments(metadata)
capsule_bytes = capsule.to_bytes()
# Corrupt proof
cfrag.proof.bn_sig = CurveBN.gen_rand(capsule.params.curve)
cfrag_bytes = cfrag.to_bytes()
assert not cfrag.verify_correctness(capsule)
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(capsule_bytes + cfrag_bytes)
data_hash = hash_ctx.finalize()
capsule_signature_by_requester = sign_data(capsule_bytes,
requester_umbral_private_key)
capsule_signature_by_requester_and_miner = sign_data(
capsule_signature_by_requester, miner_umbral_private_key)
cfrag_signature_by_miner = sign_data(cfrag_bytes, miner_umbral_private_key)
evidence = IndisputableEvidence(capsule, cfrag, ursula=None)
evidence_data = evidence.precompute_values()
args = (capsule_bytes, capsule_signature_by_requester,
capsule_signature_by_requester_and_miner, cfrag_bytes,
cfrag_signature_by_miner, requester_umbral_public_key_bytes,
miner_umbral_public_key_bytes, signed_miner_umbral_public_key,
evidence_data)
assert not adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
tx = adjudicator_contract.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
# Hash of the data is saved and miner was slashed
assert adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.minerInfo(miner).call()[0]
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert miner == event_args['miner']
assert investigator == event_args['investigator']
assert not event_args['correctness']
###############################
# Test: Bob produces wrong precomputed data
###############################
metadata = os.urandom(34)
capsule, cfrag = fragments(metadata)
capsule_bytes = capsule.to_bytes()
cfrag_bytes = cfrag.to_bytes()
assert cfrag.verify_correctness(capsule)
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(capsule_bytes + cfrag_bytes)
data_hash = hash_ctx.finalize()
capsule_signature_by_requester = sign_data(capsule_bytes,
requester_umbral_private_key)
capsule_signature_by_requester_and_miner = sign_data(
capsule_signature_by_requester, miner_umbral_private_key)
cfrag_signature_by_miner = sign_data(cfrag_bytes, miner_umbral_private_key)
evidence = IndisputableEvidence(capsule, cfrag, ursula=None)
evidence_data = evidence.precompute_values()
# Bob produces a random point and gets the bytes of coords x and y
random_point_bytes = Point.gen_rand().to_bytes(is_compressed=False)[1:]
# He uses this garbage instead of correct precomputation of z*E
evidence_data = bytearray(evidence_data)
evidence_data[32:32 + 64] = random_point_bytes
evidence_data = bytes(evidence_data)
args = (capsule_bytes, capsule_signature_by_requester,
capsule_signature_by_requester_and_miner, cfrag_bytes,
cfrag_signature_by_miner, requester_umbral_public_key_bytes,
miner_umbral_public_key_bytes, signed_miner_umbral_public_key,
evidence_data)
assert not adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
# Evaluation must fail since Bob precomputed wrong values
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
###############################
# Test: Signatures and Metadata mismatch
###############################
# TODO
###############################
# Test: Second violation. Penalty is increased
###############################
# Prepare hash of the data
metadata = os.urandom(34)
capsule, cfrag = fragments(metadata)
capsule_bytes = capsule.to_bytes()
# Corrupt proof
cfrag.proof.bn_sig = CurveBN.gen_rand(capsule.params.curve)
cfrag_bytes = cfrag.to_bytes()
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(capsule_bytes + cfrag_bytes)
data_hash = hash_ctx.finalize()
capsule_signature_by_requester = sign_data(capsule_bytes,
requester_umbral_private_key)
capsule_signature_by_requester_and_miner = sign_data(
capsule_signature_by_requester, miner_umbral_private_key)
cfrag_signature_by_miner = sign_data(cfrag_bytes, miner_umbral_private_key)
evidence = IndisputableEvidence(capsule, cfrag, ursula=None)
evidence_data = evidence.precompute_values()
args = [
capsule_bytes, capsule_signature_by_requester,
capsule_signature_by_requester_and_miner, cfrag_bytes,
cfrag_signature_by_miner, requester_umbral_public_key_bytes,
miner_umbral_public_key_bytes, signed_miner_umbral_public_key,
evidence_data
]
assert not adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
worker_stake = escrow.functions.minerInfo(miner).call()[0]
investigator_balance = escrow.functions.rewardInfo(investigator).call()
assert not adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
tx = adjudicator_contract.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
assert adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
previous_penalty = penalty
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
# Penalty was increased because it's the second violation
assert penalty == previous_penalty + PENALTY_HISTORY_COEFFICIENT
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.minerInfo(miner).call()[0]
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert miner == event_args['miner']
assert investigator == event_args['investigator']
assert not event_args['correctness']
###############################
# Test: Third violation. Penalty reaches the maximum allowed
###############################
# Prepare corrupted data again
capsule, cfrag = fragments(metadata)
capsule_bytes = capsule.to_bytes()
# Corrupt proof
cfrag.proof.bn_sig = CurveBN.gen_rand(capsule.params.curve)
cfrag_bytes = cfrag.to_bytes()
hash_ctx = hashes.Hash(hashes.SHA256(), backend=backend)
hash_ctx.update(capsule_bytes + cfrag_bytes)
data_hash = hash_ctx.finalize()
capsule_signature_by_requester = sign_data(capsule_bytes,
requester_umbral_private_key)
capsule_signature_by_requester_and_miner = sign_data(
capsule_signature_by_requester, miner_umbral_private_key)
cfrag_signature_by_miner = sign_data(cfrag_bytes, miner_umbral_private_key)
evidence = IndisputableEvidence(capsule, cfrag, ursula=None)
evidence_data = evidence.precompute_values()
args = [
capsule_bytes, capsule_signature_by_requester,
capsule_signature_by_requester_and_miner, cfrag_bytes,
cfrag_signature_by_miner, requester_umbral_public_key_bytes,
miner_umbral_public_key_bytes, signed_miner_umbral_public_key,
evidence_data
]
worker_stake = escrow.functions.minerInfo(miner).call()[0]
investigator_balance = escrow.functions.rewardInfo(investigator).call()
assert not adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
tx = adjudicator_contract.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
assert adjudicator_contract.functions.evaluatedCFrags(data_hash).call()
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
# Penalty has reached maximum available percentage of value
assert penalty == worker_stake // PERCENTAGE_PENALTY_COEFFICIENT
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.minerInfo(miner).call()[0]
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert miner == event_args['miner']
assert investigator == event_args['investigator']
assert not event_args['correctness']
#################
# Test: Invalid evaluations
##############
# Can't evaluate miner using broken signatures
wrong_args = args[:]
wrong_args[1] = capsule_signature_by_requester[1:]
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = args[:]
wrong_args[2] = capsule_signature_by_requester_and_miner[1:]
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = args[:]
wrong_args[4] = cfrag_signature_by_miner[1:]
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = args[:]
wrong_args[7] = signed_miner_umbral_public_key[1:]
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't evaluate miner using wrong keys
wrong_args = args[:]
wrong_args[5] = UmbralPrivateKey.gen_key().get_pubkey().to_bytes(
is_compressed=False)
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = args[:]
wrong_args[6] = UmbralPrivateKey.gen_key().get_pubkey().to_bytes(
is_compressed=False)
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't use signature for another data
wrong_args = args[:]
wrong_args[0] = bytes(args[0][0] + 1) + args[0][1:]
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = args[:]
wrong_args[3] = bytes(args[3][0] + 1) + args[3][1:]
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't evaluate nonexistent miner
address = to_canonical_address(wrong_miner)
sig_key = provider.ethereum_tester.backend._key_lookup[address]
signed_wrong_miner_umbral_public_key = bytes(
sig_key.sign_msg_hash(miner_umbral_public_key_hash))
wrong_args = args[:]
wrong_args[7] = signed_wrong_miner_umbral_public_key
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator_contract.functions.evaluateCFrag(
*wrong_args).transact()
testerchain.wait_for_receipt(tx)
def test_validate_cfrag(testerchain, reencryption_validator,
mock_ursula_reencrypts):
ursula_privkey = UmbralPrivateKey.gen_key()
ursula_stamp = SignatureStamp(verifying_key=ursula_privkey.pubkey,
signer=Signer(ursula_privkey))
ursula = Mock(stamp=ursula_stamp)
###############################
# Test: Ursula produces correct proof:
###############################
# Bob prepares supporting Evidence
evidence = mock_ursula_reencrypts(ursula)
evidence_data = evidence.precompute_values()
assert len(evidence_data) == 20 * 32 + 32 + 20 + 5
# Challenge using good data
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
capsule_bytes = capsule.to_bytes()
cfrag_bytes = cfrag.to_bytes()
args = (capsule_bytes, cfrag_bytes, evidence_data)
assert reencryption_validator.functions.validateCFrag(*args).call()
###############################
# Test: Ursula produces incorrect proof:
###############################
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=True)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
capsule_bytes = capsule.to_bytes()
cfrag_bytes = cfrag.to_bytes()
assert not cfrag.verify_correctness(capsule)
evidence_data = evidence.precompute_values()
args = (capsule_bytes, cfrag_bytes, evidence_data)
assert not reencryption_validator.functions.validateCFrag(*args).call()
###############################
# Test: Bob produces wrong precomputed data
###############################
evidence = mock_ursula_reencrypts(ursula)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
capsule_bytes = capsule.to_bytes()
cfrag_bytes = cfrag.to_bytes()
assert cfrag.verify_correctness(capsule)
evidence_data = evidence.precompute_values()
# Bob produces a random point and gets the bytes of coords x and y
random_point_bytes = Point.gen_rand().to_bytes(is_compressed=False)[1:]
# He uses this garbage instead of correct precomputation of z*E
evidence_data = bytearray(evidence_data)
evidence_data[32:32 + 64] = random_point_bytes
evidence_data = bytes(evidence_data)
args = (capsule_bytes, cfrag_bytes, evidence_data)
# Evaluation must fail since Bob precomputed wrong values
with pytest.raises(TransactionFailed):
_ = reencryption_validator.functions.validateCFrag(*args).call()
def test_evaluate_cfrag(testerchain, escrow, adjudicator, token_economics,
blockchain_ursulas, mock_ursula_reencrypts):
ursula = list(blockchain_ursulas)[0]
creator, non_staker, investigator, *everyone_else = testerchain.client.accounts
evaluation_log = adjudicator.events.CFragEvaluated.createFilter(
fromBlock='latest')
verdict_log = adjudicator.events.IncorrectCFragVerdict.createFilter(
fromBlock='latest')
worker_stake = 1000
worker_penalty_history = 0
investigator_balance = 0
number_of_evaluations = 0
def compute_penalty_and_reward(stake: int,
penalty_history: int) -> Tuple[int, int]:
penalty_ = token_economics.base_penalty
penalty_ += token_economics.penalty_history_coefficient * penalty_history
penalty_ = min(penalty_,
stake // token_economics.percentage_penalty_coefficient)
reward_ = penalty_ // token_economics.reward_coefficient
return penalty_, reward_
# Prepare one staker
staker = ursula.checksum_address
tx = escrow.functions.setStakerInfo(staker, worker_stake,
ursula.worker_address).transact()
testerchain.wait_for_receipt(tx)
assert ursula._stamp_has_valid_signature_by_worker()
# Prepare evaluation data
evidence = mock_ursula_reencrypts(ursula)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert cfrag.verify_correctness(capsule)
evidence_data = evidence.precompute_values()
assert len(evidence_data) == 20 * 32 + 32 + 20 + 5
data_hash = sha256_digest(capsule, cfrag)
# This capsule and cFrag are not yet evaluated
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
args = list(evidence.evaluation_arguments())
# Challenge using good data
assert worker_stake == escrow.functions.getAllTokens(staker).call()
tx = adjudicator.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
# Hash of the data is saved and staker was not slashed
assert adjudicator.functions.evaluatedCFrags(data_hash).call()
assert worker_stake == escrow.functions.getAllTokens(staker).call()
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert investigator == event_args['investigator']
assert event_args['correctness']
assert 0 == len(verdict_log.get_all_entries())
###############################
# Test: Don't evaluate staker with data that already was checked
###############################
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*args).transact()
testerchain.wait_for_receipt(tx)
###############################
# Test: Ursula produces incorrect proof:
###############################
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=True)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert not cfrag.verify_correctness(capsule)
args = list(evidence.evaluation_arguments())
data_hash = sha256_digest(capsule, cfrag)
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
tx = adjudicator.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
# Hash of the data is saved and staker was slashed
assert adjudicator.functions.evaluatedCFrags(data_hash).call()
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.getAllTokens(staker).call()
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert investigator == event_args['investigator']
assert not event_args['correctness']
events = verdict_log.get_all_entries()
assert number_of_evaluations - 1 == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert ursula.worker_address == event_args['worker']
assert staker == event_args['staker']
###############################
# Test: Bob produces wrong precomputed data
###############################
evidence = mock_ursula_reencrypts(ursula)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert cfrag.verify_correctness(capsule)
# Bob produces a random point and gets the bytes of coords x and y
random_point_bytes = Point.gen_rand().to_bytes(is_compressed=False)[1:]
# He uses this garbage instead of correct precomputation of z*E
evidence_data = bytearray(evidence_data)
evidence_data[32:32 + 64] = random_point_bytes
evidence_data = bytes(evidence_data)
args = list(evidence.evaluation_arguments())
args[-1] = evidence_data
data_hash = sha256_digest(capsule, cfrag)
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
# Evaluation must fail since Bob precomputed wrong values
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
###############################
# Test: Second violation. Penalty is increased
###############################
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=True)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert not cfrag.verify_correctness(capsule)
args = list(evidence.evaluation_arguments())
data_hash = sha256_digest(capsule, cfrag)
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
worker_stake = escrow.functions.getAllTokens(staker).call()
investigator_balance = escrow.functions.rewardInfo(investigator).call()
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
tx = adjudicator.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
assert adjudicator.functions.evaluatedCFrags(data_hash).call()
previous_penalty = penalty
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
# Penalty was increased because it's the second violation
assert penalty == previous_penalty + token_economics.penalty_history_coefficient
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.getAllTokens(staker).call()
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert investigator == event_args['investigator']
assert not event_args['correctness']
events = verdict_log.get_all_entries()
assert number_of_evaluations - 1 == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert ursula.worker_address == event_args['worker']
assert staker == event_args['staker']
###############################
# Test: Third violation. Penalty reaches the maximum allowed
###############################
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=True)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert not cfrag.verify_correctness(capsule)
args = list(evidence.evaluation_arguments())
data_hash = sha256_digest(capsule, cfrag)
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
worker_stake = escrow.functions.getAllTokens(staker).call()
investigator_balance = escrow.functions.rewardInfo(investigator).call()
tx = adjudicator.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
assert adjudicator.functions.evaluatedCFrags(data_hash).call()
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
# Penalty has reached maximum available percentage of value
assert penalty == worker_stake // token_economics.percentage_penalty_coefficient
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.getAllTokens(staker).call()
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert investigator == event_args['investigator']
assert not event_args['correctness']
events = verdict_log.get_all_entries()
assert number_of_evaluations - 1 == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert ursula.worker_address == event_args['worker']
assert staker == event_args['staker']
#################
# Test: Invalid evaluations
##############
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=True)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert not cfrag.verify_correctness(capsule)
args = list(evidence.evaluation_arguments())
data_hash = sha256_digest(capsule, cfrag)
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
# Can't evaluate staker using broken signatures
wrong_args = list(args)
wrong_args[2] = evidence.task.cfrag_signature[1:]
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = list(args)
wrong_args[3] = evidence.task.signature[1:]
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = list(args)
wrong_args[7] = wrong_args[7][1:]
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't evaluate staker using wrong keys
wrong_args = list(args)
wrong_args[5] = UmbralPrivateKey.gen_key().get_pubkey().to_bytes(
is_compressed=False)[1:]
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
wrong_args = list(args)
wrong_args[6] = UmbralPrivateKey.gen_key().get_pubkey().to_bytes(
is_compressed=False)[1:]
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't use signature for another data
wrong_args = list(args)
wrong_args[1] = os.urandom(len(bytes(cfrag)))
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't evaluate nonexistent staker
signed_stamp = testerchain.client.sign_message(account=non_staker,
message=bytes(ursula.stamp))
wrong_args = list(args)
wrong_args[7] = signed_stamp
with pytest.raises(TransactionFailed):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# Can't evaluate staker without tokens
tx = escrow.functions.setStakerInfo(non_staker, 0,
ursula.worker_address).transact()
testerchain.wait_for_receipt(tx)
with pytest.raises((TransactionFailed, ValueError)):
tx = adjudicator.functions.evaluateCFrag(*wrong_args).transact()
testerchain.wait_for_receipt(tx)
# If the non-staker starts to stake, then she can be slashed
new_staker = non_staker
tx = escrow.functions.setStakerInfo(new_staker, worker_stake,
ursula.worker_address).transact()
testerchain.wait_for_receipt(tx)
evidence = mock_ursula_reencrypts(ursula, corrupt_cfrag=True)
capsule = evidence.task.capsule
cfrag = evidence.task.cfrag
assert not cfrag.verify_correctness(capsule)
args = list(evidence.evaluation_arguments())
data_hash = sha256_digest(capsule, cfrag)
assert not adjudicator.functions.evaluatedCFrags(data_hash).call()
tx = adjudicator.functions.evaluateCFrag(*args).transact(
{'from': investigator})
testerchain.wait_for_receipt(tx)
number_of_evaluations += 1
assert adjudicator.functions.evaluatedCFrags(data_hash).call()
penalty, reward = compute_penalty_and_reward(worker_stake,
worker_penalty_history)
worker_stake -= penalty
investigator_balance += reward
worker_penalty_history += 1
assert worker_stake == escrow.functions.getAllTokens(new_staker).call()
assert investigator_balance == escrow.functions.rewardInfo(
investigator).call()
events = evaluation_log.get_all_entries()
assert number_of_evaluations == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert investigator == event_args['investigator']
assert not event_args['correctness']
events = verdict_log.get_all_entries()
assert number_of_evaluations - 1 == len(events)
event_args = events[-1]['args']
assert data_hash == event_args['evaluationHash']
assert ursula.worker_address == event_args['worker']
assert new_staker == event_args['staker']
def _generate_signing_keys() -> Tuple[UmbralPrivateKey, UmbralPublicKey]:
"""
"""
privkey = UmbralPrivateKey.gen_key()
pubkey = privkey.get_pubkey()
return privkey, pubkey
alice_config = AliceConfiguration(
config_root=os.path.join(TEMP_ALICE_DIR),
domains={TEMPORARY_DOMAIN},
known_nodes={ursula},
start_learning_now=False,
federated_only=True,
learn_on_same_thread=True,
)
alice_config.initialize(password=passphrase)
alice_config.keyring.unlock(password=passphrase)
alicia = alice_config.produce()
# We will save Alicia’s config to a file for later use
alice_config_file = alice_config.to_configuration_file()
# Let’s get to learn about the NuCypher network
alicia.start_learning_loop(now=True)
enc_privkey = UmbralPrivateKey.gen_key()
sig_privkey = UmbralPrivateKey.gen_key()
print(enc_privkey.to_bytes().hex())
print(enc_privkey.get_pubkey().to_bytes().hex())
verifying_key = UmbralPublicKey.from_hex(enc_privkey.get_pubkey().to_bytes().hex()),
encrypting_key = UmbralPublicKey.from_hex(sig_privkey.get_pubkey().to_bytes().hex())
label = "QmVahkTzLmU88CayjyZrRvqX78BmjjqH4iW26tNPvYQ18M"
label = label.encode()
policy_pubkey = alicia.get_policy_encrypting_key_from_label(label)
print("The policy public key for "
"label '{}' is {}".format(label.decode("utf-8"), policy_pubkey.to_bytes().hex()))
def _generate_encryption_keys() -> Tuple[UmbralPrivateKey, UmbralPublicKey]:
"""Use pyUmbral keys to generate a new encrypting key pair"""
privkey = UmbralPrivateKey.gen_key()
pubkey = privkey.get_pubkey()
return privkey, pubkey
except FileExistsError:
pass
# If True, this will overwrite existing test vector files with new randomly generated instances
generate_again = False
#########
# SETUP #
#########
set_default_curve()
params = default_params()
curve = params.curve
# We create also some Umbral objects for later
delegating_privkey = UmbralPrivateKey.gen_key(params=params)
receiving_privkey = UmbralPrivateKey.gen_key(params=params)
signing_privkey = UmbralPrivateKey.gen_key(params=params)
verifying_key = signing_privkey.get_pubkey()
delegating_key = delegating_privkey.get_pubkey()
receiving_key = receiving_privkey.get_pubkey()
signer = Signer(signing_privkey)
kfrags = pre.generate_kfrags(delegating_privkey=delegating_privkey,
receiving_pubkey=receiving_key,
threshold=6,
N=10,
signer=signer,
)
def test_signature_can_verify():
privkey = UmbralPrivateKey.gen_key()
message = b"attack at dawn"
der_sig_bytes = ecdsa_sign(message, privkey)
signature = Signature.from_bytes(der_sig_bytes, der_encoded=True)
assert signature.verify(message, privkey.get_pubkey())
