def alice(ursulas, mock_policy_agent, nucypher_test_config): ALICE = Alice(network_middleware=MockNetworkyStuff(ursulas), policy_agent=mock_policy_agent, config=nucypher_test_config) ALICE.server.listen(8471) ALICE.__resource_id = b"some_resource_id" EVENT_LOOP.run_until_complete(ALICE.server.bootstrap([("127.0.0.1", u.dht_port) for u in ursulas])) ALICE.network_bootstrap([("127.0.0.1", u.rest_port) for u in ursulas]) return ALICE
def alice(ursulas): alice = Alice(network_middleware=MockRestMiddleware(), known_nodes=ursulas, federated_only=True, abort_on_learning_error=True) alice.recruit = lambda *args, **kwargs: [u._ether_address for u in ursulas] return alice
def create_policy(self, label: bytes, alice_privkey: UmbralPrivateKey, bob_pubkey: UmbralPublicKey, policy_expiration, m: int, n: int): """ Create a Policy with Alice granting Bob access to `label` DataSource :param label: A label to represent the policies data :param alice_privkey: Alice's private key :param bob_pubkey: Bob's public key :param policy_expiration: Datetime of policy expiration duration :param m: Minimum number of KFrags needed to rebuild ciphertext :param n: Total number of rekey shares to generate :return: The policy granted to Bob """ # This is not how this should be implemented, but I am still figuring out # the keying material and why it is randomly generated when a character is # initialized, instead of being derived from the keys like the other powers # or explained how it should be stored. d = DelegatingPower() d.umbral_keying_material = UmbralKeyingMaterial.from_bytes( alice_privkey.to_bytes() + alice_privkey.get_pubkey().to_bytes()) # Initialize Alice ALICE = Alice( crypto_power_ups=[ SigningPower(keypair=SigningKeypair(alice_privkey)), EncryptingPower(keypair=EncryptingKeypair(alice_privkey)), # DelegatingPower d ], network_middleware=RestMiddleware(), known_nodes=(self.ursula, ), federated_only=True, always_be_learning=True) # Initialize Bob BOB = Bob(crypto_power_ups=[ SigningPower(pubkey=bob_pubkey), EncryptingPower(pubkey=bob_pubkey) ], known_nodes=(self.ursula, ), federated_only=True, always_be_learning=True) # Alice grants a policy for Bob policy = ALICE.grant(BOB, label, m=m, n=n, expiration=policy_expiration) return policy
def from_bytes(cls, arrangement_as_bytes): # Still unclear how to arrive at the correct number of bytes to represent a deposit. See #148. alice_pubkey_sig, id, expiration_bytes = cls.splitter( arrangement_as_bytes) expiration = maya.parse(expiration_bytes.decode()) alice = Alice.from_public_keys({SigningPower: alice_pubkey_sig}) return cls(alice=alice, id=id, expiration=expiration)
def test_anybody_can_verify(): """ In the last example, we used the lower-level Crypto API to verify the signature. Here, we show that anybody can do it without needing to directly access Crypto. """ # Alice can sign by default, by dint of her _default_crypto_powerups. alice = Alice(federated_only=True, always_be_learning=False) # So, our story is fairly simple: an everyman meets Alice. somebody = Character(always_be_learning=False, federated_only=True) # Alice signs a message. message = b"A message for all my friends who can only verify and not sign." signature = alice.stamp(message) # Our everyman can verify it. cleartext = somebody.verify_from(alice, message, signature, decrypt=False) assert cleartext is constants.NO_DECRYPTION_PERFORMED
def blockchain_alice(mining_ursulas, three_agents): token_agent, miner_agent, policy_agent = three_agents etherbase, alice_address, bob_address, *everyone_else = token_agent.blockchain.interface.w3.eth.accounts alice = Alice(network_middleware=MockRestMiddleware(), policy_agent=policy_agent, known_nodes=mining_ursulas, abort_on_learning_error=True, checksum_address=alice_address) # alice.recruit = lambda *args, **kwargs: [u._ether_address for u in ursulas] return alice
def test_anybody_can_verify(nucypher_test_config, mock_policy_agent): """ In the last example, we used the lower-level Crypto API to verify the signature. Here, we show that anybody can do it without needing to directly access Crypto. """ # Alice can sign by default, by dint of her _default_crypto_powerups. alice = Alice(config=nucypher_test_config, policy_agent=mock_policy_agent) # So, our story is fairly simple: an everyman meets Alice. somebody = Character(config=nucypher_test_config) # Alice signs a message. message = b"A message for all my friends who can only verify and not sign." signature = alice.stamp(message) # Our everyman can verify it. verification, cleartext = somebody.verify_from(alice, message, signature, decrypt=False) assert verification is True assert cleartext is constants.NO_DECRYPTION_PERFORMED
# This is already running in another process. ############################################## # This is already running in another process. ############################################## BLOCKCHAIN = Blockchain.connect() URSULA = Ursula.from_config() ######### # Alice # ######### ALICE = Alice.from_config() # Here are our Policy details. policy_end_datetime = maya.now() + datetime.timedelta(days=201) m = 2 n = 3 label = b"secret/files/and/stuff" # Alice grants to Bob. BOB = Bob.from_config() ALICE.start_learning_loop(now=True) policy = ALICE.grant(BOB, label, m=m, n=n, expiration=policy_end_datetime) # Alice puts her public key somewhere for Bob to find later...
with open("examples-runtime-cruft/node-metadata-{}".format(teacher_rest_port), "r") as f: f.seek(0) teacher_bytes = binascii.unhexlify(f.read()) URSULA = Ursula.from_bytes(teacher_bytes, federated_only=True) print("Will learn from {}".format(URSULA)) # network_middleware = SandboxRestMiddleware([URSULA]) ######### # Alice # ######### ALICE = Alice( network_middleware=RestMiddleware(), known_nodes=(URSULA, ), # in lieu of seed nodes federated_only=True, always_be_learning=True) # TODO: 289 # Here are our Policy details. policy_end_datetime = maya.now() + datetime.timedelta(days=5) m = 2 n = 3 label = b"secret/files/and/stuff" # Alice grants to Bob. BOB = Bob(known_nodes=(URSULA, ), federated_only=True, always_be_learning=True) ALICE.start_learning_loop(now=True) policy = ALICE.grant(BOB, label, m=m, n=n, expiration=policy_end_datetime) # Alice puts her public key somewhere for Bob to find later...
def get_alice(): return Alice(network_middleware=RestMiddleware(), known_nodes=(get_seed(),), # in lieu of seed nodes federated_only=True, always_be_learning=True) # TODO: 289
from examples.sandbox_resources import SandboxNetworkyStuff from nucypher.characters import Alice, Bob, Ursula from nucypher.data_sources import DataSource from nucypher.network.node import NetworkyStuff import maya # This is already running in another process. URSULA = Ursula.from_rest_url(NetworkyStuff(), address="localhost", port=3601) network_middleware = SandboxNetworkyStuff([URSULA]) ######### # Alice # ######### ALICE = Alice(network_middleware=network_middleware) # Here are our Policy details. policy_end_datetime = maya.now() + datetime.timedelta(days=5) m = 1 n = 1 label = b"secret/files/and/stuff" # Alice gets on the network and, knowing about at least one Ursula, # Is able to discover all Ursulas. ALICE.network_bootstrap([("localhost", 3601)]) # Alice grants to Bob. BOB = Bob() policy = ALICE.grant(BOB, label, m=m, n=n, expiration=policy_end_datetime)