Nucypher
/
nucypher
mirror of https://github.com/nucypher/nucypher.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Renames relayer -> publisher.

pull/2687/head
Kieran R. Prasch 2021-07-06 14:42:53 -07:00
parent 8f8b79aa08
commit 6192c34c3d
7 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
nucypher/characters/control/interfaces.py
View File

@ -194,7 +194,7 @@ class BobInterface(CharacterPublicInterface):
"""
Character control endpoint for joining a policy on the network.
"""
self.character.join_policy(label=label, relayer_verifying_key=alice_verifying_key)
self.character.join_policy(label=label, publisher_verifying_key=alice_verifying_key)
response = {'policy_encrypting_key': 'OK'} # FIXME
return response
@ -218,7 +218,7 @@ class BobInterface(CharacterPublicInterface):
policy_encrypting_key=policy_encrypting_key,
label=label)
self.character.join_policy(label=label, relayer_verifying_key=alice_verifying_key)
self.character.join_policy(label=label, publisher_verifying_key=alice_verifying_key)
plaintexts = self.character.retrieve(message_kit,
enrico=enrico,

54
nucypher/characters/lawful.py
View File

@ -629,8 +629,8 @@ class Bob(Character):
except treasure_map.InvalidSignature:
raise # TODO: Maybe do something here? NRN
def get_treasure_map(self, relayer_verifying_key: PublicKey, label: bytes):
map_identifier = self.construct_map_id(relayer_verifying_key=relayer_verifying_key, label=label)
def get_treasure_map(self, publisher_verifying_key: PublicKey, label: bytes):
map_identifier = self.construct_map_id(publisher_verifying_key=publisher_verifying_key, label=label)
if not self.known_nodes and not self._learning_task.running:
# Quick sanity check - if we don't know of *any* Ursulas, and we have no
@ -644,25 +644,25 @@ class Bob(Character):
treasure_map = self.get_treasure_map_from_known_ursulas(self.network_middleware, map_identifier)
self._try_orient(treasure_map, relayer_verifying_key)
self._try_orient(treasure_map, publisher_verifying_key)
self.treasure_maps[map_identifier] = treasure_map # TODO: make a part of _try_orient()?
return treasure_map
def make_compass_for_alice(self, alice):
return partial(self.verify_from, alice, decrypt=True)
def construct_policy_hrac(self, relayer_verifying_key: Union[bytes, PublicKey], label: bytes) -> bytes:
_hrac = keccak_digest(bytes(relayer_verifying_key) + self.stamp + label)[:HRAC_LENGTH]
def construct_policy_hrac(self, publisher_verifying_key: Union[bytes, PublicKey], label: bytes) -> bytes:
_hrac = keccak_digest(bytes(publisher_verifying_key) + self.stamp + label)[:HRAC_LENGTH]
return _hrac
def construct_map_id(self, relayer_verifying_key: PublicKey, label: bytes):
hrac = self.construct_policy_hrac(relayer_verifying_key, label)
def construct_map_id(self, publisher_verifying_key: PublicKey, label: bytes):
hrac = self.construct_policy_hrac(publisher_verifying_key, label)
# Ugh stupid federated only mode....
if not self.federated_only:
map_id = hrac.hex()
else:
map_id = keccak_digest(bytes(relayer_verifying_key) + hrac).hex()
map_id = keccak_digest(bytes(publisher_verifying_key) + hrac).hex()
return map_id
@ -713,15 +713,15 @@ class Bob(Character):
label: bytes,
treasure_map: 'TreasureMap',
alice_verifying_key: PublicKey,
relayer_verifying_key: Optional[PublicKey] = None,
publisher_verifying_key: Optional[PublicKey] = None,
num_ursulas: int = None,
) -> Tuple[Dict[ChecksumAddress, 'WorkOrder'], Dict['Capsule', 'WorkOrder']]:
from nucypher.policy.orders import WorkOrder
if not relayer_verifying_key:
if not publisher_verifying_key:
# Assume the policy publisher is the same as the KFrag generator by default.
relayer_verifying_key = alice_verifying_key
publisher_verifying_key = alice_verifying_key
if not treasure_map:
raise ValueError(f"Bob doesn't have a TreasureMap; can't generate work orders.")
@ -748,7 +748,7 @@ class Bob(Character):
ursula = self.known_nodes[ursula_address]
if capsules_to_include:
work_order = WorkOrder.construct_by_bob(label=label,
relayer_verifying_key=relayer_verifying_key,
publisher_verifying_key=publisher_verifying_key,
alice_verifying_key=alice_verifying_key,
capsules=capsules_to_include,
ursula=ursula,
@ -768,12 +768,12 @@ class Bob(Character):
def join_policy(self,
label: bytes,
relayer_verifying_key: PublicKey,
publisher_verifying_key: PublicKey,
node_list: Optional[List['Ursula']] = None,
block: bool = False):
if node_list:
self._node_ids_to_learn_about_immediately.update(node_list)
treasure_map = self.get_treasure_map(relayer_verifying_key, label)
treasure_map = self.get_treasure_map(publisher_verifying_key, label)
self.follow_treasure_map(treasure_map=treasure_map, block=block)
def _filter_work_orders_and_capsules(self,
@ -851,7 +851,7 @@ class Bob(Character):
enrico,
policy_encrypting_key,
use_attached_cfrags,
relayer_verifying_key,
publisher_verifying_key,
alice_verifying_key,
treasure_map,
label,
@ -878,11 +878,11 @@ class Bob(Character):
for message_kit in message_kits:
message_kit.set_correctness_keys(receiving=self.public_keys(DecryptingPower))
message_kit.set_correctness_keys(verifying=relayer_verifying_key)
message_kit.set_correctness_keys(verifying=publisher_verifying_key)
new_work_orders, complete_work_orders = self.work_orders_for_capsules(
treasure_map=treasure_map,
relayer_verifying_key=relayer_verifying_key,
publisher_verifying_key=publisher_verifying_key,
alice_verifying_key=alice_verifying_key,
label=label,
*[mk.capsule for mk in message_kits])
@ -968,7 +968,7 @@ class Bob(Character):
return cleartexts
def _handle_treasure_map(self, treasure_map, relayer_verifying_key: PublicKey, label: bytes):
def _handle_treasure_map(self, treasure_map, publisher_verifying_key: PublicKey, label: bytes):
if treasure_map is not None:
if self.federated_only:
@ -984,15 +984,15 @@ class Bob(Character):
tmap_bytes = treasure_map.encode()
treasure_map = _MapClass.from_bytes(b64decode(tmap_bytes))
self._try_orient(treasure_map, relayer_verifying_key)
self._try_orient(treasure_map, publisher_verifying_key)
# self.treasure_maps[treasure_map.public_id()] = treasure_map # TODO: Can we?
else:
map_id = self.construct_map_id(relayer_verifying_key, label)
map_id = self.construct_map_id(publisher_verifying_key, label)
try:
treasure_map = self.treasure_maps[map_id]
except KeyError:
# If the treasure map is not known, join the policy as part of retrieval.
self.join_policy(label=label, relayer_verifying_key=relayer_verifying_key)
self.join_policy(label=label, publisher_verifying_key=publisher_verifying_key)
treasure_map = self.treasure_maps[map_id]
_unknown_ursulas, _known_ursulas, m = self.follow_treasure_map(treasure_map=treasure_map, block=True)
@ -1006,7 +1006,7 @@ class Bob(Character):
# Alice(s)
alice_verifying_key: Union[PublicKey, bytes],
relayer_verifying_key: Optional[Union[PublicKey, bytes]] = None,
publisher_verifying_key: Optional[Union[PublicKey, bytes]] = None,
# Source Authentication
enrico: "Enrico" = None,
@ -1022,14 +1022,14 @@ class Bob(Character):
# Try our best to get an PublicKey instances from input
alice_verifying_key = PublicKey.from_bytes(bytes(alice_verifying_key))
if not relayer_verifying_key:
if not publisher_verifying_key:
# If an policy relay's verifying key is not passed, use the alice's by default.
relayer_verifying_key = alice_verifying_key
publisher_verifying_key = alice_verifying_key
else:
relayer_verifying_key = PublicKey.from_bytes(bytes(relayer_verifying_key))
publisher_verifying_key = PublicKey.from_bytes(bytes(publisher_verifying_key))
treasure_map, m = self._handle_treasure_map(treasure_map=treasure_map,
relayer_verifying_key=relayer_verifying_key,
publisher_verifying_key=publisher_verifying_key,
label=label)
work_orders, message_kits_map = self._assemble_work_orders(
@ -1038,7 +1038,7 @@ class Bob(Character):
enrico=enrico,
policy_encrypting_key=policy_encrypting_key,
alice_verifying_key=alice_verifying_key,
relayer_verifying_key=relayer_verifying_key,
publisher_verifying_key=publisher_verifying_key,
treasure_map=treasure_map,
use_attached_cfrags=use_attached_cfrags,
use_precedent_work_orders=use_precedent_work_orders

2
nucypher/network/server.py
View File

@ -198,7 +198,7 @@ def _make_rest_app(datastore: Datastore, this_node, domain: str, log: Logger) ->
# Alice & Relayer
alice = _alice_class.from_public_keys(verifying_key=work_order.alice_verifying_key)
alice_verifying_key = alice.stamp.as_umbral_pubkey()
policy_relayer = _alice_class.from_public_keys(verifying_key=work_order.relayer_verifying_key)
policy_relayer = _alice_class.from_public_keys(verifying_key=work_order.publisher_verifying_key)
# Bob
bob_ip_address = request.remote_addr

14
nucypher/policy/orders.py
View File

@ -144,7 +144,7 @@ class WorkOrder:
hrac: bytes,
encrypted_kfrag: bytes,
alice_verifying_key: bytes,
relayer_verifying_key: bytes,
publisher_verifying_key: bytes,
tasks: dict,
receipt_signature: Signature,
ursula: Optional['Ursula'] = None):
@ -153,7 +153,7 @@ class WorkOrder:
self.hrac = hrac
self.ursula = ursula
self.encrypted_kfrag = encrypted_kfrag
self.relayer_verifying_key = relayer_verifying_key
self.publisher_verifying_key = publisher_verifying_key
self.alice_verifying_key = alice_verifying_key
self.tasks = tasks
self.receipt_signature = receipt_signature # not a blockchain receipt
@ -185,7 +185,7 @@ class WorkOrder:
def construct_by_bob(cls,
label: bytes,
alice_verifying_key: PublicKey,
relayer_verifying_key: PublicKey,
publisher_verifying_key: PublicKey,
capsules: Sequence,
ursula: 'Ursula',
bob: 'Bob',
@ -211,14 +211,14 @@ class WorkOrder:
receipt = cls.make_receipt(tasks=tasks, ursula=ursula, encrypted_kfrag=encrypted_kfrag)
receipt_signature = bob.stamp(receipt)
hrac = bob.construct_policy_hrac(relayer_verifying_key=relayer_verifying_key, label=label)
hrac = bob.construct_policy_hrac(publisher_verifying_key=publisher_verifying_key, label=label)
return cls(bob=bob,
ursula=ursula,
hrac=hrac,
tasks=tasks,
receipt_signature=receipt_signature,
encrypted_kfrag=encrypted_kfrag,
relayer_verifying_key=relayer_verifying_key,
publisher_verifying_key=publisher_verifying_key,
alice_verifying_key=alice_verifying_key)
def payload(self) -> bytes:
@ -237,7 +237,7 @@ class WorkOrder:
tasks_bytes = b''.join(bytes(item) for item in self.tasks.values())
result = bytes(self.receipt_signature) \
+ bytes(self.alice_verifying_key) \
+ bytes(self.relayer_verifying_key) \
+ bytes(self.publisher_verifying_key) \
+ bytes(self.bob.stamp) \
+ bytes(self.hrac) \
+ bytes(VariableLengthBytestring(self.encrypted_kfrag)) \
@ -279,7 +279,7 @@ class WorkOrder:
ursula=ursula,
tasks=tasks,
encrypted_kfrag=ekfrag,
relayer_verifying_key=publisher_verifying,
publisher_verifying_key=publisher_verifying,
alice_verifying_key=authorizer_verifying,
receipt_signature=signature)

12
tests/integration/characters/test_bob_handles_frags.py
View File

@ -58,7 +58,7 @@ def test_bob_already_knows_all_nodes_in_treasure_map(enacted_federated_policy,
federated_bob.remember_node(ursula)
# Now, Bob can get the TreasureMap all by himself, and doesn't need a side channel.
the_map = federated_bob.get_treasure_map(relayer_verifying_key=federated_alice.stamp,
the_map = federated_bob.get_treasure_map(publisher_verifying_key=federated_alice.stamp,
label=enacted_federated_policy.label)
unknown, known = federated_bob.peek_at_treasure_map(treasure_map=the_map)
@ -158,7 +158,7 @@ def test_bob_can_issue_a_work_order_to_a_specific_ursula(enacted_federated_polic
message_kit.capsule,
label=enacted_federated_policy.label,
treasure_map=treasure_map,
relayer_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
alice_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
num_ursulas=1)
# Again: one Ursula, one work_order.
@ -172,7 +172,7 @@ def test_bob_can_issue_a_work_order_to_a_specific_ursula(enacted_federated_polic
message_kit.capsule,
label=enacted_federated_policy.label,
treasure_map=treasure_map,
relayer_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
alice_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
num_ursulas=1)
# The work order we just made is not yet complete, of course.
@ -240,7 +240,7 @@ def test_bob_can_use_cfrag_attached_to_completed_workorder(enacted_federated_pol
last_capsule_on_side_channel,
label=enacted_federated_policy.label,
treasure_map=enacted_federated_policy.treasure_map,
relayer_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
alice_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
num_ursulas=1,
)
@ -290,7 +290,7 @@ def test_bob_remembers_that_he_has_cfrags_for_a_particular_capsule(enacted_feder
last_capsule_on_side_channel,
label=enacted_federated_policy.label,
treasure_map=enacted_federated_policy.treasure_map,
relayer_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
alice_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
num_ursulas=1)
id_of_this_new_ursula, new_work_order = list(incomplete_work_orders.items())[0]
@ -344,7 +344,7 @@ def test_bob_gathers_and_combines(enacted_federated_policy, federated_bob, feder
the_message_kit.capsule,
label=enacted_federated_policy.label,
treasure_map=enacted_federated_policy.treasure_map,
relayer_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
alice_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
num_ursulas=number_left_to_collect)
_id_of_yet_another_ursula, new_work_order = list(new_incomplete_work_orders.items())[0]

4
tests/integration/characters/test_bob_joins_policy_and_retrieves.py
View File

@ -96,7 +96,7 @@ def test_bob_joins_policy_and_retrieves(federated_alice,
try:
# Now, Bob joins the policy
bob.join_policy(label=label,
relayer_verifying_key=federated_alice.stamp,
publisher_verifying_key=federated_alice.stamp,
block=True)
except policy.treasure_map.NowhereToBeFound:
maps = []
@ -106,7 +106,7 @@ def test_bob_joins_policy_and_retrieves(federated_alice,
if policy.treasure_map in maps:
# This is a nice place to put a breakpoint to examine Bob's failure to join a policy.
bob.join_policy(label=label,
relayer_verifying_key=federated_alice.stamp,
publisher_verifying_key=federated_alice.stamp,
block=True)
pytest.fail(f"Bob didn't find map {policy.treasure_map} even though it was available. Come on, Bob.")
else:

2
tests/unit/test_work_orders.py
View File

@ -107,7 +107,7 @@ def test_work_order_with_multiple_capsules(mock_ursula_reencrypts,
# Test construction of WorkOrders by Bob
work_order = WorkOrder.construct_by_bob(encrypted_kfrag=mock_kfrag,
bob=federated_bob,
relayer_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
publisher_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
alice_verifying_key=federated_alice.stamp.as_umbral_pubkey(),
ursula=ursula,
capsules=capsules,