def test_keyops():
pre = bbs98.PRE()
# Check types
priv = pre.gen_priv(dtype=bytes)
assert type(priv) is bytes
pub = pre.priv2pub(priv)
assert type(pub) is bytes
# Check types
priv2 = pre.gen_priv()
assert priv2 is not None
assert type(priv2) is not bytes
pub2 = pre.priv2pub(priv2)
assert pub2 is not None
assert type(pub2) is not bytes
# Check serialization
assert priv == pre.save_key(pre.load_key(priv))
assert pub == pre.save_key(pre.load_key(pub))
assert pre.load_key(pre.save_key(priv2)) == priv2
assert pre.load_key(pre.save_key(pub2)) == pub2
# Check that RNG gave us different keys
assert priv != pre.save_key(priv2)
assert pub != pre.save_key(pub2)
# Check that creating a new PRE object with same params gives the same key
pre2 = bbs98.PRE()
pub3 = pre2.priv2pub(priv)
assert pub3 == pub
def test_two_instances():
pre = bbs98.PRE()
pre1 = bbs98.PRE()
pre2 = bbs98.PRE(g=pre.g**2)
assert pre.g == pre1.g
assert pre.curve == pre1.curve
assert pre2.curve == pre.curve
assert pre2.g != pre.g
assert isinstance(pre2.g, type(pre.g))
def test_serde():
pre = bbs98.PRE()
pre1 = bbs98.PRE(**pre.to_dict())
assert pre.g == pre1.g
assert pre.curve == pre1.curve
s = pre.serialize()
pre2 = bbs98.PRE.deserialize(s)
assert pre.g == pre2.g
assert pre.curve == pre2.curve
def reencrypt():
data = request.get_json()
resp = {}
emsg = data['emsg']
reeK = data['reeK']
pk_B = data['pk_B']
EphSK = data['EphSK']
emsg = base64.b64decode(emsg)
reeK = base64.b64decode(reeK)
pk_B = base64.b64decode(pk_B)
EphSK = base64.b64decode(EphSK)
pre = bbs98.PRE()
remsg = pre.reencrypt(reeK, emsg)
BEphPK = pre.encrypt(pk_B, EphSK)
resp['BEphPK'] = base64.encodestring(BEphPK).decode('ascii')
resp['remsg'] = base64.encodestring(remsg).decode('ascii')
return jsonify(resp)
def genKeys():
data = {}
pre = bbs98.PRE()
#Keys of person A
sk_A = pre.gen_priv(dtype=bytes)
pk_A = pre.priv2pub(sk_A)
#Keys of person B
sk_B = pre.gen_priv(dtype=bytes)
pk_B = pre.priv2pub(sk_B)
#Keys Ephimeral
sk_Eph = pre.gen_priv(dtype=bytes)
#Reencryption Key
reeK = pre.rekey(sk_A, sk_Eph)
#Guardar parametros en data
data['sk_A'] = base64.encodestring(sk_A).decode('ascii')
data['pk_A'] = base64.encodestring(pk_A).decode('ascii')
data['sk_B'] = base64.encodestring(sk_B).decode('ascii')
data['pk_B'] = base64.encodestring(pk_B).decode('ascii')
data['sk_Eph'] = base64.encodestring(sk_Eph).decode('ascii')
data['reeK'] = base64.encodestring(reeK).decode('ascii')
return jsonify(data)
def update_task(msg):
data = {}
pre = bbs98.PRE()
sk_Alice = pre.gen_priv(dtype=bytes)
sk_Alice = pre.gen_priv(dtype=bytes)
pk_Alice = pre.priv2pub(sk_Alice)
sk_Bob = pre.gen_priv(dtype=bytes)
pk_Bob = pre.priv2pub(sk_Bob)
sk_Aux = pre.gen_priv(dtype=bytes)
re_AliceAux = pre.rekey(sk_Alice, sk_Aux)
emsg = pre.encrypt(pk_Alice, msg)
emsg_Aux = pre.reencrypt(re_AliceAux, emsg) # Mensaje encriptado para Bob
e_Aux = pre.encrypt(pk_Bob, sk_Aux)
bob_Aux = pre.decrypt(sk_Bob, e_Aux)
msgFinal = pre.decrypt(bob_Aux, emsg_Aux).decode('UTF-8')
#encoded = base64.encodestring(msgFinalB)
#msgFinal = encoded.decode('ascii')
return jsonify({'task': msgFinal})
def __init__(self, param, proxy, ca):
self.pre = bbs98.PRE(g=param)
self.index = None
self.__random_seed = None
self.__cipher = None
self.__encryptor = None
self.__decryptor = None
# start registry
proxy.register(self, ca)
self.__sk = ca.get_secrete_key(self)
self.__pk = ca.get_public_key(self)
def test_encrypt_decrypt():
pre = bbs98.PRE()
priv = pre.gen_priv()
pub = pre.priv2pub(priv)
emsg = pre.encrypt(pub, msg)
assert type(emsg) is bytes
msg2 = pre.decrypt(priv, emsg)
assert type(msg2) is bytes
assert msg2 == msg
assert pre.decrypt(priv, pre.encrypt(pub, msg.decode())) == msg
def decryptA():
data = request.get_json()
key = data['key']
emsg = data['emsg']
key = base64.b64decode(key)
emsg = base64.b64decode(emsg)
pre = bbs98.PRE()
msg = pre.decrypt(key, emsg).decode('ascii')
return jsonify(msg)
def encryptA():
data = request.get_json()
pk_A = data['pk_A']
msg = data['msg']
pk_A = base64.b64decode(pk_A)
pre = bbs98.PRE()
emsg = pre.encrypt(pk_A, msg)
emsg = base64.encodestring(emsg).decode('ascii')
return jsonify(emsg)
def post(self):
args = json.loads(self.request.body)
# test an object can be created
print('Download function got args {}'.format(args))
# encrypt some data
pre = bbs98.PRE()
fname = args['filename']
sender_b64 = args['sender']
receiver_b64 = args['receiver']
sender = decode_base64_str_into_bytes(sender_b64)
receiver = decode_base64_str_into_bytes(receiver_b64)
# first, fetch the ciphertext and edek from S3
# format is /public_key/fname
k_base = '/{}/{}'.format(sender_b64, fname)
bucket = CONN.get_bucket(BUCKET)
# download ciphertext
k_ciphertext = '{}/ciphertext'.format(k_base)
c_b64 = bytes.decode(
bucket.get_key(k_ciphertext,
validate=False).get_contents_as_string())
print('Got ciphertext from path {}'.format(k_ciphertext))
# download edek
k_edek = '{}/edek'.format(k_base)
edek_b64 = bucket.get_key(k_edek,
validate=False).get_contents_as_string()
print('Got edek from path {}'.format(k_edek))
edek = decode_base64_str_into_bytes(bytes.decode(edek_b64))
# next, fetch re_key
receiver_metadata = self.keys[sender_b64][fname][receiver_b64]
print(receiver_metadata)
rekey = decode_base64_str_into_bytes(receiver_metadata['rekey'])
e_b_b64 = receiver_metadata['encryptedEphemeralKey']
# now, reencrypt the edek with the re_key
edek_b = pre.reencrypt(rekey, edek)
edek_b_b64 = encode_bytes_to_base_64_str(edek_b)
out = {'e_b': e_b_b64, 'edek_b': edek_b_b64, 'ciphertext': c_b64}
# ipdb.set_trace()
self.write(json.dumps(out))
def decryptEphKey():
data = request.get_json()
sk_B = data['sk_B']
BEphPK = data['BEphPK']
sk_B = base64.b64decode(sk_B)
BEphPK = base64.b64decode(BEphPK)
pre = bbs98.PRE()
EphPKDec = pre.decrypt(sk_B, BEphPK)
EphPKDec = base64.encodestring(EphPKDec).decode('ascii')
return jsonify(EphPKDec)
def post(self):
args = json.loads(self.request.body)
# test an object can be created
print('Got args {}'.format(args))
# encrypt some data
pre = bbs98.PRE()
p_k = decode_base64_str_into_bytes(args['p_k'])
# p_k_encoded = str.encode(args['p_k'])
# p_k = b64decode(p_k_encoded)
msg = args['msg']
emsg = pre.encrypt(p_k, msg)
emsg_encoded = base64.b64encode(emsg)
# ipdb.set_trace()
out = {'emsg': bytes.decode(emsg_encoded)}
self.write(json.dumps(out))
def test_reencrypt():
pre = bbs98.PRE()
alice_priv = pre.gen_priv()
alice_pub = pre.priv2pub(alice_priv)
bob_priv = pre.gen_priv()
re1 = pre.rekey(alice_priv, bob_priv)
re2 = pre.rekey(alice_priv, bob_priv, dtype=bytes)
assert type(re1) != type(re2)
assert type(re2) is bytes
assert re1 == pre.load_key(re2)
for m in (msg, long_msg, msg28, b''):
emsg = pre.encrypt(alice_pub, m)
emsg2 = pre.reencrypt(re1, emsg)
emsg3 = pre.reencrypt(re2, emsg)
assert pre.decrypt(alice_priv, emsg) == m
assert pre.decrypt(bob_priv, emsg2) == m
assert pre.decrypt(bob_priv, emsg3) == m
def __init__(self, param):
self.pre = bbs98.PRE(g=param)
self.pk_list = []
self.pre_aes_key = None
self.pre_seed = None
self.encrypted_data = None
def __init__(self):
self.pre = bbs98.PRE()
self.__keypair_dict = {}
from npre import bbs98 pre = bbs98.PRE() import base64 import sys publicKey = base64.b64decode(sys.argv[1]) encrypted_message = pre.encrypt(publicKey, sys.argv[2]) print(base64.b64encode(encrypted_message))
