def test_charm_crypto():
# instantiate a bilinear pairing map
pairing_group = PairingGroup('MNT224')
cpabe = CPabe_BSW07(pairing_group)
hyb_abe = HybridABEnc(cpabe, pairing_group)
# run the set up
(pk, msk) = hyb_abe.setup() # Public Key and Master SECRET Key
# generate a key
attr_list = ['U-11890454', 'D-46', 'D-46-GUEST']
key = hyb_abe.keygen(pk, msk, attr_list)
serialized_pk = serialize_charm_object(pk, pairing_group)
pk = deserialize_charm_object(serialized_pk, pairing_group)
serialized_key = serialize_charm_object(key, pairing_group)
key = deserialize_charm_object(serialized_key, pairing_group)
# choose a random message
msg = "Hello World"
# generate a ciphertext
policy_str = '(u-11890454 OR d-46 OR d-46-GUEST)' # evaluates to "((U-11890454 or D-46) or D-46-GUEST)" - see upper chars
ctxt = hyb_abe.encrypt(pk, msg, policy_str)
policy_str = '(u-1 AND d-46 AND d-46-GUEST)' # Re-encrypted data with new policy
ctxt2 = hyb_abe.encrypt(pk, msg, policy_str)
# decryption
rec_msg = hyb_abe.decrypt(pk, key, ctxt).decode("utf-8")
with pytest.raises(Exception):
hyb_abe.decrypt(pk, key, ctxt2)
assert rec_msg == msg, "Failed." # "First successfully decrypted, second not."
def create_abe_key_pair():
pairing_group = create_pairing_group()
cp_abe = create_cp_abe()
public_key, master_key = cp_abe.setup()
serialized_public_key = serialize_charm_object(public_key, pairing_group)
serialized_master_key = serialize_charm_object(master_key, pairing_group)
return serialized_public_key, serialized_master_key
def test_serialize_and_deserialize_pk():
pairing_group = create_pairing_group()
cp_abe = create_cp_abe()
public_key, master_key = cp_abe.setup()
assert public_key == deserialize_charm_object(
serialize_charm_object(public_key, pairing_group), pairing_group)
def encrypt_using_abe_serialized_key(pk, plaintext, policy_string):
pairing_group = create_pairing_group()
cp_abe = create_cp_abe()
try:
public_key = deserialize_charm_object(str.encode(pk), pairing_group)
except binascii.Error:
raise Exception("Invalid public key.")
ciphertext = cp_abe.encrypt(public_key, str(plaintext), policy_string)
return serialize_charm_object(ciphertext, pairing_group).decode("utf-8")
def key_setup():
pairing_group = create_pairing_group()
cp_abe = create_cp_abe()
public_key, master_key = cp_abe.setup()
# "store keypair in DB"
user = AttrAuthUser.get_using_jwt_token(request.headers.get("Authorization", None))
serialized_public_key = serialize_charm_object(public_key, pairing_group)
serialized_master_key = serialize_charm_object(master_key, pairing_group)
user.master_keypair = MasterKeypair(data_public=serialized_public_key,
data_master=serialized_master_key)
db.session.add(user)
db.session.commit()
# return pk, msk
return http_json_response(**{'public_key': serialized_public_key.decode("utf-8")})
def test_create_private_key():
pairing_group = create_pairing_group()
cp_abe = create_cp_abe()
public_key, master_key = cp_abe.setup()
serialized_public_key = serialize_charm_object(public_key, pairing_group)
serialized_master_key = serialize_charm_object(master_key, pairing_group)
serialized_private_key = create_private_key(serialized_master_key,
serialized_public_key,
["1", "1-2", "1-GUEST"])
plaintext_in = "stuff"
policy_string = "(1)"
ciphertext = cp_abe.encrypt(public_key, plaintext_in, policy_string)
private_key = deserialize_charm_object(serialized_private_key,
pairing_group)
plaintext_out = cp_abe.decrypt(public_key, private_key, ciphertext)
assert plaintext_in == plaintext_out.decode()
def encrypt():
data_owner = AttrAuthUser.get_using_jwt_token(request.headers.get("Authorization", None))
plaintext = request.args.get("message", None)
policy_string = request.args.get("policy_string", None)
arg_check = check_missing_request_argument(
(plaintext, MESSAGE_MISSING_ERROR_MSG),
(policy_string, POLICY_STRING_MISSING_ERROR_MSG))
if arg_check is not True:
return arg_check
pairing_group = create_pairing_group()
cp_abe = create_cp_abe()
public_key = deserialize_charm_object(data_owner.master_keypair.data_public, pairing_group)
ciphertext = cp_abe.encrypt(public_key, plaintext, policy_string)
# return ciphertext
return http_json_response(**{'ciphertext': serialize_charm_object(ciphertext, pairing_group).decode("utf-8")})