def capsule_side_channel(enacted_policy): signing_keypair = SigningKeypair() data_source = DataSource(policy_pubkey_enc=enacted_policy.public_key, signing_keypair=signing_keypair) message_kit, _signature = data_source.encapsulate_single_message( b"Welcome to the flippering.") return message_kit, data_source
def from_public_keys(cls, policy_public_key, datasource_public_key, label): umbral_public_key = UmbralPublicKey.from_bytes(datasource_public_key) return cls( policy_public_key, signing_keypair=SigningKeypair(public_key=umbral_public_key), label=label, )
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 __init__(self, policy_pubkey_enc, signing_keypair=NO_SIGNING_POWER, label=None) -> None: self.policy_pubkey = policy_pubkey_enc if signing_keypair is NO_SIGNING_POWER: signing_keypair = SigningKeypair() # TODO: Generate signing key properly. #241 signing_power = SigningPower(keypair=signing_keypair) self.stamp = signing_power.get_signature_stamp() self.label = label
def capsule_side_channel(enacted_federated_policy): data_source = DataSource(policy_pubkey_enc=enacted_federated_policy.public_key, signing_keypair=SigningKeypair(), label=enacted_federated_policy.label ) message_kit, _signature = data_source.encrypt_message(b"Welcome to the flippering.") return message_kit, data_source
def decrypt_for_policy(self, label: bytes, message_kit: UmbralMessageKit, alice_pubkey: UmbralPublicKey, bob_privkey: UmbralPrivateKey, policy_pubkey: UmbralPublicKey, data_source_pubkey: UmbralPublicKey): """ Decrypt data for a Policy :param label: A label to represent the policies data :param message_kit: UmbralMessageKit :param alice_pubkey: Alice's public key :param bob_privkey: Bob's private key :param policy_pubkey: Policy's private key :param data_source_pubkey: DataSource's private key :return: The decrypted cleartext """ print('decrypt_for_policy') # Initialize Bob BOB = Bob(crypto_power_ups=[ SigningPower(keypair=SigningKeypair(bob_privkey)), EncryptingPower(keypair=EncryptingKeypair(bob_privkey)) ], known_nodes=(self.ursula, ), federated_only=True, always_be_learning=True) print('-=-=-=') print(label) print(bytes(alice_pubkey)) # Bob joins the policy so that he can receive data shared on it BOB.join_policy( label, # The label - he needs to know what data he's after. bytes(alice_pubkey ), # To verify the signature, he'll need Alice's public key. # verify_sig=True, # And yes, he usually wants to verify that signature. # He can also bootstrap himself onto the network more quickly # by providing a list of known nodes at this time. node_list=[("localhost", 3601)]) print('-=-=-=2') # Bob needs to reconstruct the DataSource. datasource_as_understood_by_bob = DataSource.from_public_keys( policy_public_key=policy_pubkey, datasource_public_key=bytes(data_source_pubkey), label=label) print('-=-=-=3') # NOTE: Not sure if I am doing something wrong or if this is missing # from the serialized bytes message_kit.policy_pubkey = policy_pubkey # Now Bob can retrieve the original message. He just needs the MessageKit # and the DataSource which produced it. cleartexts = BOB.retrieve(message_kit=message_kit, data_source=datasource_as_understood_by_bob, alice_verifying_key=alice_pubkey) print('-=-=-=4') return cleartexts[0]
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 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
TEMP_DOCTOR_CERTIFICATE_DIR = "{}/bob-certs".format(TEMP_DOCTOR_DIR) # Remove previous demo files and create new ones shutil.rmtree(TEMP_DOCTOR_DIR, ignore_errors=True) os.mkdir(TEMP_DOCTOR_DIR) os.mkdir(TEMP_URSULA_CERTIFICATE_DIR) os.mkdir(TEMP_DOCTOR_CERTIFICATE_DIR) ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URL, federated_only=True, minimum_stake=0) bob_privkeys = demo_keys.get_recipient_privkeys("bob") 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 Bob ...") bob = 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(),
os.path.dirname(os.path.abspath(__file__))) # Remove previous demo files and create new ones shutil.rmtree(TEMP_DOCTOR_DIR, ignore_errors=True) ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URI, federated_only=True, minimum_stake=0) # To create a Bob, we need the doctor's private keys previously generated. from doctor_keys import get_doctor_privkeys doctor_keys = get_doctor_privkeys() bob_enc_keypair = DecryptingKeypair(private_key=doctor_keys["enc"]) bob_sig_keypair = SigningKeypair(private_key=doctor_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 Doctor ...") doctor = 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(),
def decryptDelegated(): # Fetch Request Data # { # "bobKeys": "{\"enc\": \"40f05590a27491caf37049366fefd43e46034e4308f4f1fd233c166bc3980ab4\", \"sig\": \"3bcf21d3cb160118b499a883023569c60476f8731bd9eade11016c5030c1ca5d\"}", # "policy_public_key": "02aef01b40c0a62a9a1f650dd9a8381695e21a7b3826c748a5b64831aa0dd9862c", # "alice_sig_pubkey": "036c5d361000e6fbf3c4a84c98f924a3206e8a72c758a67e8300b5bee111b5fa97", # "label": "1stlabel", # "message": "messagekit", # "data_source": "03a38eef9fd09c9841585dea93791e139a3003d540539673c8c719af55e46c0c1b", # } json_data = json.loads(request.data.decode('utf-8')) bob_private_keys = json.loads(json_data['bobKeys']) policy_public_key = json_data['policy_public_key'] alice_signing_key = json_data['alice_sig_pubkey'] label = json_data['label'] # username = json_data['username'] message = json_data['message'] data_source = json_data['data_source'] data_source = bytes.fromhex(data_source) print (bob_private_keys['enc']) enc = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["enc"])) sig = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["sig"])) # signingPublic = sig.get_pubkey() # bobFilePath = os.path.join(os.getcwd(), 'bob/' + username + '.json') # doctor_pubkeys = _get_keys(bobFilePath, UmbralPublicKey) # print (signingPublic == doctor_pubkeys['sig']) # print (signingPublic) # print (doctor_pubkeys['sig']) print ('\n\n\n') bob_enc_keypair = DecryptingKeypair(private_key=enc) bob_sig_keypair = SigningKeypair(private_key=sig) enc_power = DecryptingPower(keypair=bob_enc_keypair) sig_power = SigningPower(keypair=bob_sig_keypair) power_ups = [enc_power, sig_power] doctor = Bob( domains={'TEMPORARY_DOMAIN'}, 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() ) policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(policy_public_key)) alices_sig_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(alice_signing_key)) label = label.encode() doctor.join_policy(label, alices_sig_pubkey) message_kit = UmbralMessageKit.from_bytes(bytes.fromhex(message)) print (message_kit == MessageKit) print (message_kit) print (MessageKit) print ('\n\n\n') data_source = Enrico.from_public_keys( {SigningPower: data_source}, policy_encrypting_key=policy_pubkey ) retrieved_plaintexts = doctor.retrieve( label=label, message_kit=message_kit, data_source=data_source, alice_verifying_key=alices_sig_pubkey ) # the object to be sent back to front end # { # "fileFieldCount": 2, # "textFieldCount": 2, # "files (stringified)": { # "fileKey1": "fileUrl1", # "fileKey2": "fileUrl2" # }, # "textFields (stringified)": { # "age": "18", # "name": "arvind" # } # } plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False) # the object from plaintext data_obj = createDataObject(plaintext, json_data['label']) return jsonify(data_obj)
def test_bob_joins_policy_and_retrieves(federated_alice, federated_ursulas, certificates_tempdir, ): # Let's partition Ursulas in two parts a_couple_of_ursulas = list(federated_ursulas)[:2] rest_of_ursulas = list(federated_ursulas)[2:] # Bob becomes bob = Bob(federated_only=True, start_learning_now=True, network_middleware=MockRestMiddleware(), abort_on_learning_error=True, known_nodes=a_couple_of_ursulas, ) # Bob only knows a couple of Ursulas initially assert len(bob.known_nodes) == 2 # Alice creates a policy granting access to Bob # Just for fun, let's assume she distributes KFrags among Ursulas unknown to Bob n = NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK - 2 label = b'label://' + os.urandom(32) contract_end_datetime = maya.now() + datetime.timedelta(days=5) policy = federated_alice.grant(bob=bob, label=label, m=3, n=n, expiration=contract_end_datetime, handpicked_ursulas=set(rest_of_ursulas), ) assert bob == policy.bob assert label == policy.label # Now, Bob joins the policy bob.join_policy(label=label, alice_pubkey_sig=federated_alice.stamp, ) # In the end, Bob should know all the Ursulas assert len(bob.known_nodes) == len(federated_ursulas) # DataSource becomes data_source = DataSource(policy_pubkey_enc=policy.public_key, signing_keypair=SigningKeypair(), label=label ) plaintext = b"What's your approach? Mississippis or what?" message_kit, _signature = data_source.encrypt_message(plaintext) alices_verifying_key = federated_alice.stamp.as_umbral_pubkey() # Bob takes the message_kit and retrieves the message within delivered_cleartexts = bob.retrieve(message_kit=message_kit, data_source=data_source, alice_verifying_key=alices_verifying_key) assert plaintext == delivered_cleartexts[0] # Let's try retrieve again, but Alice revoked the policy. failed_revocations = federated_alice.revoke(policy) assert len(failed_revocations) == 0 with pytest.raises(Ursula.NotEnoughUrsulas): _cleartexts = bob.retrieve(message_kit=message_kit, data_source=data_source, alice_verifying_key=alices_verifying_key)
def decryptDelegated(): json_data = json.loads(request.data.decode('utf-8')) bob_private_keys = json.loads(json_data['bobKeys']) policy_public_key = json_data['policy_public_key'] alice_signing_key = json_data['alice_sig_pubkey'] label = json_data['label'] # username = json_data['username'] message = json_data['message'] data_source = json_data['data_source'] data_source = bytes.fromhex(data_source) print (bob_private_keys['enc']) enc = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["enc"])) sig = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["sig"])) # signingPublic = sig.get_pubkey() # bobFilePath = os.path.join(os.getcwd(), 'bob/' + username + '.json') # doctor_pubkeys = _get_keys(bobFilePath, UmbralPublicKey) # print (signingPublic == doctor_pubkeys['sig']) # print (signingPublic) # print (doctor_pubkeys['sig']) print ('\n\n\n') bob_enc_keypair = DecryptingKeypair(private_key=enc) bob_sig_keypair = SigningKeypair(private_key=sig) enc_power = DecryptingPower(keypair=bob_enc_keypair) sig_power = SigningPower(keypair=bob_sig_keypair) power_ups = [enc_power, sig_power] doctor = Bob( domains={'TEMPORARY_DOMAIN'}, 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() ) policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(policy_public_key)) alices_sig_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(alice_signing_key)) label = label.encode() doctor.join_policy(label, alices_sig_pubkey) message_kit = UmbralMessageKit.from_bytes(bytes.fromhex(message)) print (message_kit == MessageKit) print (message_kit) print (MessageKit) print ('\n\n\n') data_source = Enrico.from_public_keys( {SigningPower: data_source}, policy_encrypting_key=policy_pubkey ) retrieved_plaintexts = doctor.retrieve( label=label, message_kit=message_kit, data_source=data_source, alice_verifying_key=alices_sig_pubkey ) # the object to be sent back to front end # { # "fileFieldCount": 2, # "textFieldCount": 2, # "files (stringified)": { # "fileKey1": "fileUrl1", # "fileKey2": "fileUrl2" # }, # "textFields (stringified)": { # "age": "18", # "name": "arvind" # } # } plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False) # the object from plaintext # data_obj = createDataObject(plaintext, json_data['label']) return jsonify(plaintext)
def run_doc(): globalLogPublisher.addObserver(SimpleObserver()) ###################### # Boring setup stuff # ###################### SEEDNODE_URL = 'localhost:11501' # TODO: path joins? TEMP_DOCTOR_DIR = "{}/doctor-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) ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URL, federated_only=True, minimum_stake=0) # To create a Bob, we need the doctor's private keys previously generated. doctor_keys = get_doctor_privkeys() bob_enc_keypair = DecryptingKeypair(private_key=doctor_keys["enc"]) bob_sig_keypair = SigningKeypair(private_key=doctor_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 Doctor ...") doctor = 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("Doctor = ", doctor) # Let's join the policy generated by Alicia. We just need some info about it. 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 Doctor joins policy for label '{}'".format( label.decode("utf-8"))) doctor.join_policy(label, alices_sig_pubkey) # Now that the Doctor joined the policy in the NuCypher network, # he can retrieve encrypted data which he can decrypt with his private key. # But first we need some encrypted data! # Let's read the file produced by the heart monitor and unpack the MessageKits, # which are the individual ciphertexts. data = msgpack.load(open("heart_data.msgpack", "rb"), raw=False) message_kits = (UmbralMessageKit.from_bytes(k) for k in data['kits']) # The doctor also needs to create a view of the Data Source from its public keys data_source = Enrico.from_public_keys({SigningPower: data['data_source']}, policy_encrypting_key=policy_pubkey) # Now he can ask the NuCypher network to get a re-encrypted version of each MessageKit. for message_kit in message_kits: try: start = timer() retrieved_plaintexts = doctor.retrieve( label=label, message_kit=message_kit, data_source=data_source, alice_verifying_key=alices_sig_pubkey) end = timer() plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False) # Now we can get the heart rate and the associated timestamp, # generated by the heart rate monitor. heart_rate = plaintext['heart_rate'] timestamp = maya.MayaDT(plaintext['timestamp']) # This code block simply pretty prints the heart rate info terminal_size = shutil.get_terminal_size().columns max_width = min(terminal_size, 120) columns = max_width - 12 - 27 scale = columns / 40 scaled_heart_rate = int(scale * (heart_rate - 60)) retrieval_time = "Retrieval time: {:8.2f} ms".format(1000 * (end - start)) line = ("-" * scaled_heart_rate) + "❤︎ ({} BPM)".format(heart_rate) line = line.ljust(max_width - 27, " ") + retrieval_time print(line) except Exception as e: # We just want to know what went wrong and continue the demo traceback.print_exc()
def doctor_decrypt(hash_key): globalLogPublisher.addObserver(SimpleObserver()) SEEDNODE_URL = 'localhost:11501' TEMP_DOCTOR_DIR = "{}/doctor-files".format( os.path.dirname(os.path.abspath(__file__))) shutil.rmtree(TEMP_DOCTOR_DIR, ignore_errors=True) ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URL, federated_only=True, minimum_stake=0) from doctor_keys import get_doctor_privkeys doctor_keys = get_doctor_privkeys() bob_enc_keypair = DecryptingKeypair(private_key=doctor_keys["enc"]) bob_sig_keypair = SigningKeypair(private_key=doctor_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 Doctor ...") doctor = 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("Doctor = ", doctor) 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 Doctor joins policy for label '{}'".format( label.decode("utf-8"))) doctor.join_policy(label, alices_sig_pubkey) ipfs_api = ipfsapi.connect() file = ipfs_api.get(hash_key) print(file) os.rename(hash_key, 'patient_details.msgpack') data = msgpack.load(open("patient_details.msgpack", "rb"), raw=False) message_kits = (UmbralMessageKit.from_bytes(k) for k in data['kits']) data_source = DataSource.from_public_keys( policy_public_key=policy_pubkey, datasource_public_key=data['data_source'], label=label) complete_message = [] for message_kit in message_kits: print(message_kit) try: start = timer() retrieved_plaintexts = doctor.retrieve( message_kit=message_kit, data_source=data_source, alice_verifying_key=alices_sig_pubkey) end = timer() plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False) complete_message.append(plaintext) print(plaintext) #with open("details.json", "w") as write_file: # json.dump(plaintext, write_file) except Exception as e: traceback.print_exc() with open("details.json", "w") as write_file: json.dump(complete_message, write_file) return complete_message
def downloadFile(self, downloadFilename, recipient_privkeys, receipt, policy_info): hash = receipt['hash_key'] input = self.ipfs.cat(hash) ursula = Ursula.from_seed_and_stake_info( seed_uri=self.URSULA_SEEDNODE_URI, federated_only=True, minimum_stake=0) bob_enc_keypair = DecryptingKeypair( private_key=UmbralPrivateKey.from_bytes( bytes.fromhex(recipient_privkeys["enc"]))) bob_sig_keypair = SigningKeypair( private_key=UmbralPrivateKey.from_bytes( bytes.fromhex(recipient_privkeys["sig"]))) enc_power = DecryptingPower(keypair=bob_enc_keypair) sig_power = SigningPower(keypair=bob_sig_keypair) power_ups = [enc_power, sig_power] authorizedRecipient = 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(), ) policy_pubkey = UmbralPublicKey.from_bytes( bytes.fromhex(policy_info["policy_pubkey"])) enrico_as_understood = Enrico.from_public_keys( { SigningPower: UmbralPublicKey.from_bytes( bytes.fromhex(receipt['data_source_public_key'])) }, #{SigningPower: data_source_public_key}, policy_encrypting_key=policy_pubkey) alice_pubkey_restored = UmbralPublicKey.from_bytes( (policy_info['alice_sig_pubkey'])) authorizedRecipient.join_policy(policy_info['label'].encode(), alice_pubkey_restored) kit = UmbralMessageKit.from_bytes(input) delivered_cleartexts = authorizedRecipient.retrieve( message_kit=kit, data_source=enrico_as_understood, alice_verifying_key=alice_pubkey_restored, label=(policy_info['label'].encode())) #delivered_cleartexts = authorizedRecipient.retrieve(message_kit=kit,data_source=data_source,alice_verifying_key=alice_pubkey_restored, label=(policy_info['label'].encode()) ) data = base64.b64decode(delivered_cleartexts[0]) output = open('./' + downloadFilename, 'wb') output.write(data) output.close()