mirror of https://github.com/nucypher/nucypher.git
158 lines
6.5 KiB
Python
158 lines
6.5 KiB
Python
import asyncio
|
|
|
|
import pytest
|
|
from kademlia.utils import digest
|
|
|
|
from nucypher.crypto.api import keccak_digest
|
|
from tests.utilities import MockRestMiddleware
|
|
|
|
|
|
@pytest.mark.usefixtures('testerchain')
|
|
def test_all_ursulas_know_about_all_other_ursulas(ursulas, three_agents):
|
|
"""
|
|
Once launched, all Ursulas know about - and can help locate - all other Ursulas in the network.
|
|
"""
|
|
token_agent, miner_agent, policy_agent = three_agents
|
|
|
|
ignorance = []
|
|
for acounter, announcing_ursula in enumerate(miner_agent.swarm()):
|
|
for counter, propagating_ursula in enumerate(ursulas):
|
|
announcing_ursula_ether_address, announcing_ursula_id = announcing_ursula
|
|
if not digest(bytes(announcing_ursula_id)) in propagating_ursula.server.storage:
|
|
ignorance.append((counter, acounter))
|
|
if ignorance:
|
|
pytest.fail(str(["{} didn't know about {}".format(counter, acounter) for counter, acounter in ignorance]))
|
|
|
|
|
|
def test_vladimir_illegal_interface_key_does_not_propagate(ursulas):
|
|
"""
|
|
Although Ursulas propagate each other's interface information, as demonstrated above, they do not propagate
|
|
interface information for Vladimir, an Evil Ursula.
|
|
"""
|
|
ursulas = list(ursulas)
|
|
vladimir, ursula = ursulas[0], ursulas[1]
|
|
|
|
# Ursula hasn't seen any illegal keys.
|
|
assert ursula.dht_server.protocol.illegal_keys_seen == []
|
|
|
|
# Vladimir does almost everything right....
|
|
value = vladimir.interface_info_with_metadata()
|
|
|
|
# Except he sets an illegal key for his interface.
|
|
illegal_key = b"Not allowed to set arbitrary key for this."
|
|
setter = vladimir.dht_server.set(key=illegal_key, value=value)
|
|
loop = asyncio.get_event_loop()
|
|
loop.run_until_complete(setter)
|
|
|
|
# Now Ursula has seen an illegal key.
|
|
assert digest(illegal_key) in ursula.dht_server.protocol.illegal_keys_seen
|
|
|
|
|
|
@pytest.mark.skip("What do we want this test to do now?")
|
|
def test_alice_finds_ursula_via_rest(alice, ursulas):
|
|
# Imagine alice knows of nobody.
|
|
alice._known_nodes = {}
|
|
|
|
some_ursula_interface = ursulas.pop().rest_interface
|
|
|
|
new_nodes = alice.learn_from_teacher_node()
|
|
|
|
assert len(new_nodes) == len(ursulas)
|
|
|
|
for ursula in ursulas:
|
|
assert ursula.stamp.as_umbral_pubkey() in new_nodes
|
|
|
|
|
|
def test_alice_creates_policy_with_correct_hrac(idle_federated_policy):
|
|
"""
|
|
Alice creates a Policy. It has the proper HRAC, unique per her, Bob, and the uri (resource_id).
|
|
"""
|
|
alice = idle_federated_policy.alice
|
|
bob = idle_federated_policy.bob
|
|
|
|
assert idle_federated_policy.hrac() == keccak_digest(
|
|
bytes(alice.stamp) + bytes(bob.stamp) + idle_federated_policy.label)
|
|
|
|
|
|
def test_alice_sets_treasure_map(enacted_federated_policy, ursulas):
|
|
"""
|
|
Having enacted all the policies of a PolicyGroup, Alice creates a TreasureMap and sends it to Ursula via the DHT.
|
|
"""
|
|
networky_stuff = MockRestMiddleware()
|
|
enacted_federated_policy.publish_treasure_map(network_middleare=networky_stuff)
|
|
|
|
treasure_map_as_set_on_network = list(ursulas)[0].treasure_maps[
|
|
digest(enacted_federated_policy.treasure_map.public_id())]
|
|
assert treasure_map_as_set_on_network == enacted_federated_policy.treasure_map
|
|
|
|
|
|
@pytest.mark.skip("Needs cleanup.")
|
|
def test_treasure_map_with_bad_id_does_not_propagate(idle_federated_policy, ursulas):
|
|
"""
|
|
In order to prevent spam attacks, Ursula refuses to propagate a TreasureMap whose PolicyGroup ID does not comport to convention.
|
|
"""
|
|
illegal_policygroup_id = b"This is not a conventional policygroup id"
|
|
alice = idle_federated_policy.alice
|
|
bob = idle_federated_policy.bob
|
|
treasure_map = idle_federated_policy.treasure_map
|
|
|
|
message_kit, signature = alice.encrypt_for(bob, treasure_map.packed_payload())
|
|
|
|
alice.network_middleware.put_treasure_map_on_node(node=ursulas[1],
|
|
map_id=illegal_policygroup_id,
|
|
map_payload=message_kit.to_bytes())
|
|
|
|
# setter = alice.server.set(illegal_policygroup_id, message_kit.to_bytes())
|
|
# _set_event = TEST_EVENT_LOOP.run_until_complete(setter)
|
|
|
|
# with pytest.raises(KeyError):
|
|
# _ = ursulas_on_network[0].server.storage[digest(illegal_policygroup_id)]
|
|
assert False
|
|
|
|
|
|
def test_treasure_map_stored_by_ursula_is_the_correct_one_for_bob(alice, bob, ursulas, enacted_federated_policy):
|
|
"""
|
|
The TreasureMap given by Alice to Ursula is the correct one for Bob; he can decrypt and read it.
|
|
"""
|
|
treasure_map_as_set_on_network = list(ursulas)[0].treasure_maps[
|
|
digest(enacted_federated_policy.treasure_map.public_id())]
|
|
|
|
hrac_by_bob = bob.construct_policy_hrac(alice.stamp, enacted_federated_policy.label)
|
|
assert enacted_federated_policy.hrac() == hrac_by_bob
|
|
|
|
map_id_by_bob = bob.construct_map_id(alice.stamp, enacted_federated_policy.label)
|
|
assert map_id_by_bob == treasure_map_as_set_on_network.public_id()
|
|
|
|
|
|
def test_bob_can_retreive_the_treasure_map_and_decrypt_it(enacted_federated_policy, ursulas):
|
|
"""
|
|
Above, we showed that the TreasureMap saved on the network is the correct one for Bob. Here, we show
|
|
that Bob can retrieve it with only the information about which he is privy pursuant to the PolicyGroup.
|
|
"""
|
|
bob = enacted_federated_policy.bob
|
|
|
|
# Of course, in the real world, Bob has sufficient information to reconstitute a PolicyGroup, gleaned, we presume,
|
|
# through a side-channel with Alice.
|
|
|
|
# If Bob doesn't know about any Ursulas, he can't find the TreasureMap via the REST swarm:
|
|
with pytest.raises(bob.NotEnoughUrsulas):
|
|
treasure_map_from_wire = bob.get_treasure_map(enacted_federated_policy.alice.stamp,
|
|
enacted_federated_policy.label)
|
|
|
|
# Let's imagine he has learned about some - say, from the blockchain.
|
|
bob._known_nodes = {u.canonical_public_address: u for u in ursulas}
|
|
|
|
# Now try.
|
|
treasure_map_from_wire = bob.get_treasure_map(enacted_federated_policy.alice.stamp,
|
|
enacted_federated_policy.label)
|
|
|
|
assert enacted_federated_policy.treasure_map == treasure_map_from_wire
|
|
|
|
|
|
def test_treaure_map_is_legit(enacted_federated_policy):
|
|
"""
|
|
Sure, the TreasureMap can get to Bob, but we also need to know that each Ursula in the TreasureMap is on the network.
|
|
"""
|
|
for ursula_address in enacted_federated_policy.treasure_map:
|
|
assert ursula_address in enacted_federated_policy.bob._known_nodes
|