def crawl(
general_config,
teacher_uri,
registry_filepath,
min_stake,
network,
learn_on_launch,
provider_uri,
influx_host,
influx_port,
http_port,
dry_run,
eager,
poa,
):
"""
Gather NuCypher network information.
"""
# Banner
emitter = general_config.emitter
emitter.clear()
emitter.banner(MONITOR_BANNER.format(CRAWLER))
# Setup
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
poa=poa)
registry = _get_registry(registry_filepath, network)
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else None
teacher_nodes = actions.load_seednodes(
emitter,
teacher_uris=teacher_uris,
min_stake=min_stake,
federated_only=False,
network_domains={network} if network else None,
network_middleware=RestMiddleware())
crawler = Crawler(domains={network} if network else None,
network_middleware=RestMiddleware(),
known_nodes=teacher_nodes,
registry=registry,
start_learning_now=eager,
learn_on_same_thread=learn_on_launch,
influx_host=influx_host,
influx_port=influx_port)
emitter.message(f"Network: {network.capitalize()}", color='blue')
emitter.message(f"InfluxDB: {influx_host}:{influx_port}", color='blue')
emitter.message(f"Provider: {provider_uri}", color='blue')
emitter.message(f"Refresh Rate: {crawler._refresh_rate}s", color='blue')
message = f"Running Nucypher Crawler JSON endpoint at http://localhost:{http_port}/stats"
emitter.message(message, color='green', bold=True)
if not dry_run:
crawler.start(eager=eager)
reactor.run()
def from_seed_and_stake_info(cls, host,
certificates_directory,
federated_only,
port=9151,
checksum_address=None,
minimum_stake=0,
network_middleware=None,
*args,
**kwargs
):
if network_middleware is None:
network_middleware = RestMiddleware()
certificate = network_middleware.get_certificate(host=host, port=port)
real_host = certificate.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value
# Write certificate; this is really only for temporary purposes. Ideally, we'd use
# it in-memory here but there's no obvious way to do that.
filename = '{}.{}'.format(checksum_address, Encoding.PEM.name.lower())
certificate_filepath = os.path.join(certificates_directory, filename)
_write_tls_certificate(certificate=certificate, full_filepath=certificate_filepath, force=True)
cls.log.info("Saved seednode {} TLS certificate".format(checksum_address))
potential_seed_node = cls.from_rest_url(
host=real_host,
port=port,
network_middleware=network_middleware,
certificate_filepath=certificate_filepath,
federated_only=True,
*args,
**kwargs) # TODO: 466
if checksum_address:
if not checksum_address == potential_seed_node.checksum_public_address:
raise potential_seed_node.SuspiciousActivity(
"This seed node has a different wallet address: {} (was hoping for {}). Are you sure this is a seed node?".format(
potential_seed_node.checksum_public_address,
checksum_address))
else:
if minimum_stake > 0:
# TODO: check the blockchain to verify that address has more then minimum_stake. #511
raise NotImplementedError("Stake checking is not implemented yet.")
try:
potential_seed_node.verify_node(
network_middleware=network_middleware,
accept_federated_only=federated_only,
certificate_filepath=certificate_filepath)
except potential_seed_node.InvalidNode:
raise # TODO: What if our seed node fails verification?
return potential_seed_node
def crawl(click_config, teacher_uri, registry_filepath, min_stake, network,
learn_on_launch, provider_uri, influx_host, influx_port, dry_run):
"""
Gather NuCypher network information.
"""
# Banner
emitter = click_config.emitter
emitter.clear()
emitter.banner(MONITOR_BANNER.format(CRAWLER))
registry = _get_registry(provider_uri, registry_filepath)
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else None
teacher_nodes = actions.load_seednodes(
emitter,
teacher_uris=teacher_uris,
min_stake=min_stake,
federated_only=False,
network_domains={network} if network else None,
network_middleware=click_config.middleware)
# Configure Storage
crawler = Crawler(domains={network} if network else None,
network_middleware=RestMiddleware(),
known_nodes=teacher_nodes,
registry=registry,
start_learning_now=True,
learn_on_same_thread=learn_on_launch,
blockchain_db_host=influx_host,
blockchain_db_port=influx_port)
if not dry_run:
crawler.start()
reactor.run()
def test_get_cert_from_running_seed_node(ursula_federated_test_config):
lonely_ursula_maker = partial(make_federated_ursulas,
ursula_config=ursula_federated_test_config,
quantity=1,
know_each_other=False)
firstula = lonely_ursula_maker().pop()
node_deployer = firstula.get_deployer()
node_deployer.addServices()
node_deployer.catalogServers(node_deployer.hendrix)
node_deployer.start()
certificate_as_deployed = node_deployer.cert.to_cryptography()
firstula_as_seed_node = firstula.seed_node_metadata()
any_other_ursula = lonely_ursula_maker(
seed_nodes=[firstula_as_seed_node],
network_middleware=RestMiddleware()).pop()
assert not any_other_ursula.known_nodes
def start_lonely_learning_loop():
any_other_ursula.start_learning_loop()
start = maya.now()
while not firstula in any_other_ursula.known_nodes.values():
passed = maya.now() - start
if passed.seconds > 2:
pytest.fail("Didn't find the seed node.")
yield deferToThread(start_lonely_learning_loop)
assert firstula in any_other_ursula.known_nodes.values()
certificate_as_learned = list(
any_other_ursula.known_nodes.values())[0].certificate
assert certificate_as_learned == certificate_as_deployed
any_other_ursula.stop_learning_loop()
def nucypher_cli(click_config, verbose, mock_networking, json_ipc, no_logs,
quiet, debug, no_registry, log_level):
# Session Emitter for pre and post character control engagement.
if json_ipc:
emitter = JSONRPCStdoutEmitter(
quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout)
else:
emitter = StdoutEmitter(
quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout)
click_config.attach_emitter(emitter)
if not json_ipc:
click_config.emit(message=NUCYPHER_BANNER)
if log_level:
GlobalConsoleLogger.set_log_level(log_level_name=log_level)
globalLogPublisher.addObserver(SimpleObserver())
if debug and quiet:
raise click.BadOptionUsage(
option_name="quiet",
message="--debug and --quiet cannot be used at the same time.")
if debug:
click_config.log_to_sentry = False
click_config.log_to_file = True # File Logging
globalLogPublisher.addObserver(SimpleObserver()) # Console Logging
globalLogPublisher.removeObserver(logToSentry) # No Sentry
GlobalConsoleLogger.set_log_level(log_level_name='debug')
elif quiet: # Disable Logging
globalLogPublisher.removeObserver(logToSentry)
globalLogPublisher.removeObserver(SimpleObserver)
globalLogPublisher.removeObserver(getJsonFileObserver())
# Logging
if not no_logs:
GlobalConsoleLogger.start_if_not_started()
# CLI Session Configuration
click_config.verbose = verbose
click_config.mock_networking = mock_networking
click_config.json_ipc = json_ipc
click_config.no_logs = no_logs
click_config.quiet = quiet
click_config.no_registry = no_registry
click_config.debug = debug
# Only used for testing outputs;
# Redirects outputs to in-memory python containers.
if mock_networking:
click_config.emit(message="WARNING: Mock networking is enabled")
click_config.middleware = MockRestMiddleware()
else:
click_config.middleware = RestMiddleware()
# Global Warnings
if click_config.verbose:
click_config.emit(message="Verbose mode is enabled", color='blue')
def moe(click_config, teacher_uri, min_stake, network, ws_port, dry_run, http_port, learn_on_launch):
"""
"Moe" NuCypher node monitor CLI.
"""
if not click_config.json_ipc and not click_config.quiet:
click.secho(MOE_BANNER)
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else list()
teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris,
min_stake=min_stake,
federated_only=True, # TODO: hardcoded for now
network_middleware=click_config.middleware)
# Deserialize network domain name if override passed
if network:
domain_constant = getattr(constants, network.upper())
domains = {domain_constant}
else:
domains = None
monitor = Moe(
domains=domains,
network_middleware=RestMiddleware(),
known_nodes=teacher_nodes,
federated_only=True)
monitor.start_learning_loop(now=learn_on_launch)
monitor.start(http_port=http_port, ws_port=ws_port, dry_run=dry_run)
def _propose_arrangement(
self,
address: ChecksumAddress,
network_middleware: RestMiddleware,
) -> Tuple[Ursula, Arrangement]:
"""
Attempt to propose an arrangement to the node with the given address.
"""
if address not in self.alice.known_nodes:
raise RuntimeError(f"{address} is not known")
ursula = self.alice.known_nodes[address]
arrangement = Arrangement.from_alice(alice=self.alice,
expiration=self.expiration)
self.log.debug(f"Proposing arrangement {arrangement} to {ursula}")
negotiation_response = network_middleware.propose_arrangement(
ursula, arrangement)
status = negotiation_response.status_code
if status == 200:
self.log.debug(f"Arrangement accepted by {ursula}")
else:
message = f"Proposing arrangement to {ursula} failed with {status}"
self.log.debug(message)
raise RuntimeError(message)
# We could just return the arrangement and get the Ursula object
# from `known_nodes` later, but when we introduce slashing in FleetSensor,
# the address can already disappear from `known_nodes` by that time.
return (ursula, arrangement)
def publish_treasure_map(self, network_middleware: RestMiddleware) -> dict:
self.treasure_map.prepare_for_publication(self.bob.public_keys(DecryptingPower),
self.bob.public_keys(SigningPower),
self.alice.stamp,
self.label)
if not self.alice.known_nodes:
# TODO: Optionally, block.
raise RuntimeError("Alice hasn't learned of any nodes. Thus, she can't push the TreasureMap.")
responses = dict()
for node in self.alice.known_nodes:
# TODO: # 342 - It's way overkill to push this to every node we know about. Come up with a system.
try:
treasure_map_id = self.treasure_map.public_id()
# TODO: Certificate filepath needs to be looked up and passed here
response = network_middleware.put_treasure_map_on_node(node=node,
map_id=treasure_map_id,
map_payload=bytes(self.treasure_map))
except NodeSeemsToBeDown:
# TODO: Introduce good failure mode here if too few nodes receive the map.
continue
if response.status_code == 202:
# TODO: #341 - Handle response wherein node already had a copy of this TreasureMap.
responses[node] = response
else:
# TODO: Do something useful here.
raise RuntimeError
return responses
def test_get_cert_from_running_seed_node(lonely_ursula_maker):
firstula = lonely_ursula_maker().pop()
node_deployer = firstula.get_deployer()
node_deployer.addServices()
node_deployer.catalogServers(node_deployer.hendrix)
node_deployer.start(
) # If this port happens not to be open, we'll get an error here. THis might be one of the few sane places to reintroduce a check.
certificate_as_deployed = node_deployer.cert.to_cryptography()
firstula_as_seed_node = firstula.seed_node_metadata()
any_other_ursula = lonely_ursula_maker(
seed_nodes=[firstula_as_seed_node],
network_middleware=RestMiddleware()).pop()
assert not any_other_ursula.known_nodes
yield deferToThread(any_other_ursula.load_seednodes)
assert firstula in any_other_ursula.known_nodes
firstula_as_learned = any_other_ursula.known_nodes[
firstula.checksum_address]
firstula_as_learned.mature()
assert certificate_as_deployed == firstula_as_learned.certificate
def initialize_bob(bob_privkeys):
ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URI,
federated_only=True,
minimum_stake=0)
TEMP_DOCTOR_DIR = "{}/listener-files".format(
os.path.dirname(os.path.abspath(__file__)))
# Remove previous demo files and create new ones
shutil.rmtree(TEMP_DOCTOR_DIR, ignore_errors=True)
bob_enc_keypair = DecryptingKeypair(private_key=bob_privkeys["enc"])
bob_sig_keypair = SigningKeypair(private_key=bob_privkeys["sig"])
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
print("Creating the Listener ...")
listener = Bob(
domains={TEMPORARY_DOMAIN},
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
print("Listener = ", listener)
return listener
def mock_node_information_endpoint(middleware, port, *args, **kwargs):
ursula_were_looking_for = ursula.rest_interface.port == port
if ursula_were_looking_for:
raise RestMiddleware.NotFound("Fake Reason") # Make this node unreachable
else:
response = Response(response=bytes(ursula), mimetype='application/octet-stream')
return response
def publish_treasure_map(self, network_middleware: RestMiddleware) -> dict:
self.treasure_map.prepare_for_publication(self.bob.public_keys(DecryptingPower),
self.bob.public_keys(SigningPower),
self.alice.stamp,
self.label
)
if not self.alice.known_nodes:
# TODO: Optionally block.
raise RuntimeError("Alice hasn't learned of any nodes. Thus, she can't push the TreasureMap.")
responses = dict()
for node in self.alice.known_nodes:
# TODO: It's way overkill to push this to every node we know about. Come up with a system. 342
response = network_middleware.put_treasure_map_on_node(node,
self.treasure_map.public_id(),
bytes(self.treasure_map)
) # TODO: Certificate filepath needs to be looked up and passed here
if response.status_code == 202:
responses[node] = response
# TODO: Handle response wherein node already had a copy of this TreasureMap. 341
else:
# TODO: Do something useful here.
raise RuntimeError
return responses
def moe(click_config, teacher_uri, min_stake, network, ws_port, dry_run, http_port, learn_on_launch):
"""
"Moe the Monitor" management commands.
"""
emitter = click_config.emitter
# Banner
emitter.clear()
emitter.banner(MOE_BANNER)
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else None
teacher_nodes = actions.load_seednodes(emitter,
teacher_uris=teacher_uris,
min_stake=min_stake,
federated_only=True, # TODO: hardcoded for now. Is Moe a Character?
network_domains={network} if network else None,
network_middleware=click_config.middleware)
# Make Moe
MOE = Moe(domains={network} if network else None,
network_middleware=RestMiddleware(),
known_nodes=teacher_nodes,
federated_only=True)
# Run
MOE.start_learning_loop(now=learn_on_launch)
emitter.message(f"Running Moe on 127.0.0.1:{http_port}")
MOE.start(http_port=http_port, ws_port=ws_port, dry_run=dry_run)
def process_middleware(mock_networking):
if mock_networking:
middleware = MockRestMiddleware()
else:
middleware = RestMiddleware()
return 'middleware', middleware
def act_as_bob(self, name):
print("act_as_bob")
dirname = "accounts/" + name + "/"
fname = dirname+"recipent.private.json"
with open(fname) as data_file:
data = json.load(data_file)
enc_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["enc"]))
sig_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["sig"]))
bob_enc_keypair = DecryptingKeypair(private_key=enc_privkey)
bob_sig_keypair = SigningKeypair(private_key=sig_privkey)
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
bob = Bob(
is_me=True,
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[self.ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
return bob
def create_crawler(node_db_filepath: str = IN_MEMORY_FILEPATH,
dont_set_teacher: bool = False):
registry = InMemoryContractRegistry()
middleware = RestMiddleware()
teacher_nodes = None
if not dont_set_teacher:
teacher_nodes = actions.load_seednodes(
None, # TODO: Needs emitter
teacher_uris=[DEFAULT_TEACHER], # TODO: Needs Cleanup
min_stake=0,
federated_only=False,
network_domains={'gemini'}, # TODO: Needs Cleanup
network_middleware=middleware)
crawler = Crawler(
domains={'goerli'}, # TODO: Needs Cleanup
network_middleware=middleware,
known_nodes=teacher_nodes,
registry=registry,
start_learning_now=True,
learn_on_same_thread=False,
influx_host='localhost', # TODO: Needs Cleanup
influx_port=8086, # TODO: Needs Cleanup
node_storage_filepath=node_db_filepath)
return crawler
def configure_alice(self, path):
return AliceConfiguration(
config_root=os.path.join(path),
known_nodes=[self.ursula, self.ursula2, self.ursula3],
start_learning_now=False,
federated_only=True,
learn_on_same_thread=True,
network_middleware=RestMiddleware(),
)
def process_middleware(mock_networking):
from nucypher.network.middleware import RestMiddleware
from nucypher.utilities.sandbox.middleware import MockRestMiddleware
if mock_networking:
middleware = MockRestMiddleware()
else:
middleware = RestMiddleware()
return 'middleware', middleware
def from_rest_url(cls,
network_middleware: RestMiddleware,
host: str,
port: int,
federated_only: bool = False) -> 'Ursula':
response = network_middleware.node_information(host, port)
if not response.status_code == 200:
raise RuntimeError("Got a bad response: {}".format(response))
stranger_ursula_from_public_keys = cls.from_bytes(response.content, federated_only=federated_only)
return stranger_ursula_from_public_keys
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 create_crawler(node_db_filepath: str = IN_MEMORY_FILEPATH):
registry = InMemoryContractRegistry()
middleware = RestMiddleware()
crawler = Crawler(domain='ibex', # TODO: Needs Cleanup
network_middleware=middleware,
registry=registry,
start_learning_now=True,
learn_on_same_thread=False,
influx_host='localhost', # TODO: Needs Cleanup
influx_port=8086, # TODO: Needs Cleanup
node_storage_filepath=node_db_filepath
)
return crawler
def generate_owner_policy_public_key(self, max_days):
self.ursula = Ursula.from_seed_and_stake_info(
seed_uri=self.URSULA_SEEDNODE_URI,
federated_only=True,
minimum_stake=0)
policy_end_datetime = maya.now() + datetime.timedelta(days=max_days)
self.ALICE = Alice(network_middleware=RestMiddleware(),
known_nodes=[self.ursula],
learn_on_same_thread=True,
federated_only=True)
policy_pubkey = self.ALICE.get_policy_pubkey_from_label(self.label)
return policy_pubkey
def from_rest_url(cls,
network_middleware: RestMiddleware,
host: str,
port: int,
certificate_filepath,
federated_only: bool = False,
*args, **kwargs
):
response_data = network_middleware.node_information(host, port, certificate_filepath=certificate_filepath)
stranger_ursula_from_public_keys = cls.from_bytes(response_data, federated_only=federated_only, *args,
**kwargs)
return stranger_ursula_from_public_keys
def _ping_node(self, address: ChecksumAddress,
network_middleware: RestMiddleware) -> 'Ursula':
# Handles edge case when provided address is not a known peer.
if address not in self.publisher.known_nodes:
raise RuntimeError(f"{address} is not a known peer")
ursula = self.publisher.known_nodes[address]
response = network_middleware.ping(node=ursula)
status_code = response.status_code
if status_code == 200:
return ursula
else:
raise RuntimeError(
f"{ursula} is not available for selection ({status_code}).")
def process_middleware(mock_networking) -> tuple:
#################
# MUST NOT RAISE!
#################
try:
from tests.utils.middleware import MockRestMiddleware
except ImportError:
# It's okay to not crash here despite not having the tests package available.
logger = Logger("CLI-Middleware-Optional-Handler")
logger.info('--mock-networking flag is unavailable without dev install.')
if mock_networking:
middleware = MockRestMiddleware()
else:
from nucypher.network.middleware import RestMiddleware
middleware = RestMiddleware()
return 'middleware', middleware
def generate_charlie():
shutil.rmtree(TEMP_CHARLIE_DIR, ignore_errors=True)
ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URL,
federated_only=True,
minimum_stake=0)
# To create a Bob, we need the charlie's private keys previously generated.
from charlie_keys import get_charlie_privkeys
charlie_keys = get_charlie_privkeys()
bob_enc_keypair = DecryptingKeypair(private_key=charlie_keys["enc"])
bob_sig_keypair = SigningKeypair(private_key=charlie_keys["sig"])
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
print("Creating the Charlie ...")
charlie = Bob(
is_me=True,
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
print("Charlie = ", charlie)
# Join policy generated by alice
with open("policy-metadata.json", 'r') as f:
policy_data = json.load(f)
policy_pubkey = UmbralPublicKey.from_bytes(
bytes.fromhex(policy_data["policy_pubkey"]))
alices_sig_pubkey = UmbralPublicKey.from_bytes(
bytes.fromhex(policy_data["alice_sig_pubkey"]))
label = policy_data["label"].encode()
print("The Charlie joins policy for label '{}'".format(
label.decode("utf-8")))
charlie.join_policy(label, alices_sig_pubkey)
return charlie, policy_pubkey, alices_sig_pubkey, label
def downloadFile(self, username, receipt, policy_info):
hash = receipt['hash_key']
input = self.ipfs_gateway_api.cat(hash)
enc_privkey, sig_privkey = self.reveal_private_keys(username)
bob_enc_key = DecryptingKeypair(private_key=enc_privkey)
bob_sig_keyp = SigningKeypair(private_key=sig_privkey)
enc_power = DecryptingPower(keypair=bob_enc_key)
sig_power = SigningPower(keypair=bob_sig_keyp)
power_ups = [enc_power, sig_power]
self.Bob = Bob(
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[self.ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(policy_info["policy_pubkey"]))
enrico = Enrico.from_public_keys(
{SigningPower: UmbralPublicKey.from_bytes(bytes.fromhex(receipt['data_source_public_key']))},
policy_encrypting_key=policy_pubkey
)
alice_pubkey_restored = UmbralPublicKey.from_bytes(base58.b58decode(policy_info['alice_sig_pubkey']))
self.Bob.join_policy(policy_info['label'].encode(), alice_pubkey_restored)
data = msgpack.loads(input, raw=False)
message_kits = (UmbralMessageKit.from_bytes(k) for k in data['kits'])
message_kit = next(message_kits)
retrieved_plaintexts = self.Bob.retrieve(
message_kit,
enrico=enrico,
alice_verifying_key=alice_pubkey_restored,
label=policy_info['label'].encode(),
)
plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False)
print(plaintext)
decrypted_data = plaintext['data']
return decrypted_data
def _get_alice(self):
# Gets an Alice instance
#print('Getting an Alice')
try: # If we had an existing Alicia in disk, let's get it from there
alice_config_file = os.path.join(self.TEMP_ALICE_DIR,
"config_root", "alice.config")
new_alice_config = AliceConfiguration.from_configuration_file(
filepath=alice_config_file,
known_nodes=[self.ursula],
network_middleware=RestMiddleware(),
start_learning_now=False,
save_metadata=False,
)
#new_alice_config.keyring.unlock(password=self.passphrase)
alicia = new_alice_config.produce()
except: # If anything fails, let's create Alicia from scratch
# Remove previous demo files and create new ones
#print("Creating ALICE")
shutil.rmtree(self.TEMP_ALICE_DIR, ignore_errors=True)
os.mkdir(self.TEMP_ALICE_DIR)
os.mkdir(self.TEMP_ALICE_URSULA_DIR)
alice_config = AliceConfiguration(
config_root=os.path.join(self.TEMP_ALICE_DIR, "config_root"),
is_me=True,
known_nodes=[self.ursula],
start_learning_now=False,
federated_only=True,
learn_on_same_thread=True,
)
alice_config.initialize(password=self.passphrase)
alice_config.keyring.unlock(password=self.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)
return alicia
def nucypher_cli(click_config,
verbose,
mock_networking,
json_ipc,
no_logs,
quiet,
debug,
no_registry):
# Session Emitter for pre and post character control engagement.
if json_ipc:
emitter = IPCStdoutEmitter(quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout)
else:
emitter = StdoutEmitter(quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout)
NucypherClickConfig.emitter = emitter
click_config.emitter(message=NUCYPHER_BANNER)
# Logging
if not no_logs:
GlobalConsoleLogger.start_if_not_started()
# CLI Session Configuration
click_config.verbose = verbose
click_config.mock_networking = mock_networking
click_config.json_ipc = json_ipc
click_config.no_logs = no_logs
click_config.quiet = quiet
click_config.no_registry = no_registry
click_config.debug = debug
# only used for testing outputs;
# Redirects outputs to in-memory python containers.
if mock_networking:
click_config.emitter(message="WARNING: Mock networking is enabled")
click_config.middleware = MockRestMiddleware()
else:
click_config.middleware = RestMiddleware()
# Global Warnings
if click_config.verbose:
click_config.emitter("Verbose mode is enabled", color='blue')
def _get_bob(self, passphrase) -> object:
'''
:param passphrase: Passpharse for new Bob instance
:return: None
'''
try:
bob_config_file = os.path.join(self.TEMP_BOB_DIR, "config_root",
"bob.config")
bob_config = BobConfiguration.from_configuration_file(
filepath=bob_config_file,
network_middleware=RestMiddleware(),
start_learning_now=False,
save_metadata=False,
)
bob_config.keyring.unlock(password=passphrase)
bob = bob_config.produce()
except:
shutil.rmtree(self.TEMP_BOB_DIR, ignore_errors=True)
os.mkdir(self.TEMP_BOB_DIR)
bob_config = BobConfiguration(
config_root=os.path.join(self.TEMP_BOB_DIR, "config_root"),
is_me=True,
known_nodes={self.ursula},
start_learning_now=True,
federated_only=True,
learn_on_same_thread=True,
)
bob_config.initialize(password=passphrase)
bob_config.keyring.unlock(password=passphrase)
bob = bob_config.produce()
bob_config_file = bob_config.to_configuration_file()
return bob
