def test_kfrag_roundtrip(d, b0, p0, p1, sig_proxy, sig_bob): k = KFrag(identifier=d, bn_key=b0, point_commitment=p0, point_precursor=p1, signature_for_proxy=sig_proxy, signature_for_bob=sig_bob) assert_kfrag_eq(k, KFrag.from_bytes(k.to_bytes()))
def reencrypt_via_rest(id_as_hex): from nucypher.policy.models import WorkOrder # Avoid circular import arrangement_id = binascii.unhexlify(id_as_hex) work_order = WorkOrder.from_rest_payload(arrangement_id, request.data) log.info("Work Order from {}, signed {}".format(work_order.bob, work_order.receipt_signature)) with ThreadedSession(db_engine) as session: policy_arrangement = datastore.get_policy_arrangement(arrangement_id=id_as_hex.encode(), session=session) kfrag_bytes = policy_arrangement.kfrag # Careful! :-) verifying_key_bytes = policy_arrangement.alice_pubkey_sig.key_data # TODO: Push this to a lower level. kfrag = KFrag.from_bytes(kfrag_bytes) alices_verifying_key = UmbralPublicKey.from_bytes(verifying_key_bytes) cfrag_byte_stream = b"" for capsule, capsule_signature in zip(work_order.capsules, work_order.capsule_signatures): # This is the capsule signed by Bob capsule_signature = bytes(capsule_signature) # Ursula signs on top of it. Now both are committed to the same capsule. capsule_signed_by_both = bytes(stamp(capsule_signature)) capsule.set_correctness_keys(verifying=alices_verifying_key) cfrag = pre.reencrypt(kfrag, capsule, metadata=capsule_signed_by_both) log.info("Re-encrypting for {}, made {}.".format(capsule, cfrag)) signature = stamp(bytes(cfrag) + bytes(capsule)) cfrag_byte_stream += VariableLengthBytestring(cfrag) + signature # TODO: Put this in Ursula's datastore work_order_tracker.append(work_order) headers = {'Content-Type': 'application/octet-stream'} return Response(response=cfrag_byte_stream, headers=headers)
def reencrypt(kfrag: KFrag, capsule: Capsule, provide_proof: bool = True, metadata: Optional[bytes] = None, verify_kfrag: bool = True) -> CapsuleFrag: if not isinstance(capsule, Capsule) or not capsule.verify(): raise Capsule.NotValid if verify_kfrag: if not isinstance(kfrag, KFrag) or not kfrag.verify_for_capsule(capsule): raise KFrag.NotValid rk = kfrag.bn_key e1 = rk * capsule.point_e # type: Any v1 = rk * capsule.point_v # type: Any cfrag = CapsuleFrag(point_e1=e1, point_v1=v1, kfrag_id=kfrag.id, point_precursor=kfrag.point_precursor) if provide_proof: cfrag.prove_correctness(capsule, kfrag, metadata) return cfrag
def test_federated_grant(federated_alice, federated_bob): # Setup the policy details m, n = 2, 3 policy_end_datetime = maya.now() + datetime.timedelta(days=5) label = b"this_is_the_path_to_which_access_is_being_granted" # Create the Policy, granting access to Bob policy = federated_alice.grant(federated_bob, label, m=m, n=n, expiration=policy_end_datetime) # Check the policy ID policy_id = keccak_digest(policy.label + bytes(policy.bob.stamp)) assert policy_id == policy.id # Check Alice's active policies assert policy_id in federated_alice.active_policies assert federated_alice.active_policies[policy_id] == policy # The number of accepted arrangements at least the number of Ursulas we're using (n) assert len(policy._accepted_arrangements) >= n # The number of actually enacted arrangements is exactly equal to n. assert len(policy._enacted_arrangements) == n # Let's look at the enacted arrangements. for kfrag in policy.kfrags: arrangement = policy._enacted_arrangements[kfrag] # Get the Arrangement from Ursula's datastore, looking up by the Arrangement ID. retrieved_policy = arrangement.ursula.datastore.get_policy_arrangement(arrangement.id.hex().encode()) retrieved_kfrag = KFrag.from_bytes(retrieved_policy.kfrag) assert kfrag == retrieved_kfrag
def set_policy(id_as_hex): """ REST endpoint for setting a kFrag. TODO: Instead of taking a Request, use the apistar typing system to type a payload and validate / split it. TODO: Validate that the kfrag being saved is pursuant to an approved Policy (see #121). """ policy_message_kit = UmbralMessageKit.from_bytes(request.data) alices_verifying_key = policy_message_kit.sender_verifying_key alice = _alice_class.from_public_keys(verifying_key=alices_verifying_key) try: cleartext = this_node.verify_from(alice, policy_message_kit, decrypt=True) except InvalidSignature: # TODO: Perhaps we log this? return Response(status_code=400) kfrag = KFrag.from_bytes(cleartext) if not kfrag.verify(signing_pubkey=alices_verifying_key): raise InvalidSignature("{} is invalid".format(kfrag)) with ThreadedSession(db_engine) as session: datastore.attach_kfrag_to_saved_arrangement( alice, id_as_hex, kfrag, session=session) # TODO: Sign the arrangement here. #495 return "" # TODO: Return A 200, with whatever policy metadata.
def create_keyfrag(): if not request.json or not 'id' in request.json or request.json['id'] in keyfrags.keys(): abort(400) k_id = request.json['id'] show_debug("Storing key fragment with id: " + str(k_id)) keyfrags[k_id] = { 'capsule': pre.Capsule.from_bytes(binascii.unhexlify(request.json['capsule'].encode()), params), 'keyfrag': KFrag.from_bytes(binascii.unhexlify(request.json['keyfrag'].encode()), SECP256K1), 'delegating': UmbralPublicKey.from_bytes(binascii.unhexlify(request.json['delegating'].encode()), params), 'receiving': UmbralPublicKey.from_bytes(binascii.unhexlify(request.json['receiving'].encode()), params), 'verifying': UmbralPublicKey.from_bytes(binascii.unhexlify(request.json['verifying'].encode()), params), 'rekeyfrag': None } show_debug('-- Delegating:' + request.json['delegating']) show_debug('-- Receiving:' + request.json['receiving']) now = time.time()*1000 keyfrags[k_id]['capsule'].set_correctness_keys(delegating=keyfrags[k_id]['delegating'], receiving=keyfrags[k_id]['receiving'], verifying=keyfrags[k_id]['verifying']) keyfrags[k_id]['rekeyfrag'] = pre.reencrypt(kfrag=keyfrags[k_id]['keyfrag'], capsule=keyfrags[k_id]['capsule']) end = time.time()*1000 enc_tot = end-now show_debug("-- Re-encrypted key fragment with id: " + str(k_id)) return jsonify({'time': enc_tot}), 201
def test_decentralized_grant(blockchain_alice, blockchain_bob, agency): # Setup the policy details n = 3 policy_end_datetime = maya.now() + datetime.timedelta(days=5) label = b"this_is_the_path_to_which_access_is_being_granted" # Create the Policy, Granting access to Bob policy = blockchain_alice.grant( bob=blockchain_bob, label=label, m=2, n=n, rate=int(1e18), # one ether expiration=policy_end_datetime) # Check the policy ID policy_id = keccak_digest(policy.label + bytes(policy.bob.stamp)) assert policy_id == policy.id # The number of accepted arrangements at least the number of Ursulas we're using (n) assert len(policy._accepted_arrangements) >= n # The number of actually enacted arrangements is exactly equal to n. assert len(policy._enacted_arrangements) == n # Let's look at the enacted arrangements. for kfrag in policy.kfrags: arrangement = policy._enacted_arrangements[kfrag] # Get the Arrangement from Ursula's datastore, looking up by the Arrangement ID. retrieved_policy = arrangement.ursula.datastore.get_policy_arrangement( arrangement.id.hex().encode()) retrieved_kfrag = KFrag.from_bytes(retrieved_policy.kfrag) assert kfrag == retrieved_kfrag # Test PolicyCredential w/o TreasureMap credential = policy.credential(with_treasure_map=False) assert credential.alice_verifying_key == policy.alice.stamp assert credential.label == policy.label assert credential.expiration == policy.expiration assert credential.policy_pubkey == policy.public_key assert credential.treasure_map is None cred_json = credential.to_json() deserialized_cred = PolicyCredential.from_json(cred_json) assert credential == deserialized_cred # Test PolicyCredential w/ TreasureMap credential = policy.credential() assert credential.alice_verifying_key == policy.alice.stamp assert credential.label == policy.label assert credential.expiration == policy.expiration assert credential.policy_pubkey == policy.public_key assert credential.treasure_map == policy.treasure_map cred_json = credential.to_json() deserialized_cred = PolicyCredential.from_json(cred_json) assert credential == deserialized_cred
def test_federated_grant(federated_alice, federated_bob): # Setup the policy details m, n = 2, 3 policy_end_datetime = maya.now() + datetime.timedelta(days=5) label = b"this_is_the_path_to_which_access_is_being_granted" # Create the Policy, granting access to Bob policy = federated_alice.grant(federated_bob, label, m=m, n=n, expiration=policy_end_datetime) # The number of accepted arrangements at least the number of Ursulas we're using (n) assert len(policy._accepted_arrangements) >= n # The number of actually enacted arrangements is exactly equal to n. assert len(policy._enacted_arrangements) == n # Let's look at the enacted arrangements. for kfrag in policy.kfrags: arrangement = policy._enacted_arrangements[kfrag] # Get the Arrangement from Ursula's datastore, looking up by hrac. # This will be changed in 180, when we use the Arrangement ID. proper_hrac = keccak_digest( bytes(federated_alice.stamp) + bytes(federated_bob.stamp) + label) retrieved_policy = arrangement.ursula.datastore.get_policy_arrangement( arrangement.id.hex().encode()) retrieved_kfrag = KFrag.from_bytes(retrieved_policy.kfrag) assert kfrag == retrieved_kfrag
def test_mocked_decentralized_grant(blockchain_alice, blockchain_bob, three_agents): # Monkey patch Policy Creation _token_agent, _miner_agent, policy_agent = three_agents policy_agent.blockchain.wait_for_receipt = MockPolicyCreation.wait_for_receipt policy_agent.contract.functions.createPolicy = MockPolicyCreation # Setup the policy details n = 3 policy_end_datetime = maya.now() + datetime.timedelta(days=5) label = b"this_is_the_path_to_which_access_is_being_granted" # Create the Policy, Granting access to Bob policy = blockchain_alice.grant(blockchain_bob, label, m=2, n=n, expiration=policy_end_datetime) # The number of accepted arrangements at least the number of Ursulas we're using (n) assert len(policy._accepted_arrangements) >= n # The number of actually enacted arrangements is exactly equal to n. assert len(policy._enacted_arrangements) == n # Let's look at the enacted arrangements. for kfrag in policy.kfrags: arrangement = policy._enacted_arrangements[kfrag] # Get the Arrangement from Ursula's datastore, looking up by the Arrangement ID. retrieved_policy = arrangement.ursula.datastore.get_policy_arrangement(arrangement.id.hex().encode()) retrieved_kfrag = KFrag.from_bytes(retrieved_policy.kfrag) assert kfrag == retrieved_kfrag
def set_policy(id_as_hex): """ REST endpoint for setting a kFrag. """ policy_message_kit = UmbralMessageKit.from_bytes(request.data) alices_verifying_key = policy_message_kit.sender_verifying_key alice = _alice_class.from_public_keys( verifying_key=alices_verifying_key) try: cleartext = this_node.verify_from(alice, policy_message_kit, decrypt=True) except InvalidSignature: # TODO: Perhaps we log this? Essentially 355. return Response(status_code=400) if not this_node.federated_only: # This splitter probably belongs somewhere canonical. transaction_splitter = BytestringSplitter(32) tx, kfrag_bytes = transaction_splitter(cleartext, return_remainder=True) try: # Get all of the arrangements and verify that we'll be paid. # TODO: We'd love for this part to be impossible to reduce the risk of collusion. #1274 arranged_addresses = this_node.policy_agent.fetch_arrangement_addresses_from_policy_txid( tx, timeout=this_node.synchronous_query_timeout) except TimeExhausted: # Alice didn't pay. Return response with that weird status code. this_node.suspicious_activities_witnessed['freeriders'].append( (alice, f"No transaction matching {tx}.")) return Response(status=402) this_node_has_been_arranged = this_node.checksum_address in arranged_addresses if not this_node_has_been_arranged: this_node.suspicious_activities_witnessed['freeriders'].append( (alice, f"The transaction {tx} does not list me as a Worker - it lists {arranged_addresses}." )) return Response(status=402) else: _tx = NO_BLOCKCHAIN_CONNECTION kfrag_bytes = cleartext kfrag = KFrag.from_bytes(kfrag_bytes) if not kfrag.verify(signing_pubkey=alices_verifying_key): raise InvalidSignature("{} is invalid".format(kfrag)) with datastore.describe(PolicyArrangement, id_as_hex, writeable=True) as policy_arrangement: if not policy_arrangement.alice_verifying_key == alice.stamp.as_umbral_pubkey( ): raise alice.SuspiciousActivity policy_arrangement.kfrag = kfrag # TODO: Sign the arrangement here. #495 return "" # TODO: Return A 200, with whatever policy metadata.
def reencrypt_via_rest(id_as_hex): from nucypher.policy.models import WorkOrder # Avoid circular import arrangement_id = binascii.unhexlify(id_as_hex) work_order = WorkOrder.from_rest_payload(arrangement_id, request.data) log.info("Work Order from {}, signed {}".format( work_order.bob, work_order.receipt_signature)) with ThreadedSession(db_engine) as session: policy_arrangement = datastore.get_policy_arrangement( arrangement_id=id_as_hex.encode(), session=session) kfrag_bytes = policy_arrangement.kfrag # Careful! :-) verifying_key_bytes = policy_arrangement.alice_pubkey_sig.key_data # TODO: Push this to a lower level. Perhaps to Ursula character? #619 kfrag = KFrag.from_bytes(kfrag_bytes) alices_verifying_key = UmbralPublicKey.from_bytes(verifying_key_bytes) cfrag_byte_stream = b"" alices_address = canonical_address_from_umbral_key( alices_verifying_key) if not alices_address == work_order.alice_address: message = f"This Bob ({work_order.bob}) sent an Alice's ETH address " \ f"({work_order.alice_address}) that doesn't match " \ f"the one I have ({alices_address})." raise SuspiciousActivity(message) bob_pubkey = work_order.bob.stamp.as_umbral_pubkey() if not work_order.alice_address_signature.verify( message=alices_address, verifying_key=bob_pubkey): message = f"This Bob ({work_order.bob}) sent an invalid signature of Alice's ETH address" raise InvalidSignature(message) # This is Bob's signature of Alice's verifying key as ETH address. alice_address_signature = bytes(work_order.alice_address_signature) for capsule, capsule_signature in zip(work_order.capsules, work_order.capsule_signatures): # This is the capsule signed by Bob capsule_signature = bytes(capsule_signature) # Ursula signs on top of it. Now both are committed to the same capsule. # She signs Alice's address too. ursula_signature = stamp(capsule_signature + alice_address_signature) capsule.set_correctness_keys(verifying=alices_verifying_key) cfrag = pre.reencrypt(kfrag, capsule, metadata=bytes(ursula_signature)) log.info(f"Re-encrypting for {capsule}, made {cfrag}.") signature = stamp(bytes(cfrag) + bytes(capsule)) cfrag_byte_stream += VariableLengthBytestring(cfrag) + signature # TODO: Put this in Ursula's datastore work_order_tracker.append(work_order) headers = {'Content-Type': 'application/octet-stream'} return Response(response=cfrag_byte_stream, headers=headers)
def reencrypt_via_rest(id_as_hex): # TODO: How to pass Ursula's identity evidence to Bob? #962 # 'Identity evidence' is a signature of her stamp with the checksum address from nucypher.policy.models import WorkOrder # Avoid circular import arrangement_id = binascii.unhexlify(id_as_hex) with ThreadedSession(db_engine) as session: policy_arrangement = datastore.get_policy_arrangement( arrangement_id=id_as_hex.encode(), session=session) kfrag_bytes = policy_arrangement.kfrag # Careful! :-) verifying_key_bytes = policy_arrangement.alice_pubkey_sig.key_data # TODO: Push this to a lower level. Perhaps to Ursula character? #619 kfrag = KFrag.from_bytes(kfrag_bytes) alices_verifying_key = UmbralPublicKey.from_bytes(verifying_key_bytes) alices_address = canonical_address_from_umbral_key( alices_verifying_key) work_order = WorkOrder.from_rest_payload(arrangement_id=arrangement_id, rest_payload=request.data, ursula_pubkey_bytes=bytes( this_node.stamp), alice_address=alices_address) log.info( f"Work Order from {work_order.bob}, signed {work_order.receipt_signature}" ) cfrag_byte_stream = b"" for task in work_order.tasks: # Ursula signs on top of Bob's signature of each task. # Now both are committed to the same task. See #259. reencryption_metadata = bytes( this_node.stamp(bytes(task.signature))) capsule = task.capsule capsule.set_correctness_keys(verifying=alices_verifying_key) cfrag = pre.reencrypt(kfrag, capsule, metadata=reencryption_metadata) log.info(f"Re-encrypting for {capsule}, made {cfrag}.") # Finally, Ursula commits to her result reencryption_signature = this_node.stamp(bytes(cfrag)) cfrag_byte_stream += VariableLengthBytestring( cfrag) + reencryption_signature # TODO: Put this in Ursula's datastore this_node._work_orders.append(work_order) headers = {'Content-Type': 'application/octet-stream'} return Response(response=cfrag_byte_stream, headers=headers)
def test_kfrag_serialization(alices_keys, bobs_keys, kfrags): delegating_privkey, signing_privkey = alices_keys _receiving_privkey, receiving_pubkey = bobs_keys for kfrag in kfrags: kfrag_bytes = kfrag.to_bytes() assert len(kfrag_bytes) == KFrag.expected_bytes_length() new_kfrag = KFrag.from_bytes(kfrag_bytes) assert new_kfrag.id == kfrag.id assert new_kfrag.bn_key == kfrag.bn_key assert new_kfrag.point_precursor == kfrag.point_precursor assert new_kfrag.point_commitment == kfrag.point_commitment assert new_kfrag.keys_in_signature == kfrag.keys_in_signature assert new_kfrag.signature_for_proxy == kfrag.signature_for_proxy assert new_kfrag.signature_for_bob == kfrag.signature_for_bob assert new_kfrag.verify(signing_pubkey=signing_privkey.get_pubkey(), delegating_pubkey=delegating_privkey.get_pubkey(), receiving_pubkey=receiving_pubkey) assert new_kfrag == kfrag
def reencrypt_via_rest(id_as_hex): # Get Policy Arrangement try: arrangement_id = binascii.unhexlify(id_as_hex) except (binascii.Error, TypeError): return Response(response=b'Invalid arrangement ID', status=405) try: with ThreadedSession(db_engine) as session: arrangement = datastore.get_policy_arrangement( arrangement_id=id_as_hex.encode(), session=session) except NotFound: return Response(response=arrangement_id, status=404) # Get KFrag # TODO: Yeah, well, what if this arrangement hasn't been enacted? 1702 kfrag = KFrag.from_bytes(arrangement.kfrag) # Get Work Order from nucypher.policy.collections import WorkOrder # Avoid circular import alice_verifying_key_bytes = arrangement.alice_verifying_key.key_data alice_verifying_key = UmbralPublicKey.from_bytes( alice_verifying_key_bytes) alice_address = canonical_address_from_umbral_key(alice_verifying_key) work_order_payload = request.data work_order = WorkOrder.from_rest_payload( arrangement_id=arrangement_id, rest_payload=work_order_payload, ursula=this_node, alice_address=alice_address) log.info( f"Work Order from {work_order.bob}, signed {work_order.receipt_signature}" ) # Re-encrypt response = this_node._reencrypt( kfrag=kfrag, work_order=work_order, alice_verifying_key=alice_verifying_key) # Now, Ursula saves this workorder to her database... with ThreadedSession(db_engine): this_node.datastore.save_workorder( bob_verifying_key=bytes(work_order.bob.stamp), bob_signature=bytes(work_order.receipt_signature), arrangement_id=work_order.arrangement_id) headers = {'Content-Type': 'application/octet-stream'} return Response(headers=headers, response=response)
def test_cfrags(): vector_file = os.path.join('vectors', 'vectors_cfrags.json') try: with open(vector_file) as f: vector_suite = json.load(f) except OSError: raise params = default_params() capsule = pre.Capsule.from_bytes(bytes.fromhex(vector_suite['capsule']), params=params) verifying_key = UmbralPublicKey.from_bytes( bytes.fromhex(vector_suite['verifying_key'])) delegating_key = UmbralPublicKey.from_bytes( bytes.fromhex(vector_suite['delegating_key'])) receiving_key = UmbralPublicKey.from_bytes( bytes.fromhex(vector_suite['receiving_key'])) kfrags_n_cfrags = [ (KFrag.from_bytes(bytes.fromhex(json_kfrag['kfrag'])), CapsuleFrag.from_bytes(bytes.fromhex(json_kfrag['cfrag']))) for json_kfrag in vector_suite['vectors'] ] capsule.set_correctness_keys(delegating=delegating_key, receiving=receiving_key, verifying=verifying_key) for kfrag, cfrag in kfrags_n_cfrags: assert kfrag.verify(signing_pubkey=verifying_key, delegating_pubkey=delegating_key, receiving_pubkey=receiving_key), \ 'Invalid KFrag {}'.format(kfrag.to_bytes().hex()) new_cfrag = pre.reencrypt(kfrag, capsule, provide_proof=False) assert new_cfrag.point_e1 == cfrag.point_e1 assert new_cfrag.point_v1 == cfrag.point_v1 assert new_cfrag.kfrag_id == cfrag.kfrag_id assert new_cfrag.point_precursor == cfrag.point_precursor assert new_cfrag.proof is None assert cfrag.to_bytes() == new_cfrag.to_bytes()
def reencrypt_data(alice_pub_key, bob_pub_key, alice_verify_key, capsule): kfrags_file = KFRAGS_FILE_FORMAT.format(bob_pub_key.to_bytes().hex()) try: with open(kfrags_file) as f: stored_kfrags = json.load(f) except FileNotFoundError as e: raise AccessError("Access Denied") kfrags = list() for kfrag_hex in stored_kfrags: kfrag = KFrag.from_bytes(bytes.fromhex(kfrag_hex)) kfrags.append(kfrag) capsule.set_correctness_keys(delegating=alice_pub_key, receiving=bob_pub_key, verifying=alice_verify_key) for kfrag in kfrags: cfrag = pre.reencrypt(kfrag=kfrag, capsule=capsule) capsule.attach_cfrag(cfrag)
def test_kfrags(): vector_file = os.path.join('vectors', 'vectors_kfrags.json') try: with open(vector_file) as f: vector_suite = json.load(f) except OSError: raise verifying_key = UmbralPublicKey.from_bytes( bytes.fromhex(vector_suite['verifying_key'])) delegating_key = UmbralPublicKey.from_bytes( bytes.fromhex(vector_suite['delegating_key'])) receiving_key = UmbralPublicKey.from_bytes( bytes.fromhex(vector_suite['receiving_key'])) for json_kfrag in vector_suite['vectors']: kfrag = KFrag.from_bytes(bytes.fromhex(json_kfrag['kfrag'])) assert kfrag.verify(signing_pubkey=verifying_key, delegating_pubkey=delegating_key, receiving_pubkey=receiving_key), \ 'Invalid KFrag {}'.format(kfrag.to_bytes().hex())
def de_route(): if not request.json: abort(400) capsule_raw = request.json['capsule'] capsule = Capsule.from_bytes(bytes.fromhex(capsule_raw), params) alices_public_key = getUmbralPublicFromHex( request.json['alices_public_key']) alices_verifying_key = getUmbralPublicFromHex( request.json['alices_verifying_key']) # ? maybe without 03 ciphertext = bytes.fromhex(request.json['ciphertext']) bobs_private_key = getUmbralPrivateFromHex( request.json['bobs_private_key']) # kfrags serialized_kfrags = request.json['kfrags'] kfrags = [] for skfrag in serialized_kfrags: kfrags.append(KFrag.from_bytes(bytes.fromhex(skfrag))) responce = de(capsule, alices_public_key, alices_verifying_key, ciphertext, bobs_private_key, kfrags) print(responce) return responce, 200
def test_decentralized_grant(blockchain_alice, blockchain_bob, agency): # Setup the policy details n = 3 policy_end_datetime = maya.now() + datetime.timedelta(days=5) label = b"this_is_the_path_to_which_access_is_being_granted" # Create the Policy, Granting access to Bob policy = blockchain_alice.grant( bob=blockchain_bob, label=label, m=2, n=n, value=int(1e18), # one ether expiration=policy_end_datetime) # Check the policy ID policy_id = keccak_digest(policy.label + bytes(policy.bob.stamp)) assert policy_id == policy.id # The number of accepted arrangements at least the number of Ursulas we're using (n) assert len(policy._accepted_arrangements) >= n # The number of actually enacted arrangements is exactly equal to n. assert len(policy._enacted_arrangements) == n # Let's look at the enacted arrangements. for kfrag in policy.kfrags: arrangement = policy._enacted_arrangements[kfrag] # Get the Arrangement from Ursula's datastore, looking up by the Arrangement ID. retrieved_policy = arrangement.ursula.datastore.get_policy_arrangement( arrangement.id.hex().encode()) retrieved_kfrag = KFrag.from_bytes(retrieved_policy.kfrag) assert kfrag == retrieved_kfrag
# file = open(os.getenv("CAPSULE"), 'rb') # The "rb" clause tells the open method to read the file as bytes # capsule_byte = file.read() # capsule = pre.Capsule.from_bytes(capsule_byte,params) public_key_byte= pickle.load(open(os.getenv("DELEGERPK"), 'rb')) public_key= keys.UmbralPublicKey.from_bytes(public_key_byte) verifying_key_byte= pickle.load(open(os.getenv("DELEGERVK"), 'rb')) verifying_key= keys.UmbralPublicKey.from_bytes(verifying_key_byte) Bob_public_key_byte= pickle.load(open(os.getenv("PK_PATH"), 'rb')) Bob_public_key= keys.UmbralPublicKey.from_bytes(Bob_public_key_byte) kfrags_byte= pickle.load(open('Ursulas/'+ os.getenv("FOR") +'/kfrag.cert', 'rb')) kfrags=[ KFrag.from_bytes(kfrag) for kfrag in kfrags_byte] kfrags_info= pickle.load(open('Ursulas/'+ os.getenv("FOR") +'/kfrags.info', 'rb')) kfrags = random.sample(kfrags, int(kfrags_info['N'])) correctness=capsule.set_correctness_keys(delegating=public_key,receiving=Bob_public_key,verifying=verifying_key) cfrags = list() if False in correctness: print ('Verification error') exit() else: for kfrag in kfrags: cfrag = pre.reencrypt(kfrag=kfrag, capsule=capsule ) cfrags.append(cfrag)
class KeyStore(object): """ A storage class of cryptographic keys. """ kfrag_splitter = BytestringSplitter(Signature, (KFrag, KFrag.expected_bytes_length())) def __init__(self, sqlalchemy_engine=None) -> None: """ Initalizes a KeyStore object. :param sqlalchemy_engine: SQLAlchemy engine object to create session """ self.engine = sqlalchemy_engine Session = sessionmaker(bind=sqlalchemy_engine) # This will probably be on the reactor thread for most production configs. # Best to treat like hot lava. self._session_on_init_thread = Session() def add_key(self, key, is_signing=True, session=None) -> Key: """ :param key: Keypair object to store in the keystore. :return: The newly added key object. """ session = session or self._session_on_init_thread fingerprint = fingerprint_from_key(key) key_data = bytes(key) new_key = Key(fingerprint, key_data, is_signing) session.add(new_key) session.commit() return new_key def get_key( self, fingerprint: bytes, session=None ) -> Union[keypairs.DecryptingKeypair, keypairs.SigningKeypair]: """ Returns a key from the KeyStore. :param fingerprint: Fingerprint, in bytes, of key to return :return: Keypair of the returned key. """ session = session or self._session_on_init_thread key = session.query(Key).filter_by(fingerprint=fingerprint).first() if not key: raise NotFound( "No key with fingerprint {} found.".format(fingerprint)) pubkey = UmbralPublicKey.from_bytes(key.key_data) return pubkey def del_key(self, fingerprint: bytes, session=None): """ Deletes a key from the KeyStore. :param fingerprint: Fingerprint of key to delete """ session = session or self._session_on_init_thread session.query(Key).filter_by(fingerprint=fingerprint).delete() session.commit() def add_policy_arrangement(self, expiration, id, kfrag=None, alice_pubkey_sig=None, alice_signature=None, session=None) -> PolicyArrangement: """ Creates a PolicyArrangement to the Keystore. :return: The newly added PolicyArrangement object """ session = session or self._session_on_init_thread alice_key_instance = session.query(Key).filter_by( key_data=bytes(alice_pubkey_sig)).first() if not alice_key_instance: alice_key_instance = Key.from_umbral_key(alice_pubkey_sig, is_signing=True) new_policy_arrangement = PolicyArrangement( expiration, id, kfrag, alice_pubkey_sig=alice_key_instance, alice_signature=None, # bob_pubkey_sig.id ) session.add(new_policy_arrangement) session.commit() return new_policy_arrangement def get_policy_arrangement(self, arrangement_id: bytes, session=None) -> PolicyArrangement: """ Returns the PolicyArrangement by its HRAC. :return: The PolicyArrangement object """ session = session or self._session_on_init_thread policy_arrangement = session.query(PolicyArrangement).filter_by( id=arrangement_id).first() if not policy_arrangement: raise NotFound( "No PolicyArrangement {} found.".format(arrangement_id)) return policy_arrangement def del_policy_arrangement(self, arrangement_id: bytes, session=None): """ Deletes a PolicyArrangement from the Keystore. """ session = session or self._session_on_init_thread session.query(PolicyArrangement).filter_by(id=arrangement_id).delete() session.commit() def attach_kfrag_to_saved_arrangement(self, alice, id_as_hex, kfrag, session=None): session = session or self._session_on_init_thread policy_arrangement = session.query(PolicyArrangement).filter_by( id=id_as_hex.encode()).first() if policy_arrangement is None: raise NotFound( "Can't attach a kfrag to non-existent Arrangement {}".format( id_as_hex)) if policy_arrangement.alice_pubkey_sig.key_data != alice.stamp: raise alice.SuspiciousActivity policy_arrangement.kfrag = bytes(kfrag) session.commit() def add_workorder(self, bob_pubkey_sig, bob_signature, arrangement_id, session=None) -> Workorder: """ Adds a Workorder to the keystore. """ session = session or self._session_on_init_thread bob_pubkey_sig = self.add_key(bob_pubkey_sig) new_workorder = Workorder(bob_pubkey_sig.id, bob_signature, arrangement_id) session.add(new_workorder) session.commit() return new_workorder def get_workorders(self, arrangement_id: bytes, session=None) -> Workorder: """ Returns a list of Workorders by HRAC. """ session = session or self._session_on_init_thread workorders = session.query(Workorder).filter_by( arrangement_id=arrangement_id) if not workorders: raise NotFound( "No Workorders with {} HRAC found.".format(arrangement_id)) return workorders def del_workorders(self, arrangement_id: bytes, session=None): """ Deletes a Workorder from the Keystore. """ session = session or self._session_on_init_thread workorders = session.query(Workorder).filter_by( arrangement_id=arrangement_id) deleted = workorders.delete() session.commit() return deleted
class Datastore: """ A storage class of persistent cryptographic entities for use by Ursula. """ kfrag_splitter = BytestringSplitter(Signature, (KFrag, KFrag.expected_bytes_length())) def __init__(self, sqlalchemy_engine=None) -> None: """ Initializes a Datastore object. :param sqlalchemy_engine: SQLAlchemy engine object to create session """ self.engine = sqlalchemy_engine Session = sessionmaker(bind=sqlalchemy_engine) # This will probably be on the reactor thread for most production configs. # Best to treat like hot lava. self._session_on_init_thread = Session() @staticmethod def __commit(session) -> None: try: session.commit() except OperationalError: session.rollback() raise # # Keys # def add_key(self, key: UmbralPublicKey, is_signing: bool = True, session=None) -> Key: """ :param key: Keypair object to store in the keystore. :return: The newly added key object. """ session = session or self._session_on_init_thread fingerprint = fingerprint_from_key(key) key_data = bytes(key) new_key = Key(fingerprint, key_data, is_signing) session.add(new_key) self.__commit(session=session) return new_key def get_key(self, fingerprint: bytes, session=None) -> UmbralPublicKey: """ Returns a key from the Datastore. :param fingerprint: Fingerprint, in bytes, of key to return :return: Keypair of the returned key. """ session = session or self._session_on_init_thread key = session.query(Key).filter_by(fingerprint=fingerprint).first() if not key: raise NotFound( "No key with fingerprint {} found.".format(fingerprint)) pubkey = UmbralPublicKey.from_bytes(key.key_data) return pubkey def del_key(self, fingerprint: bytes, session=None): """ Deletes a key from the Datastore. :param fingerprint: Fingerprint of key to delete """ session = session or self._session_on_init_thread session.query(Key).filter_by(fingerprint=fingerprint).delete() self.__commit(session=session) # # Arrangements # def add_policy_arrangement( self, expiration: maya.MayaDT, arrangement_id: bytes, kfrag: KFrag = None, alice_verifying_key: UmbralPublicKey = None, alice_signature: Signature = None, # TODO: Why is this unused? session=None) -> PolicyArrangement: """ Creates a PolicyArrangement to the Keystore. :return: The newly added PolicyArrangement object """ session = session or self._session_on_init_thread alice_key_instance = session.query(Key).filter_by( key_data=bytes(alice_verifying_key)).first() if not alice_key_instance: alice_key_instance = Key.from_umbral_key(alice_verifying_key, is_signing=True) new_policy_arrangement = PolicyArrangement( expiration=expiration, id=arrangement_id, kfrag=kfrag, alice_verifying_key=alice_key_instance, alice_signature=None, # bob_verifying_key.id # TODO: Is this needed? ) session.add(new_policy_arrangement) self.__commit(session=session) return new_policy_arrangement def get_policy_arrangement(self, arrangement_id: bytes, session=None) -> PolicyArrangement: """ Retrieves a PolicyArrangement by its HRAC. :return: The PolicyArrangement object """ session = session or self._session_on_init_thread policy_arrangement = session.query(PolicyArrangement).filter_by( id=arrangement_id).first() if not policy_arrangement: raise NotFound( "No PolicyArrangement {} found.".format(arrangement_id)) return policy_arrangement def get_all_policy_arrangements(self, session=None) -> List[PolicyArrangement]: """ Returns all the PolicyArrangements :return: The list of PolicyArrangement objects """ session = session or self._session_on_init_thread arrangements = session.query(PolicyArrangement).all() return arrangements def attach_kfrag_to_saved_arrangement(self, alice, id_as_hex, kfrag, session=None): session = session or self._session_on_init_thread policy_arrangement = session.query(PolicyArrangement).filter_by( id=id_as_hex.encode()).first() if policy_arrangement is None: raise NotFound( "Can't attach a kfrag to non-existent Arrangement {}".format( id_as_hex)) if policy_arrangement.alice_verifying_key.key_data != alice.stamp: raise alice.SuspiciousActivity policy_arrangement.kfrag = bytes(kfrag) self.__commit(session=session) def del_policy_arrangement(self, arrangement_id: bytes, session=None) -> int: """ Deletes a PolicyArrangement from the Keystore. """ session = session or self._session_on_init_thread deleted_records = session.query(PolicyArrangement).filter_by( id=arrangement_id).delete() self.__commit(session=session) return deleted_records def del_expired_policy_arrangements(self, session=None, now=None) -> int: """ Deletes all expired PolicyArrangements from the Keystore. """ session = session or self._session_on_init_thread now = now or datetime.now() result = session.query(PolicyArrangement).filter( PolicyArrangement.expiration <= now) deleted_records = 0 if result.count() > 0: deleted_records = result.delete() self.__commit(session=session) return deleted_records # # Work Orders # def save_workorder(self, bob_verifying_key: UmbralPublicKey, bob_signature: Signature, arrangement_id: bytes, session=None) -> Workorder: """ Adds a Workorder to the keystore. """ session = session or self._session_on_init_thread # Get or Create Bob Verifying Key fingerprint = fingerprint_from_key(bob_verifying_key) key = session.query(Key).filter_by(fingerprint=fingerprint).first() if not key: key = self.add_key(key=bob_verifying_key) new_workorder = Workorder(bob_verifying_key_id=key.id, bob_signature=bob_signature, arrangement_id=arrangement_id) session.add(new_workorder) self.__commit(session=session) return new_workorder def get_workorders(self, arrangement_id: bytes = None, bob_verifying_key: bytes = None, session=None) -> List[Workorder]: """ Returns a list of Workorders by HRAC. """ session = session or self._session_on_init_thread query = session.query(Workorder) if not arrangement_id and not bob_verifying_key: workorders = query.all() # Return all records else: # Return arrangement records if arrangement_id: workorders = query.filter_by(arrangement_id=arrangement_id) # Return records for Bob else: fingerprint = fingerprint_from_key(bob_verifying_key) key = session.query(Key).filter_by( fingerprint=fingerprint).first() workorders = query.filter_by(bob_verifying_key_id=key.id) if not workorders: raise NotFound return list(workorders) def del_workorders(self, arrangement_id: bytes, session=None) -> int: """ Deletes a Workorder from the Keystore. """ session = session or self._session_on_init_thread workorders = session.query(Workorder).filter_by( arrangement_id=arrangement_id) deleted = workorders.delete() self.__commit(session=session) return deleted
def test_bob_can_issue_a_work_order_to_a_specific_ursula(enacted_federated_policy, federated_bob, federated_alice, federated_ursulas, capsule_side_channel): """ Now that Bob has his list of Ursulas, he can issue a WorkOrder to one. Upon receiving the WorkOrder, Ursula saves it and responds by re-encrypting and giving Bob a cFrag. This is a multipart test; it shows proper relations between the Characters Ursula and Bob and also proper interchange between a KFrag, Capsule, and CFrag object in the context of REST-driven proxy re-encryption. """ # We pick up our story with Bob already having followed the treasure map above, ie: hrac, treasure_map = enacted_federated_policy.hrac(), enacted_federated_policy.treasure_map map_id = treasure_map.public_id() federated_bob.treasure_maps[map_id] = treasure_map federated_bob.start_learning_loop() federated_bob.follow_treasure_map(map_id=map_id, block=True, timeout=1) assert len(federated_bob.known_nodes) == len(federated_ursulas) # Bob has no saved work orders yet, ever. assert len(federated_bob._saved_work_orders) == 0 # We'll test against just a single Ursula - here, we make a WorkOrder for just one. # We can pass any number of capsules as args; here we pass just one. capsule = capsule_side_channel[0].capsule capsule.set_correctness_keys(delegating=enacted_federated_policy.public_key, receiving=federated_bob.public_keys(DecryptingPower), verifying=federated_alice.stamp.as_umbral_pubkey()) work_orders = federated_bob.generate_work_orders(map_id, capsule, num_ursulas=1) # Again: one Ursula, one work_order. assert len(work_orders) == 1 # Bob saved the WorkOrder. assert len(federated_bob._saved_work_orders) == 1 # And the Ursula. assert len(federated_bob._saved_work_orders.ursulas) == 1 ursula_id, work_order = list(work_orders.items())[0] # The work order is not yet complete, of course. assert work_order.completed is False # **** RE-ENCRYPTION HAPPENS HERE! **** cfrags = federated_bob.get_reencrypted_cfrags(work_order) # We only gave one Capsule, so we only got one cFrag. assert len(cfrags) == 1 the_cfrag = cfrags[0] # ...and the work order is complete. assert work_order.completed # Attach the CFrag to the Capsule. capsule.attach_cfrag(the_cfrag) # Having received the cFrag, Bob also saved the WorkOrder as complete. assert len(federated_bob._saved_work_orders.by_ursula[ursula_id]) == 1 # OK, so cool - Bob has his cFrag! Let's make sure everything went properly. First, we'll show that it is in fact # the correct cFrag (ie, that Ursula performed re-encryption properly). for u in federated_ursulas: if u.rest_information()[0].port == work_order.ursula.rest_information()[0].port: ursula = u break else: raise RuntimeError("We've lost track of the Ursula that has the WorkOrder. Can't really proceed.") kfrag_bytes = ursula.datastore.get_policy_arrangement( work_order.arrangement_id.hex().encode()).kfrag the_kfrag = KFrag.from_bytes(kfrag_bytes) the_correct_cfrag = pre.reencrypt(the_kfrag, capsule) # The first CFRAG_LENGTH_WITHOUT_PROOF bytes (ie, the cfrag proper, not the proof material), are the same: assert bytes(the_cfrag)[:CapsuleFrag.expected_bytes_length()] == bytes( the_correct_cfrag)[:CapsuleFrag.expected_bytes_length()] # It's the correct cfrag! assert the_correct_cfrag.verify_correctness(capsule) # Now we'll show that Ursula saved the correct WorkOrder. work_orders_from_bob = ursula.work_orders(bob=federated_bob) assert len(work_orders_from_bob) == 1 assert work_orders_from_bob[0] == work_order
# kfrags_dict = {} # kfrags_dict["kfrags"] = [ KFrag.to_bytes(kfrag) for kfrag in kfrags] # kfrags_dict["FOR"]= os.getenv("FOR") # kfrags_dict["THRESHOLD"]= os.getenv("THRESHOLD") # kfrags_dict["N"]= os.getenv("N") kfrags_info = {} kfrags_info["FOR"] = os.getenv("FOR") kfrags_info["THRESHOLD"] = os.getenv("THRESHOLD") kfrags_info["N"] = os.getenv("N") outfile = open('Ursulas/' + os.getenv("FOR") + '/kfrags.info', 'wb') pickle.dump(kfrags_info, outfile) outfile.close() kfrags = [KFrag.to_bytes(kfrag) for kfrag in kfrags] outfile = open('Ursulas/' + os.getenv("FOR") + '/kfrag.cert', 'wb') pickle.dump(kfrags, outfile) outfile.close() # s=json.dumps(variables) # variables2=json.loads(s) # assert(variables==variables2) # outfile.write(str(kfrags)) # outfile.close() # outfile = open('Ursulas/'+ os.getenv("FOR") +'/kfrag.cert','wb') # kfrags_dict = {} # kfrags_dict[os.getenv("FOR")] = kfrags # # pickle.dump(kfrags_dict,outfile)
import base64 import sys from umbral import pre, keys from umbral.kfrags import KFrag from umbral.config import default_curve from umbral.params import UmbralParameters encoded_kfrags = sys.argv[1].split(',') for idx, row in enumerate(encoded_kfrags): encoded_kfrags[idx] = KFrag.from_bytes(base64.b64decode(row)) kfrags = tuple(encoded_kfrags) params = UmbralParameters(default_curve()) capsule = pre.Capsule.from_bytes(base64.b64decode(sys.argv[2]), params) ciphertext = base64.b64decode(sys.argv[3]) bobs_private_key = keys.UmbralPrivateKey.from_bytes( base64.b64decode(sys.argv[4])) bobs_public_key = keys.UmbralPublicKey.from_bytes(base64.b64decode( sys.argv[5])) alice_public_key = keys.UmbralPublicKey.from_bytes( base64.b64decode(sys.argv[6])) capsule.set_correctness_keys(alice_public_key, bobs_public_key, alice_public_key) for kfrag in kfrags: cfrag = pre.reencrypt(kfrag, capsule) capsule.attach_cfrag(cfrag) cleartext = pre.decrypt(ciphertext, capsule, bobs_private_key, alice_public_key)
def generate_kfrags( delegating_privkey: UmbralPrivateKey, receiving_pubkey: UmbralPublicKey, threshold: int, N: int, signer: Signer, sign_delegating_key: Optional[bool] = True, sign_receiving_key: Optional[bool] = True, ) -> List[KFrag]: """ Creates a re-encryption key from Alice's delegating public key to Bob's receiving public key, and splits it in KFrags, using Shamir's Secret Sharing. Requires a threshold number of KFrags out of N. Returns a list of N KFrags """ if threshold <= 0 or threshold > N: raise ValueError( 'Arguments threshold and N must satisfy 0 < threshold <= N') if delegating_privkey.params != receiving_pubkey.params: raise ValueError("Keys must have the same parameter set.") params = delegating_privkey.params g = params.g delegating_pubkey = delegating_privkey.get_pubkey() bob_pubkey_point = receiving_pubkey.point_key # The precursor point is used as an ephemeral public key in a DH key exchange, # and the resulting shared secret 'dh_point' is used to derive other secret values private_precursor = CurveBN.gen_rand(params.curve) precursor = private_precursor * g # type: Any dh_point = private_precursor * bob_pubkey_point # Secret value 'd' allows to make Umbral non-interactive d = hash_to_curvebn(precursor, bob_pubkey_point, dh_point, bytes(constants.NON_INTERACTIVE), params=params) # Coefficients of the generating polynomial coefficients = [delegating_privkey.bn_key * (~d)] coefficients += [ CurveBN.gen_rand(params.curve) for _ in range(threshold - 1) ] bn_size = CurveBN.expected_bytes_length(params.curve) kfrags = list() for _ in range(N): kfrag_id = os.urandom(bn_size) # The index of the re-encryption key share (which in Shamir's Secret # Sharing corresponds to x in the tuple (x, f(x)), with f being the # generating polynomial), is used to prevent reconstruction of the # re-encryption key without Bob's intervention share_index = hash_to_curvebn(precursor, bob_pubkey_point, dh_point, bytes(constants.X_COORDINATE), kfrag_id, params=params) # The re-encryption key share is the result of evaluating the generating # polynomial for the index value rk = poly_eval(coefficients, share_index) commitment = rk * params.u # type: Any validity_message_for_bob = ( kfrag_id, delegating_pubkey, receiving_pubkey, commitment, precursor, ) # type: Any validity_message_for_bob = bytes().join( bytes(item) for item in validity_message_for_bob) signature_for_bob = signer(validity_message_for_bob) if sign_delegating_key and sign_receiving_key: mode = DELEGATING_AND_RECEIVING elif sign_delegating_key: mode = DELEGATING_ONLY elif sign_receiving_key: mode = RECEIVING_ONLY else: mode = NO_KEY validity_message_for_proxy = [kfrag_id, commitment, precursor, mode] # type: Any if sign_delegating_key: validity_message_for_proxy.append(delegating_pubkey) if sign_receiving_key: validity_message_for_proxy.append(receiving_pubkey) validity_message_for_proxy = bytes().join( bytes(item) for item in validity_message_for_proxy) signature_for_proxy = signer(validity_message_for_proxy) kfrag = KFrag( identifier=kfrag_id, bn_key=rk, point_commitment=commitment, point_precursor=precursor, signature_for_proxy=signature_for_proxy, signature_for_bob=signature_for_bob, keys_in_signature=mode, ) kfrags.append(kfrag) return kfrags
def reencrypt(): api = ipfsapi.connect('127.0.0.1', 5001) addrs = list() caddrs = list() res = {} if request.headers['Content-Type'] == 'application/json': account = request.json['account'] # 所有的传入参数都是hex key threshold = request.json['threshold'] capsulehex = request.json['capsule'] b_capsule = api.cat(capsulehex) capsule = Capsule.from_bytes(b_capsule, UmbralParameters(Curve(714))) addrs = request.json['addresses'] delegatinghex = request.json['delegating'] b_delegating = bytes.fromhex(delegatinghex) delegating = UmbralPublicKey.from_bytes(b_delegating) receivinghex = request.json['receiving'] b_receiving = bytes.fromhex(receivinghex) receiving = UmbralPublicKey.from_bytes(b_receiving) verifyinghex = request.json['verifying'] b_verifying = bytes.fromhex(verifyinghex) verifying = UmbralPublicKey.from_bytes(b_verifying) if threshold > len(addrs): return "Not enough addresses." capsule.set_correctness_keys(delegating=delegating, receiving=receiving, verifying=verifying) cfrags = list() # Receiver's cfrag collection # each kfrag is a rk segment for addr in addrs: rkseg = KFrag.from_bytes(api.cat(addr)) # cfrag = pre.reencrypt(kfrag=kfrag, capsule=capsule) cfrag = pre.reencrypt(kfrag=rkseg, capsule=capsule) cfrags.append(cfrag) # Receiver's collects a cfrag for cfrag in cfrags: caddrs.append(api.add_bytes(cfrag.to_bytes())) savedcap = capsule.to_bytes_all() # savedcap包括三块,basic为capsule,correctness为set的key,cfrag是append上去的东西,此时还为空 print(type(savedcap)) print(type(savedcap['basic'])) print(savedcap['correctness']) delegating_key = savedcap['correctness']['delegating'] receiving_key = savedcap['correctness']['receiving'] verifying_key = savedcap['correctness']['verifying'] b_delegating_key = delegating_key.to_bytes() b_receiving_key = receiving_key.to_bytes() b_verifying_key = verifying_key.to_bytes() print(b_delegating_key) print(b_receiving_key) print(b_verifying_key) sendbytes = savedcap[ 'basic'] + b'ZAtech' + b_delegating_key + b'ZBtech' + b_receiving_key + b'ZBtech' + b_verifying_key print(sendbytes) savedcapaddr = api.add_bytes(sendbytes) res = {"caddrs": caddrs, "capsule": savedcapaddr} return jsonify(res), {'Content-Type': 'application/json'} return
for kfrag_hex in kfrags: kfrag_hex = kfrag_hex.to_bytes().hex() kfrags_hex.append(kfrag_hex) # print("************************** random `kfrags_hex`") # print(kfrags_hex) # Bob collects the resulting `cfrags` from several Ursulas. # Bob must gather at least `threshold` `cfrags` in order to activate the capsule. bob_capsule.set_correctness_keys(delegating=alices_public_key, receiving=bobs_public_key, verifying=alices_verifying_key) cfrags = list() # Bob's cfrag collection cfrags_hex = list() for kfrag_h in kfrags_hex: kfrag_from_hex = KFrag.from_bytes(bytes.fromhex(kfrag_h)) cfrag = pre.reencrypt(kfrag=kfrag_from_hex, capsule=bob_capsule) cfrag_hex = cfrag.to_bytes().hex() cfrags_hex.append(cfrag_hex) cfrags.append(cfrag) # Bob collects a cfrag assert len(cfrags) == 10 # pprint("$$$$$$$$$$cfrags --------------------") ##pprint(cfrags_hex_from_file) # receive from server for cfrag in cfrags: # cfrags_from_hex = CapsuleFrag.from_bytes(bytes.fromhex(cfrag_hex_from_file)) ##pprint(cfrags_from_hex) bob_capsule.attach_cfrag(cfrag) #for cfrag in cfrags:
def test_lifecycle_with_serialization(N, M, signing_mode, curve=default_curve()): """ This test is a variant of test_simple_api, but with intermediate serialization/deserialization steps, modeling how pyUmbral artifacts (such as keys, ciphertexts, etc) will actually be used. These intermediate steps are in between the different 'usage domains' in NuCypher, namely, key generation, delegation, encryption, decryption by Alice, re-encryption by Ursula, and decryption by Bob. Manually injects UmbralParameters for multi-curve testing. """ # Convenience method to avoid replicating key generation code def new_keypair_bytes(): privkey = UmbralPrivateKey.gen_key(params=params) return privkey.to_bytes(), privkey.get_pubkey().to_bytes() ## SETUP params = UmbralParameters(curve=curve) delegating_privkey_bytes, delegating_pubkey_bytes = new_keypair_bytes() signing_privkey_bytes, signing_pubkey_bytes = new_keypair_bytes() receiving_privkey_bytes, receiving_pubkey_bytes = new_keypair_bytes() ## DELEGATION DOMAIN: ## Alice delegates decryption rights to some Bob by generating a set of ## KFrags, using her delegating private key and Bob's receiving public key delegating_privkey = UmbralPrivateKey.from_bytes(delegating_privkey_bytes, params=params) signing_privkey = UmbralPrivateKey.from_bytes(signing_privkey_bytes, params=params) receiving_pubkey = UmbralPublicKey.from_bytes(receiving_pubkey_bytes, params=params) signer = Signer(signing_privkey) sign_delegating_key, sign_receiving_key = signing_mode kfrags = pre.generate_kfrags(delegating_privkey=delegating_privkey, receiving_pubkey=receiving_pubkey, threshold=M, N=N, signer=signer, sign_delegating_key=sign_delegating_key, sign_receiving_key=sign_receiving_key) kfrags_bytes = tuple(map(bytes, kfrags)) del kfrags del signer del delegating_privkey del signing_privkey del receiving_pubkey del params ## ENCRYPTION DOMAIN ## params = UmbralParameters(curve=curve) delegating_pubkey = UmbralPublicKey.from_bytes(delegating_pubkey_bytes, params) plain_data = b'peace at dawn' ciphertext, capsule = pre.encrypt(delegating_pubkey, plain_data) capsule_bytes = bytes(capsule) del capsule del delegating_pubkey del params ## DECRYPTION BY ALICE ## params = UmbralParameters(curve=curve) delegating_privkey = UmbralPrivateKey.from_bytes(delegating_privkey_bytes, params=params) capsule = pre.Capsule.from_bytes(capsule_bytes, params) cleartext = pre.decrypt(ciphertext, capsule, delegating_privkey) assert cleartext == plain_data del delegating_privkey del capsule del params ## RE-ENCRYPTION DOMAIN (i.e., Ursula's side) cfrags_bytes = list() for kfrag_bytes in kfrags_bytes: params = UmbralParameters(curve=curve) delegating_pubkey = UmbralPublicKey.from_bytes(delegating_pubkey_bytes, params) signing_pubkey = UmbralPublicKey.from_bytes(signing_pubkey_bytes, params) receiving_pubkey = UmbralPublicKey.from_bytes(receiving_pubkey_bytes, params) capsule = pre.Capsule.from_bytes(capsule_bytes, params) capsule.set_correctness_keys(delegating=delegating_pubkey, receiving=receiving_pubkey, verifying=signing_pubkey) # TODO: use params instead of curve? kfrag = KFrag.from_bytes(kfrag_bytes, params.curve) assert kfrag.verify(signing_pubkey, delegating_pubkey, receiving_pubkey, params) cfrag_bytes = bytes(pre.reencrypt(kfrag, capsule)) cfrags_bytes.append(cfrag_bytes) del capsule del kfrag del params del delegating_pubkey del signing_pubkey del receiving_pubkey ## DECRYPTION DOMAIN (i.e., Bob's side) params = UmbralParameters(curve=curve) capsule = pre.Capsule.from_bytes(capsule_bytes, params) delegating_pubkey = UmbralPublicKey.from_bytes(delegating_pubkey_bytes, params) signing_pubkey = UmbralPublicKey.from_bytes(signing_pubkey_bytes, params) receiving_privkey = UmbralPrivateKey.from_bytes(receiving_privkey_bytes, params=params) receiving_pubkey = receiving_privkey.get_pubkey() capsule.set_correctness_keys(delegating=delegating_pubkey, receiving=receiving_pubkey, verifying=signing_pubkey) for cfrag_bytes in cfrags_bytes: # TODO: use params instead of curve? cfrag = CapsuleFrag.from_bytes(cfrag_bytes, params.curve) capsule.attach_cfrag(cfrag) reenc_cleartext = pre.decrypt(ciphertext, capsule, receiving_privkey) assert reenc_cleartext == plain_data