Ejemplo n.º 1
0
    def add_contents(self, alicia, my_label, contents): 
        """
        cid = client.add_contents(
            policy_pubkey=policy_pub_key
        )
        """
        policy_pubkey = alicia.get_policy_pubkey_from_label(my_label)

        data_source = Enrico(policy_encrypting_key=policy_pubkey)
        data_source_public_key = bytes(data_source.stamp)
        heart_rate = 80
        now = time.time()
        kits = list()
        heart_rate = contents
        now += 3
        heart_rate_data = { 'heart_rate': heart_rate, 'timestamp': now, }
        plaintext = msgpack.dumps(heart_rate_data, use_bin_type=True)
        message_kit, _signature = data_source.encrypt_message(plaintext)
        kit_bytes = message_kit.to_bytes()
        kits.append(kit_bytes)
        data = { 'data_source': data_source_public_key, 'kits': kits, }
#         print("🚀 ADDING TO IPFS D-STORAGE NETWORK 🚀")
        d = msgpack.dumps(data, use_bin_type=True)

        ### NETWORK ERROR OUT ON FALLBACK 
        cid = self.ipfs_gateway_api.add_bytes(d)
#         print("File Address:\t%s" % cid)
        return cid
Ejemplo n.º 2
0
def enrico(click_config, action, policy_encrypting_key, dry_run, http_port,
           message):
    """
    "Enrico the Encryptor" management commands.
    """

    #
    # Validate
    #

    if not policy_encrypting_key:
        raise click.BadArgumentUsage(
            '--policy-encrypting-key is required to start Enrico.')

    # Banner
    emitter = click_config.emitter
    emitter.clear()
    emitter.banner(ENRICO_BANNER.format(policy_encrypting_key))

    #
    # Make Enrico
    #

    policy_encrypting_key = UmbralPublicKey.from_bytes(
        bytes.fromhex(policy_encrypting_key))
    ENRICO = Enrico(policy_encrypting_key=policy_encrypting_key)
    ENRICO.controller.emitter = emitter  # TODO: set it on object creation? Or not set at all?

    #
    # Actions
    #

    if action == 'run':

        # RPC
        if click_config.json_ipc:
            rpc_controller = ENRICO.make_rpc_controller()
            _transport = rpc_controller.make_control_transport()
            rpc_controller.start()
            return

        ENRICO.log.info('Starting HTTP Character Web Controller')
        controller = ENRICO.make_web_controller()
        return controller.start(http_port=http_port, dry_run=dry_run)

    elif action == 'encrypt':

        # Validate
        if not message:
            raise click.BadArgumentUsage(
                '--message is a required flag to encrypt.')

        # Request
        encryption_request = {'message': message}
        response = ENRICO.controller.encrypt_message(
            request=encryption_request)
        return response

    else:
        raise click.BadArgumentUsage
    def uploadData(self, label, file):

        policy_pubkey = self.Alice.get_policy_encrypting_key_from_label(label.encode("utf-8"))

        data_source = Enrico(policy_encrypting_key=policy_pubkey)
        data_source_public_key = bytes(data_source.stamp)

        now = time.time()
        kits = list()
        now += 5
        data_representation = { 'data': file, 'timestamp': now, }
        plaintext = msgpack.dumps(data_representation, use_bin_type=True)

        message_kit, _signature = data_source.encrypt_message(plaintext)
        kit_bytes = message_kit.to_bytes()
        kits.append(kit_bytes)
        data = { 'data_source': data_source_public_key, 'kits': kits, }
        d = msgpack.dumps(data, use_bin_type=True)

        ipfs_hash = self.ipfs_gateway_api.add_bytes(d)

        receipt = {
            "data_source_public_key" : data_source_public_key.hex(),
            "hash_key" : ipfs_hash
        }
        return receipt
Ejemplo n.º 4
0
 def __call__(self):
     enrico = Enrico(
         policy_encrypting_key=enacted_blockchain_policy.public_key)
     message = "Welcome to flippering number {}.".format(
         len(self.messages)).encode()
     message_kit, _signature = enrico.encrypt_message(message)
     self.messages.append((message_kit, enrico))
     return message_kit, enrico
Ejemplo n.º 5
0
def enrico(click_config, action, policy_encrypting_key, dry_run, http_port, message):
    """
    Start and manage an "Enrico" character control HTTP server
    """

    #
    # Validate
    #

    if not policy_encrypting_key:
        raise click.BadArgumentUsage('--policy-encrypting-key is required to start Enrico.')

    # Banner
    click.clear()
    if not click_config.json_ipc and not click_config.quiet:
        click.secho(ENRICO_BANNER)

    #
    # Make Enrico
    #

    policy_encrypting_key = UmbralPublicKey.from_bytes(bytes.fromhex(policy_encrypting_key))
    ENRICO = Enrico(policy_encrypting_key=policy_encrypting_key)
    if click_config.json_ipc:
        ENRICO.controller.emitter = JSONRPCStdoutEmitter(quiet=click_config.quiet)

    #
    # Actions
    #

    if action == 'run':

        # RPC
        if click_config.json_ipc:
            rpc_controller = ENRICO.make_rpc_controller()
            _transport = rpc_controller.make_control_transport()
            rpc_controller.start()
            return

        ENRICO.log.info('Starting HTTP Character Web Controller')
        controller = ENRICO.make_web_controller()
        return controller.start(http_port=http_port, dry_run=dry_run)

    elif action == 'encrypt':

        # Validate
        if not message:
            raise click.BadArgumentUsage('--message is a required flag to encrypt.')

        # Request
        encryption_request = {'message': message}
        response = ENRICO.controller.encrypt_message(request=encryption_request)
        return response

    else:
        raise click.BadArgumentUsage
Ejemplo n.º 6
0
 def post(self):
     policy_key = request.json['policy_pubkey']
     data = request.json['data']
     enrico = Enrico(policy_encrypting_key=UmbralPublicKey.from_bytes(
         bytes.fromhex(policy_key)))
     message_kit, _signature = enrico.encrypt_message(data.encode())
     result = {}
     result["ciphertext"] = message_kit.to_bytes().hex()
     result["enrico"] = bytes(enrico.stamp).hex()
     return json.dumps(result)
Ejemplo n.º 7
0
def _make_message_kits(policy_pubkey):
    messages = [b"plaintext1", b"plaintext2", b"plaintext3"]

    message_kits = []
    for message in messages:
        # Using different Enricos, because why not.
        enrico = Enrico(policy_encrypting_key=policy_pubkey)
        message_kit = enrico.encrypt_message(message)
        message_kits.append(message_kit)

    return messages, message_kits
def test_alice_can_decrypt(federated_alice):
    label = b"boring test label"

    policy_pubkey = federated_alice.get_policy_encrypting_key_from_label(label)

    enrico = Enrico(policy_encrypting_key=policy_pubkey)

    message = b"boring test message"
    message_kit = enrico.encrypt_message(plaintext=message)

    # Interesting thing: if Alice wants to decrypt, she needs to provide the label directly.
    cleartexts = federated_alice.decrypt_message_kit(label=label,
                                                     message_kit=message_kit)
    assert cleartexts == [message]
Ejemplo n.º 9
0
def reencrypt_segment(enc_data, policy_metadata, listener):
    policy_pubkey = UmbralPublicKey.from_bytes(
        bytes.fromhex(policy_metadata["policy_pubkey"]))
    alices_sig_pubkey = UmbralPublicKey.from_bytes(
        bytes.fromhex(policy_metadata["alice_sig_pubkey"]))
    label = policy_metadata["label"].encode()

    data = msgpack.loads(enc_data)
    message_kit = UmbralMessageKit.from_bytes((data[b'track_segment_data']))
    data_source = Enrico.from_public_keys(verifying_key=data[b'data_source'],
                                          policy_encrypting_key=policy_pubkey)
    plaintext = None
    try:
        start = timer()
        retrieved_plaintexts = listener.retrieve(
            message_kit,
            label=label,
            enrico=data_source,
            alice_verifying_key=alices_sig_pubkey)
        end = timer()
        plaintext = retrieved_plaintexts[0]

    except Exception as e:
        # We just want to know what went wrong and continue the demo
        traceback.print_exc()
    return plaintext
Ejemplo n.º 10
0
    def decrypt(self, channel_reader: object) -> bytes:
        '''
        Decrypt extsting message using ChannelReader instance
        :param BOB:
        :return:
        '''
        policy_pubkey_restored = UmbralPublicKey.from_bytes(
            self.policy_pubkey_bytes)

        data_source_restored = Enrico.from_public_keys(
            {SigningPower: self.data_source_pubkey_bytes},
            policy_encrypting_key=policy_pubkey_restored)

        channel_reader.BOB.join_policy(self.label_bytes,
                                       self.alice_pubkey_bytes)

        alices_sig_pubkey = UmbralPublicKey.from_bytes(
            bytes(self.alice_pubkey_bytes))
        message_kit_object = UmbralMessageKit.from_bytes(self.kit_bytes)

        return channel_reader.BOB.retrieve(
            message_kit=message_kit_object,
            data_source=data_source_restored,
            alice_verifying_key=alices_sig_pubkey,
            label=self.label_bytes)
Ejemplo n.º 11
0
    def decrypt_data(self, data_source_public_key, data, policy_info):
        """
        Decrypt data

        Args:
            data_source_public_key (bytes): data_source_public_key
            data (bytes): encrypted data
            policy_info (dict): dict containing policy_pubkey, alice_sig_pubkey and label keys

        Returns:
            retrieved_plaintexts (list): list of str
        """
        policy_pubkey = UmbralPublicKey.from_bytes(
            bytes.fromhex(policy_info["policy_pubkey"]))
        alice_sig_pubkey = UmbralPublicKey.from_bytes(
            bytes.fromhex(policy_info["alice_sig_pubkey"]))
        label = policy_info["label"].encode()
        self.bob.join_policy(label, alice_sig_pubkey)
        message_kit = UmbralMessageKit.from_bytes(data)
        data_source = Enrico.from_public_keys(
            verifying_key=data_source_public_key,
            policy_encrypting_key=policy_pubkey)
        retrieved_plaintexts = self.bob.retrieve(
            message_kit,
            label=label,
            enrico=data_source,
            alice_verifying_key=alice_sig_pubkey)
        retrieved_plaintexts = [
            x.decode('utf-8') for x in retrieved_plaintexts
        ]
        return retrieved_plaintexts
Ejemplo n.º 12
0
def enrico_control_from_alice(federated_alice, random_policy_label):
    enrico = Enrico.from_alice(federated_alice, random_policy_label)

    enrico_control = enrico.make_wsgi_app()
    enrico_control.config['DEBUG'] = True
    enrico_control.config['TESTING'] = True
    yield enrico_control.test_client()
Ejemplo n.º 13
0
 def ensure_correct_sender(
         self,
         enrico: Optional["Enrico"] = None,
         policy_encrypting_key: Optional[UmbralPublicKey] = None):
     """
     Make sure that the sender of the message kit is set and corresponds to
     the given ``enrico``, or create it from the given ``policy_encrypting_key``.
     """
     if self.sender:
         if enrico and self.sender != enrico:
             raise ValueError(
                 f"Mismatched sender: the object has {self.sender}, provided {enrico}"
             )
     elif enrico:
         self.sender = enrico
     elif self.sender_verifying_key and policy_encrypting_key:
         # Well, after all, this is all we *really* need.
         from nucypher.characters.lawful import Enrico
         self.sender = Enrico.from_public_keys(
             verifying_key=self.sender_verifying_key,
             policy_encrypting_key=policy_encrypting_key)
     else:
         raise ValueError(
             "No information provided to set the message kit sender. "
             "Need eiter `enrico` or `policy_encrypting_key` to be given.")
Ejemplo n.º 14
0
 def reset(self, plaintext_passthrough=False):
     self.enrico = Enrico(
         policy_encrypting_key=enacted_blockchain_policy.public_key)
     self.messages = []
     self.plaintexts = []
     self.plaintext_passthrough = plaintext_passthrough
     return self(), self.enrico
Ejemplo n.º 15
0
 def decrypt(self, bob, item_cid, pol, sig, lab):
     policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(pol))
     alices_sig_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(sig))
     label = lab.encode()
     dat = self.ipfs_gateway_api.cat(item_cid)
     doctor = bob
     doctor.join_policy(label, alices_sig_pubkey)
     data = msgpack.loads(dat, raw=False)
     message_kits = (UmbralMessageKit.from_bytes(k) for k in data['kits'])
     data_source = Enrico.from_public_keys(
         {SigningPower: data['data_source']},
         policy_encrypting_key=policy_pubkey
     )
     message_kit = next(message_kits)
     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)
     heart_rate = plaintext['heart_rate']
     timestamp = maya.MayaDT(plaintext['timestamp'])
     terminal_size = shutil.get_terminal_size().columns
     max_width = min(terminal_size, 120)
     columns = max_width - 12 - 27
     scale = columns / 40
     retrieval_time = "Retrieval time: {:8.2f} ms".format(1000 * (end - start))
     line = heart_rate# + "   " + retrieval_time
     return line
Ejemplo n.º 16
0
    def decrypt(self, label: bytes, message_kit: bytes) -> dict:
        """
        Character control endpoint to allow Alice to decrypt her own data.
        """

        from nucypher.characters.lawful import Enrico
        policy_encrypting_key = self.character.get_policy_encrypting_key_from_label(label)

        # TODO #846: May raise UnknownOpenSSLError and InvalidTag.
        message_kit = UmbralMessageKit.from_bytes(message_kit)

        enrico = Enrico.from_public_keys(
            verifying_key=message_kit.sender_verifying_key,
            policy_encrypting_key=policy_encrypting_key,
            label=label
        )

        plaintexts = self.character.decrypt_message_kit(
            message_kit=message_kit,
            data_source=enrico,
            label=label
        )

        response = {'cleartexts': plaintexts}
        return response
Ejemplo n.º 17
0
    def retrieve(self,
                 label: bytes,
                 policy_encrypting_key: bytes,
                 alice_verifying_key: bytes,
                 message_kit: bytes,
                 treasure_map: Union[bytes, str, 'TreasureMap'] = None):
        """
        Character control endpoint for re-encrypting and decrypting policy data.
        """
        from nucypher.characters.lawful import Enrico

        policy_encrypting_key = UmbralPublicKey.from_bytes(
            policy_encrypting_key)
        alice_verifying_key = UmbralPublicKey.from_bytes(alice_verifying_key)
        message_kit = UmbralMessageKit.from_bytes(
            message_kit
        )  # TODO #846: May raise UnknownOpenSSLError and InvalidTag.

        enrico = Enrico.from_public_keys(
            verifying_key=message_kit.sender_verifying_key,
            policy_encrypting_key=policy_encrypting_key,
            label=label)

        self.character.join_policy(label=label,
                                   alice_verifying_key=alice_verifying_key)

        plaintexts = self.character.retrieve(
            message_kit,
            enrico=enrico,
            alice_verifying_key=alice_verifying_key,
            label=label,
            treasure_map=treasure_map)

        response_data = {'cleartexts': plaintexts}
        return response_data
Ejemplo n.º 18
0
def _create_enrico(emitter, policy_encrypting_key):
    policy_encrypting_key = UmbralPublicKey.from_bytes(
        bytes.fromhex(policy_encrypting_key))
    ENRICO = Enrico(policy_encrypting_key=policy_encrypting_key)
    ENRICO.controller.emitter = emitter  # TODO: set it on object creation? Or not set at all?

    return ENRICO
Ejemplo n.º 19
0
    def retrieve(self,
                 label: bytes,
                 policy_encrypting_key: bytes,
                 alice_verifying_key: bytes,
                 message_kit: bytes):
        """
        Character control endpoint for re-encrypting and decrypting policy data.
        """
        from nucypher.characters.lawful import Enrico

        policy_encrypting_key = UmbralPublicKey.from_bytes(policy_encrypting_key)
        alice_pubkey_sig = UmbralPublicKey.from_bytes(alice_verifying_key)
        message_kit = UmbralMessageKit.from_bytes(message_kit)  # TODO: May raise UnknownOpenSSLError and InvalidTag.

        data_source = Enrico.from_public_keys({SigningPower: message_kit.sender_pubkey_sig},
                                              policy_encrypting_key=policy_encrypting_key,
                                              label=label)

        self.bob.join_policy(label=label, alice_pubkey_sig=alice_pubkey_sig)
        plaintexts = self.bob.retrieve(message_kit=message_kit,
                                       data_source=data_source,
                                       alice_verifying_key=alice_pubkey_sig,
                                       label=label)

        response_data = {'cleartexts': plaintexts}
        return response_data
Ejemplo n.º 20
0
def test_blockchain_ursulas_reencrypt(blockchain_ursulas, blockchain_alice,
                                      blockchain_bob, policy_value):

    label = b'bbo'

    # TODO: Make sample selection buffer configurable - #1061
    # Currently, it only supports N<=6, since for N=7, it tries to sample 11 ursulas due to wiggle room,
    # and blockchain_ursulas only contains 10.
    # For N >= 7 : NotEnoughBlockchainUrsulas: Cannot create policy with 7 arrangements: There are 10 active stakers, need at least 11.
    m = n = 6
    expiration = maya.now() + datetime.timedelta(days=5)

    _policy = blockchain_alice.grant(bob=blockchain_bob,
                                     label=label,
                                     m=m,
                                     n=n,
                                     expiration=expiration,
                                     value=policy_value)

    enrico = Enrico.from_alice(blockchain_alice, label)

    message = b"Oh, this isn't even BO. This is beyond BO. It's BBO."

    message_kit, signature = enrico.encrypt_message(message)

    blockchain_bob.join_policy(label, bytes(blockchain_alice.stamp))

    plaintext = blockchain_bob.retrieve(message_kit, enrico,
                                        blockchain_alice.stamp, label)
    assert plaintext[0] == message
Ejemplo n.º 21
0
def _create_enrico(emitter, policy_encrypting_key):
    policy_encrypting_key = UmbralPublicKey.from_bytes(
        bytes.fromhex(policy_encrypting_key))
    ENRICO = Enrico(policy_encrypting_key=policy_encrypting_key)
    ENRICO.controller.emitter = emitter

    return ENRICO
def test_federated_alice_can_decrypt(federated_alice, federated_bob):
    """
    Test that alice can decrypt data encrypted by an enrico
    for her own derived policy pubkey.
    """

    # Setup the policy details
    threshold, shares = 2, 3
    policy_end_datetime = maya.now() + datetime.timedelta(days=5)
    label = b"this_is_the_path_to_which_access_is_being_granted"

    policy = federated_alice.create_policy(
        bob=federated_bob,
        label=label,
        threshold=threshold,
        shares=shares,
        expiration=policy_end_datetime,
    )

    enrico = Enrico.from_alice(
        federated_alice,
        policy.label,
    )
    plaintext = b"this is the first thing i'm encrypting ever."

    # use the enrico to encrypt the message
    message_kit = enrico.encrypt_message(plaintext)

    # decrypt the data
    decrypted_data = federated_alice.decrypt_message_kit(
        label=policy.label,
        message_kit=message_kit,
    )

    assert [plaintext] == decrypted_data
def test_blockchain_ursulas_reencrypt(blockchain_ursulas, blockchain_alice,
                                      blockchain_bob, policy_value):

    label = b'bbo'

    # TODO: Investigate issues with wiggle room and additional ursulas during sampling. See also #1061 and #1090
    # 1 <= N <= 4 : OK, although for N=4 it can fail with very small probability (<1%)
    # M = N = 5: Fails with prob. ~66%  --> Cannot create policy with 5 arrangements: Selection failed after 5 attempts
    # N == 6 : NotEnoughBlockchainUrsulas: Cannot create policy with 6 arrangements: Selection failed after 5 attempts
    # N >= 7 : NotEnoughBlockchainUrsulas: Cannot create policy with 7 arrangements: Cannot create policy with 7 arrangements: 10 stakers are available, need 11 (for wiggle room)
    m = n = 3
    expiration = maya.now() + datetime.timedelta(days=5)

    _policy = blockchain_alice.grant(bob=blockchain_bob,
                                     label=label,
                                     m=m,
                                     n=n,
                                     expiration=expiration,
                                     value=policy_value)

    enrico = Enrico.from_alice(blockchain_alice, label)

    message = b"Oh, this isn't even BO. This is beyond BO. It's BBO."

    message_kit, signature = enrico.encrypt_message(message)

    blockchain_bob.join_policy(label, bytes(blockchain_alice.stamp))

    plaintext = blockchain_bob.retrieve(message_kit, enrico,
                                        blockchain_alice.stamp, label)
    assert plaintext[0] == message
Ejemplo n.º 24
0
def encrypt_data(plain_text, datasource_filename):
    POLICY_FILENAME = "policy-metadata.json"

    POLICY_FILE = os.path.join(
        settings.BASE_DIR,
        'nucypher_utils',
        'nucypher_data',
        POLICY_FILENAME,
    )

    with open(POLICY_FILE, 'rb') as fp:
        policy_pubkey_data = json.load(fp)

    policy_pubkey_string = policy_pubkey_data['policy_pubkey']

    policy_pubkey_bytes = unhexlify(policy_pubkey_string)
    policy_pubkey = keys.UmbralPublicKey.from_bytes(policy_pubkey_bytes)

    data_source = Enrico(policy_encrypting_key=policy_pubkey)

    data_source_public_key = bytes(data_source.stamp)

    plain_text = bytes(plain_text, 'utf-8')
    message_kit, _signature = data_source.encrypt_message(plain_text)
    kit_bytes = message_kit.to_bytes()
    kit = kit_bytes
    data = {
        'data_source_public_key': data_source_public_key,
        'kits': kit,
    }

    # data souce pub key naming convention:
    # author_name-article_title-article_id-datasource-pubkey.msgpack

    DATA_SOURCE_DIR = os.path.join(
        settings.BASE_DIR,
        'nucypher_utils',
        'nucypher_data',
    )

    DATA_SOURCE_FILE_NAME = datasource_filename

    with open(os.path.join(DATA_SOURCE_DIR, DATA_SOURCE_FILE_NAME),
              "wb") as file:
        msgpack.dump(data, file, use_bin_type=True)

    return kit_bytes
Ejemplo n.º 25
0
def test_alice_can_decrypt(federated_alice):
    label = b"boring test label"

    policy_pubkey = federated_alice.get_policy_pubkey_from_label(label)

    enrico = Enrico(policy_encrypting_key=policy_pubkey)

    message = b"boring test message"
    message_kit, signature = enrico.encrypt_message(message=message)

    # Interesting thing: if Alice wants to decrypt, she needs to provide the label directly.
    cleartext = federated_alice.verify_from(stranger=enrico,
                                            message_kit=message_kit,
                                            signature=signature,
                                            decrypt=True,
                                            label=label)
    assert cleartext == message
Ejemplo n.º 26
0
def mario_box_cli(plaintext_dir, alice_config, label, outfile):

    # Derive Policy Encrypting Key
    alice_configuration = AliceConfiguration.from_configuration_file(
        filepath=alice_config)
    alice = make_cli_character(character_config=alice_configuration)
    alice_signing_key = alice.public_keys(SigningPower)
    policy_encrypting_key = alice.get_policy_encrypting_key_from_label(
        label=label.encode())
    policy_encrypting_key_hex = bytes(policy_encrypting_key).hex()

    output = list()
    paths = list(plaintext_dir.iterdir())
    click.secho(
        f"Encrypting {len(paths)} files for policy {policy_encrypting_key_hex}",
        fg='blue')

    with click.progressbar(paths) as bar:
        for path in bar:
            filepath = Path(plaintext_dir, path)
            with open(filepath, 'rb') as file:
                plaintext = file.read()
                encoded_plaintext = base64.b64encode(plaintext)

                enrico = Enrico(policy_encrypting_key=policy_encrypting_key)
                message_kit = enrico.encrypt_message(
                    plaintext=encoded_plaintext)
                base64_message_kit = base64.b64encode(
                    bytes(message_kit)).decode()

                # Collect Bob Retrieve JSON Requests
                retrieve_payload = {
                    'label': label,
                    'policy-encrypting-key': policy_encrypting_key_hex,
                    'alice-verifying-key': bytes(alice_signing_key).hex(),
                    'message-kit': base64_message_kit
                }

                output.append(retrieve_payload)

    if not outfile:
        outfile = f'{policy_encrypting_key_hex}.json'

    with open(outfile, 'w') as file:
        file.write(json.dumps(output, indent=2))
    click.secho(f"Successfully wrote output to {outfile}", fg='green')
Ejemplo n.º 27
0
    def encrypt_data(self, plaintext):
        """
        Encrypt data

        Args:
            plaintext (str): plaintext that should be encrypted

        Returns:
            label, data_source_public_key, data (bytes, bytes, byes): tuple containing label for the policy,
                                                                      data source public_key & encrypted data
        """
        label = ("policy️-" + os.urandom(8).hex()).encode()
        policy_pubkey = self.alice.get_policy_encrypting_key_from_label(label)
        data_source = Enrico(policy_encrypting_key=policy_pubkey)
        data_source_public_key = bytes(data_source.stamp)
        message, _signature = data_source.encrypt_message(
            plaintext.encode("utf-8"))
        data = message.to_bytes()
        return label, data_source_public_key, data
Ejemplo n.º 28
0
def encrypt_track(policy_pubkey, file_path):
    data_source = Enrico(policy_encrypting_key=policy_pubkey)
    data_source_public_key = bytes(data_source.stamp)
    print(file_path)

    with open(file_path, "rb") as f:
        plaintext = f.read()

    ciphertext, signature = data_source.encrypt_message(plaintext)

    print("Signature", signature)
    data = {
        'track_segment_data': ciphertext.to_bytes(),
        'data_source': data_source_public_key
    }

    with open(file_path + '_encrypted', "wb") as f:
        msgpack.dump(data, f, use_bin_type=True)

    return True
Ejemplo n.º 29
0
    def from_channel(cls, channel: Channel, data: bytes) -> object:
        '''
        Create EncryptedDataPackage from Channel & data. In other words it encrypts data usign Channel settings
        :param channel: Channel instance
        :param data: data to be encrypted
        :return: EncryptedDataPackage instance
        '''

        label_bytes = channel.label_bytes
        policy_pub_key_object = UmbralPublicKey.from_bytes(
            channel.policy_pubkey_bytes)
        data_source = Enrico(policy_encrypting_key=policy_pub_key_object)
        data_source_pubkey_bytes = bytes(data_source.stamp)
        message_kit, _signature = data_source.encrypt_message(data)
        kit_bytes = message_kit.to_bytes()

        return EncryptedDataPackage(
            alice_pubkey_bytes=channel.alice_pubkey_bytes,
            data_source_pubkey_bytes=data_source_pubkey_bytes,
            kit_bytes=kit_bytes,
            label_bytes=label_bytes,
            policy_pubkey_bytes=channel.policy_pubkey_bytes)
Ejemplo n.º 30
0
def generate_heart_rate_samples(policy_pubkey,
                                samples: int = 500,
                                save_as_file: bool = False):
    data_source = Enrico(policy_encrypting_key=policy_pubkey)

    data_source_public_key = bytes(data_source.stamp)

    heart_rate = 80
    now = time.time()

    kits = list()
    for _ in range(samples):
        # Simulated heart rate data
        # Normal resting heart rate for adults: between 60 to 100 BPM
        heart_rate = random.randint(max(60, heart_rate - 5),
                                    min(100, heart_rate + 5))
        now += 3

        heart_rate_data = {
            'heart_rate': heart_rate,
            'timestamp': now,
        }

        plaintext = msgpack.dumps(heart_rate_data, use_bin_type=True)
        message_kit = data_source.encrypt_message(plaintext)

        kit_bytes = bytes(message_kit)
        kits.append(kit_bytes)

    data = {
        'data_source': data_source_public_key,
        'kits': kits,
    }

    if save_as_file:
        with open(HEART_DATA_FILENAME, "wb") as file:
            msgpack.dump(data, file, use_bin_type=True)

    return data