abenc_maabe_rw15

Rouselakis - Waters Efficient Statically-Secure Large-Universe Multi-Authority Attribute-Based Encryption

From: Efficient Statically-Secure Large-Universe Multi-Authority Attribute-Based Encryption

Published in: Financial Crypto 2015

Available from: http://eprint.iacr.org/2015/016.pdf

Notes: Implementation based on implementation (maabe_rw12.py) which cah be found here: https://sites.google.com/site/yannisrouselakis/rwabe

• type: attribute-based encryption (public key)
• setting: bilinear pairing group of prime order
• assumption: complex q-type assumption

Authors:Yannis Rouselakis Date:11/12

class abenc_maabe_rw15.MaabeRW15(group, verbose=False)

Bases: charm.toolbox.ABEncMultiAuth.ABEncMultiAuth

Efficient Statically-Secure Large-Universe Multi-Authority Attribute-Based Encryption Rouselakis - Waters

>>> group = PairingGroup('SS512')
>>> maabe = MaabeRW15(group)
>>> public_parameters = maabe.setup()

Setup the attribute authorities

>>> attributes1 = ['ONE', 'TWO']
>>> attributes2 = ['THREE', 'FOUR']
>>> (public_key1, secret_key1) = maabe.authsetup(public_parameters, 'UT')
>>> (public_key2, secret_key2) = maabe.authsetup(public_parameters, 'OU')
>>> public_keys = {'UT': public_key1, 'OU': public_key2}

Setup a user and give him some keys

>>> gid = "bob"
>>> user_attributes1 = ['STUDENT@UT', 'PHD@UT']
>>> user_attributes2 = ['STUDENT@OU']
>>> user_keys1 = maabe.multiple_attributes_keygen(public_parameters, secret_key1, gid, user_attributes1)
>>> user_keys2 = maabe.multiple_attributes_keygen(public_parameters, secret_key2, gid, user_attributes2)
>>> user_keys = {'GID': gid, 'keys': merge_dicts(user_keys1, user_keys2)}

Create a random message

>>> message = group.random(GT)

Encrypt the message

>>> access_policy = '(STUDENT@UT or PROFESSOR@OU) and (STUDENT@UT or MASTERS@OU)'
>>> cipher_text = maabe.encrypt(public_parameters, public_keys, message, access_policy)

Decrypt the message

>>> decrypted_message = maabe.decrypt(public_parameters, user_keys, cipher_text)
>>> decrypted_message == message
True

authsetup(gp, name)

Setup an attribute authority. :param gp: The global parameters :param name: The name of the authority :return: The public and private key of the authority

decrypt(gp, sk, ct)

Decrypt the ciphertext using the secret keys of the user. :param gp: The global parameters. :param sk: The secret keys of the user. :param ct: The ciphertext to decrypt. :return: The decrypted message. :raise Exception: When the access policy can not be satisfied with the user’s attributes.

encrypt(gp, pks, message, policy_str)

Encrypt a message under an access policy :param gp: The global parameters. :param pks: The public keys of the relevant attribute authorities, as dict from authority name to public key. :param message: The message to encrypt. :param policy_str: The access policy to use. :return: The encrypted message.

keygen(gp, sk, gid, attribute)

Generate a user secret key for the attribute. :param gp: The global parameters. :param sk: The secret key of the attribute authority. :param gid: The global user identifier. :param attribute: The attribute. :return: The secret key for the attribute for the user with identifier gid.

multiple_attributes_keygen(gp, sk, gid, attributes)

Generate a dictionary of secret keys for a user for a list of attributes. :param gp: The global parameters. :param sk: The secret key of the attribute authority. :param gid: The global user identifier. :param attributes: The list of attributes. :return: A dictionary with attribute names as keys, and secret keys for the attributes as values.

setup()

unpack_attribute(attribute)

Unpacks an attribute in attribute name, authority name and index :param attribute: The attribute to unpack :return: The attribute name, authority name and the attribute index, if present.

>>> group = PairingGroup('SS512')
>>> maabe = MaabeRW15(group)
>>> maabe.unpack_attribute('STUDENT@UT')
('STUDENT', 'UT', None)
>>> maabe.unpack_attribute('STUDENT@UT_2')
('STUDENT', 'UT', '2')

abenc_maabe_rw15.merge_dicts(*dict_args)

Given any number of dicts, shallow copy and merge into a new dict, precedence goes to key value pairs in latter dicts.