def act_as_bob(self, name):
print("act_as_bob")
dirname = "accounts/" + name + "/"
fname = dirname+"recipent.private.json"
with open(fname) as data_file:
data = json.load(data_file)
enc_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["enc"]))
sig_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["sig"]))
bob_enc_keypair = DecryptingKeypair(private_key=enc_privkey)
bob_sig_keypair = SigningKeypair(private_key=sig_privkey)
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
bob = Bob(
is_me=True,
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[self.ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
return bob
def reveal_private_keys(self, username):
private_keys = self.user_path + username + self.private_key_path
with open(private_keys) as data_file:
data = json.load(data_file)
enc_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["enc"]))
sig_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["sig"]))
return enc_privkey, sig_privkey
def create_policy():
"""
input:
{
"label": "",-
"alice_privkey": "",
"bob_pubkey": "",
"policy_expiration": "",
"m": "",
"n": ""
}
response:
{
"success": "",
"policy_pubkey": "",
"policy_expiration_date": "",
"err_msg": ""
}
"""
result = {
'success': False,
'policy_pubkey': None,
'policy_expiration_date': None,
'err_msg': None
}
try:
j = json.loads(request.data.decode('utf-8'))
# TODO: Check if the input is valid
# Parse the input values
label = j['label'].encode('utf-8')
alice_privkey = UmbralPrivateKey.from_bytes(
j['alice_privkey'], decoder=base64.urlsafe_b64decode)
bob_pubkey = UmbralPublicKey.from_bytes(
j['bob_pubkey'], decoder=base64.urlsafe_b64decode)
policy_expiration = maya.now() + datetime.timedelta(
days=int(j['policy_expiration']))
m = int(j['m'])
n = int(j['n'])
# Create the policy
policy = api.create_policy(label, alice_privkey, bob_pubkey,
policy_expiration, m, n)
# Format the response
result['policy_pubkey'] = base64.urlsafe_b64encode(
policy.public_key.to_bytes()).decode('utf8')
result['policy_expiration_date'] = str(policy_expiration)
result['success'] = True
except Exception as e:
result['success'] = False
result['err_msg'] = str(e)
# Create response
response = jsonify(result)
return response
def __decrypt_keyfile(self, key_path: str) -> UmbralPrivateKey:
"""Returns plaintext version of decrypting key."""
key_data = _read_keyfile(key_path, deserializer=self._private_key_serializer)
wrap_key = _derive_wrapping_key_from_key_material(salt=key_data['wrap_salt'],
key_material=self.__derived_key_material)
plain_umbral_key = UmbralPrivateKey.from_bytes(key_bytes=key_data['key'], wrapping_key=wrap_key)
return plain_umbral_key
def test_privkey_roundtrip(p):
insecure_scrypt_cost = 5 # This is deliberately insecure, just to make it faster
k = UmbralPrivateKey.gen_key()
rt = UmbralPrivateKey.from_bytes(k.to_bytes(password=p, _scrypt_cost=insecure_scrypt_cost),
password=p,
_scrypt_cost=insecure_scrypt_cost)
assert(k.get_pubkey() == rt.get_pubkey())
def get_reseller_pubkeys(ethPk):
try:
reseller_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(ethPk))
except IndexError:
reseller_privkey = UmbralPrivateKey.gen_key()
return reseller_privkey.get_pubkey();
def test_private_key_serialization(random_ec_curvebn1):
priv_key = random_ec_curvebn1
umbral_key = UmbralPrivateKey(priv_key, default_params())
encoded_key = umbral_key.to_bytes()
decoded_key = UmbralPrivateKey.from_bytes(encoded_key)
assert priv_key == decoded_key.bn_key
def test_key_encoder_decoder(random_ec_curvebn1):
priv_key = random_ec_curvebn1
umbral_key = UmbralPrivateKey(priv_key, default_params())
encoded_key = umbral_key.to_bytes(encoder=base64.urlsafe_b64encode)
decoded_key = UmbralPrivateKey.from_bytes(encoded_key,
decoder=base64.urlsafe_b64decode)
assert decoded_key.to_bytes() == umbral_key.to_bytes()
def decrypt_for_policy():
"""
input:
{
"label": "",
"message_kit": "",
"alice_pubkey": "",
"bob_privkey": "",
"policy_pubkey": "",
"data_source_pubkey": ""
}
response:
{
"success": "",
"cleartext": "",
"err_msg": ""
}
"""
result = {'success': False, 'cleartext': None, 'err_msg': None}
try:
j = json.loads(request.data.decode('utf-8'))
# TODO: Check if the input is valid
# Parse the input values
label = j['label'].encode('utf-8')
message_kit = UmbralMessageKit.from_bytes(
base64.urlsafe_b64decode(j['message_kit']))
alice_pubkey = UmbralPublicKey.from_bytes(
j['alice_pubkey'], decoder=base64.urlsafe_b64decode)
bob_privkey = UmbralPrivateKey.from_bytes(
j['bob_privkey'], decoder=base64.urlsafe_b64decode)
policy_pubkey = UmbralPublicKey.from_bytes(
j['policy_pubkey'], decoder=base64.urlsafe_b64decode)
data_source_pubkey = UmbralPublicKey.from_bytes(
j['data_source_pubkey'], decoder=base64.urlsafe_b64decode)
# Encrypt plaintext for policy
cleartext = api.decrypt_for_policy(label, message_kit, alice_pubkey,
bob_privkey, policy_pubkey,
data_source_pubkey)
# Format the response data
result['cleartext'] = base64.urlsafe_b64encode(cleartext).decode(
'utf8')
result['success'] = True
except Exception as e:
result['success'] = False
result['err_msg'] = str(e)
# Create response
response = jsonify(result)
return response
def create_keyfrag():
if (not request.json or not 't' in request.json
or not 'delegating_secret' in request.json
or not 'receiving' in request.json
or not 'signer_secret' in request.json):
abort(400)
threshold = request.json['t']
show_debug(request.json['delegating_secret'])
sk_a = UmbralPrivateKey.from_bytes(binascii.unhexlify(
request.json['delegating_secret'].encode()),
params=params)
pk_b = UmbralPublicKey.from_bytes(
binascii.unhexlify(request.json['receiving'].encode()), params)
sign_a = UmbralPrivateKey.from_bytes(binascii.unhexlify(
request.json['signer_secret'].encode()),
params=params)
signer_a = signing.Signer(private_key=sign_a)
show_debug("Generating kfrags")
now = time.time() * 1000
kfrags = pre.generate_kfrags(delegating_privkey=sk_a,
signer=signer_a,
receiving_pubkey=pk_b,
threshold=threshold,
N=nodes_num)
end = time.time() * 1000
gen_tot = end - now
show_debug("Generated key fragment in: " + str(gen_tot))
show_debug("Distributing kfrags")
k_id = request.json['id']
payload = {
'capsule': request.json['capsule'],
'delegating': request.json['pk'],
'receiving': request.json['receiving'],
'verifying': binascii.hexlify(sign_a.get_pubkey().to_bytes()).decode()
}
ree_tot = distribute_key_fragments(k_id, kfrags, payload, threshold)
show_debug("Distributed key fragments")
return jsonify({'gen_time': gen_tot, 'ree_time': ree_tot}), 201
def test_private_key_serialization_with_encryption(random_ec_curvebn1):
priv_key = random_ec_curvebn1
umbral_key = UmbralPrivateKey(priv_key, default_params())
insecure_cost = 15 # This is deliberately insecure, just to make the tests faster
encoded_key = umbral_key.to_bytes(password=b'test',
_scrypt_cost=insecure_cost)
decoded_key = UmbralPrivateKey.from_bytes(encoded_key,
password=b'test',
_scrypt_cost=insecure_cost)
assert priv_key == decoded_key.bn_key
def _decrypt_umbral_key(wrapping_key: bytes, nonce: bytes,
encrypting_key_material: bytes) -> UmbralPrivateKey:
"""
Decrypts an encrypted key with nacl's XSalsa20-Poly1305 algorithm (SecretBox).
Returns a decrypted key as an UmbralPrivateKey.
"""
try:
decrypted_key = SecretBox(wrapping_key).decrypt(
encrypting_key_material, nonce)
except CryptoError:
raise
umbral_key = UmbralPrivateKey.from_bytes(decrypted_key)
return umbral_key
def decrypt():
api = ipfsapi.connect('127.0.0.1', 5001)
res = {}
cfrags = list()
if request.headers['Content-Type'] == 'application/json':
account = request.json['account']
ciphertexthex = request.json['ciphertext']
b_ciphertext = bytes.fromhex(ciphertexthex)
decryptkey = request.json['decryptkey']
b_decryptkey = bytes.fromhex(decryptkey)
deckey = UmbralPrivateKey.from_bytes(b_decryptkey)
capsuleaddr = request.json['capsule']
b_capsule_all = api.cat(capsuleaddr)
splitarr1 = b_capsule_all.split(b'ZAtech')
b_basic_capsule = splitarr1[0]
capsule = Capsule.from_bytes(b_basic_capsule,
UmbralParameters(Curve(714)))
print("0")
correctness_keys = splitarr1[1]
splitarr2 = correctness_keys.split(b'ZBtech')
delegating = UmbralPublicKey.from_bytes(splitarr2[0])
receiving = UmbralPublicKey.from_bytes(splitarr2[1])
verifying = UmbralPublicKey.from_bytes(splitarr2[2])
# 用带入的参数capsule_all的各种byte，重现绑定correctness keys的capsule.
capsule.set_correctness_keys(delegating=delegating,
receiving=receiving,
verifying=verifying)
print("1")
b_cfrag_all = splitarr1[2].split(b'ZCtech')
for b_cfrag in b_cfrag_all:
cfrags.append(CapsuleFrag.from_bytes(b_cfrag))
for cfrag in cfrags:
capsule.attach_cfrag(cfrag)
print("2")
print(capsule)
print(capsule.get_correctness_keys())
print(cfrags)
cleartext = pre.decrypt(ciphertext=b_ciphertext,
capsule=capsule,
decrypting_key=deckey)
print("3")
res = {"cleartext": cleartext.decode("utf-8")}
print("\nbob_cleartext: ")
print(cleartext)
return jsonify(res), {'Content-Type': 'application/json'}
return
def create_keys():
doctor_private_key = ""
doctor_public_hex = ""
shelf = shelve.open('python/proxy/doctor_private_key')
if 'privKey' in shelf:
doctor_private_key = UmbralPrivateKey.from_bytes(
bytes.fromhex(shelf['privKey']))
else:
doctor_private_key = keys.UmbralPrivateKey.gen_key()
doctor_public_hex = doctor_private_key.to_bytes().hex()
shelf["privKey"] = doctor_public_hex
shelf.close()
doctor_public_key = doctor_private_key.get_pubkey()
doctor_public_hex = doctor_public_key.to_bytes().hex()
return doctor_private_key
def revoke_policy():
"""
NOTE: This custom revoke hack is not working in the current nucypher version
input:
{
"label": "",
"alice_privkey": "",
"bob_pubkey": ""
}
response:
{
"success": "",
"err_msg": ""
}
"""
result = {'success': False, 'err_msg': None}
try:
j = json.loads(request.data.decode('utf-8'))
# TODO: Check if the input is valid
# Parse the input values
label = j['label'].encode('utf-8')
alice_privkey = UmbralPrivateKey.from_bytes(
j['alice_privkey'], decoder=base64.urlsafe_b64decode)
bob_pubkey = UmbralPublicKey.from_bytes(
j['bob_pubkey'], decoder=base64.urlsafe_b64decode)
# Revoke the policy
policy = api.revoke_policy(label, alice_privkey, bob_pubkey)
# Format the response
result['success'] = True
except Exception as e:
result['success'] = False
result['err_msg'] = str(e)
# Create response
response = jsonify(result)
return response
def _get_tls_hosting_power(host: str = None,
tls_certificate_filepath: str = None,
tls_private_key_filepath: str = None):
# Pre-Signed
if tls_certificate_filepath and tls_private_key_filepath:
with open(tls_private_key_filepath, 'rb') as file:
tls_private_key = UmbralPrivateKey.from_bytes(file.read())
tls_hosting_keypair = HostingKeypair(
curve=ec.SECP384R1,
host=host,
certificate_filepath=tls_certificate_filepath,
private_key=tls_private_key)
# Self-Sign
else:
tls_hosting_keypair = HostingKeypair(curve=ec.SECP384R1, host=host)
tls_hosting_power = TLSHostingPower(keypair=tls_hosting_keypair, host=host)
return tls_hosting_power
def decrypt_r():
if (not request.json or not 't' in request.json
or not 'verifying' in request.json
or not 'receiving' in request.json
or not 'receiving_secret' in request.json):
abort(400)
threshold = request.json['t']
verify_a = UmbralPublicKey.from_bytes(
binascii.unhexlify(request.json['verifying'].encode()), params)
pk_b = UmbralPublicKey.from_bytes(
binascii.unhexlify(request.json['receiving'].encode()), params)
sk_b = UmbralPrivateKey.from_bytes(binascii.unhexlify(
request.json['receiving_secret'].encode()),
params=params)
pk_a = UmbralPublicKey.from_bytes(
binascii.unhexlify(request.json['sender'].encode()), params)
capsule = pre.Capsule.from_bytes(
binascii.unhexlify(request.json['capsule'].encode()), params)
k_id = request.json['id']
ciphertext = binascii.unhexlify(request.json['ciphert'].encode())
show_debug("Gathering cfrags")
now = time.time() * 1000
capsule.set_correctness_keys(delegating=pk_a,
receiving=pk_b,
verifying=verify_a)
cfrags = gather_capsule_fragments(k_id, threshold)
end = time.time() * 1000
cfr_tot = end - now
show_debug("Gathered capsule fragments in: " + str(cfr_tot))
show_debug("Decrypting")
now = time.time() * 1000
plaintext_b = decrypt(cfrags, capsule, ciphertext, sk_b, threshold)
end = time.time() * 1000
dec_tot = end - now
show_debug('Decrypted in (ms)= ' + str(dec_tot))
return jsonify({
'plain': plaintext_b.decode(),
'cfr_time': cfr_tot,
'dec_time': dec_tot
}), 201
def decryptDelegated():
# Fetch Request Data
# {
# "bobKeys": "{\"enc\": \"40f05590a27491caf37049366fefd43e46034e4308f4f1fd233c166bc3980ab4\", \"sig\": \"3bcf21d3cb160118b499a883023569c60476f8731bd9eade11016c5030c1ca5d\"}",
# "policy_public_key": "02aef01b40c0a62a9a1f650dd9a8381695e21a7b3826c748a5b64831aa0dd9862c",
# "alice_sig_pubkey": "036c5d361000e6fbf3c4a84c98f924a3206e8a72c758a67e8300b5bee111b5fa97",
# "label": "1stlabel",
# "message": "messagekit",
# "data_source": "03a38eef9fd09c9841585dea93791e139a3003d540539673c8c719af55e46c0c1b",
# }
json_data = json.loads(request.data.decode('utf-8'))
bob_private_keys = json.loads(json_data['bobKeys'])
policy_public_key = json_data['policy_public_key']
alice_signing_key = json_data['alice_sig_pubkey']
label = json_data['label']
# username = json_data['username']
message = json_data['message']
data_source = json_data['data_source']
data_source = bytes.fromhex(data_source)
print (bob_private_keys['enc'])
enc = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["enc"]))
sig = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["sig"]))
# signingPublic = sig.get_pubkey()
# bobFilePath = os.path.join(os.getcwd(), 'bob/' + username + '.json')
# doctor_pubkeys = _get_keys(bobFilePath, UmbralPublicKey)
# print (signingPublic == doctor_pubkeys['sig'])
# print (signingPublic)
# print (doctor_pubkeys['sig'])
print ('\n\n\n')
bob_enc_keypair = DecryptingKeypair(private_key=enc)
bob_sig_keypair = SigningKeypair(private_key=sig)
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
doctor = Bob(
domains={'TEMPORARY_DOMAIN'},
is_me=True,
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes={ursula},
save_metadata=False,
network_middleware=RestMiddleware()
)
policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(policy_public_key))
alices_sig_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(alice_signing_key))
label = label.encode()
doctor.join_policy(label, alices_sig_pubkey)
message_kit = UmbralMessageKit.from_bytes(bytes.fromhex(message))
print (message_kit == MessageKit)
print (message_kit)
print (MessageKit)
print ('\n\n\n')
data_source = Enrico.from_public_keys(
{SigningPower: data_source},
policy_encrypting_key=policy_pubkey
)
retrieved_plaintexts = doctor.retrieve(
label=label,
message_kit=message_kit,
data_source=data_source,
alice_verifying_key=alices_sig_pubkey
)
# the object to be sent back to front end
# {
# "fileFieldCount": 2,
# "textFieldCount": 2,
# "files (stringified)": {
# "fileKey1": "fileUrl1",
# "fileKey2": "fileUrl2"
# },
# "textFields (stringified)": {
# "age": "18",
# "name": "arvind"
# }
# }
plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False)
# the object from plaintext
data_obj = createDataObject(plaintext, json_data['label'])
return jsonify(data_obj)
def kfraggen():
api = ipfsapi.connect('127.0.0.1', 5001)
addrs = list()
if request.headers['Content-Type'] == 'application/json':
account = request.json['account']
# 所有的传入参数都是hex key
delegatekey = request.json['delegatekey']
b_delegatekey = bytes.fromhex(delegatekey)
dk = UmbralPrivateKey.from_bytes(b_delegatekey)
# signer参数就是传入alice的另一个sk
signersk = request.json['signersk']
b_signersk = bytes.fromhex(signersk)
signk = UmbralPrivateKey.from_bytes(b_signersk)
signer = signing.Signer(signk)
publickey = request.json['publickey']
b_publickey = bytes.fromhex(publickey)
bpk = UmbralPublicKey.from_bytes(b_publickey)
threshold = request.json['threshold']
N = request.json['N']
# 测试写入库 error
# cursor = conn.cursor()
# sql = "insert into saved(name, delekey, signingkey, receiverpk) values('%s', '%s', '%s', '%s')"
# % (account, delegatekey, signersk, publickey)
# try:
# # Execute the SQL statement
# cursor.execute(sql)
# except Exception as e:
# print("Error: ", e)
# cursor.close()
kfrags = pre.generate_kfrags(delegating_privkey=dk,
signer=signer,
receiving_pubkey=bpk,
threshold=threshold,
N=N)
for kf in kfrags:
addrs.append(api.add_bytes(kf.to_bytes()))
# for addr in addrs:
# print(addr)
# # ipfs地址读取bytes
# biarray = api.cat(addr)
# print(biarray)
#
# # bytes转key
# kfragobj = KFrag.from_bytes(biarray)
# print(kfragobj)
#
# # key转bytes
# bye = kfragobj.to_bytes()
# print(bye)
#
# # bytes转str
# kfraghex = biarray.hex()
# print(kfraghex)
#
# # str转bytes
# d = bytes.fromhex(kfraghex)
# print(d)
# print("\n")
# N个frag的ipfs地址写入数据库，带account。
# cursor = conn.cursor()~~~
# for addr in addrs:
# sql = "insert into XXX(name, address) values('%s', '%s')" % (account, addr)
# try:
# # Execute the SQL statement
# cursor.execute(sql)
# except Exception as e:
# print("Error: ", e)
# cursor.close()
return jsonify(addrs), {'Content-Type': 'application/json'}
return
config.set_default_curve()
#2
# Generate an Umbral key pair
# ---------------------------
# First, Let's generate two asymmetric key pairs for Alice:
# A delegating key pair and a Signing key pair.
alices_private_key = None
shelf = shelve.open('python/proxy/aliceKey')
if alices_private_key == None:
alices_private_key = keys.UmbralPrivateKey.gen_key()
priv_hex = alices_private_key.to_bytes().hex()
shelf["privKey"] = priv_hex
alices_private_key = UmbralPrivateKey.from_bytes(
bytes.fromhex(shelf["privKey"]))
shelf.close()
# alices_private_key = keys.UmbralPrivateKey.gen_key()
alices_public_key = alices_private_key.get_pubkey()
alices_signing_key = keys.UmbralPrivateKey.gen_key()
alices_verifying_key = alices_signing_key.get_pubkey()
alices_signer = signing.Signer(private_key=alices_signing_key)
#3
# Encrypt some data for Alice
# ---------------------------
# Now let's encrypt data with Alice's public key.
# Invocation of `pre.encrypt` returns both the `ciphertext`,
# and a `capsule`. Anyone with Alice's public key can perform
# this operation.
with open("python/proxy/23.jpg", "rb") as imageFile:
# pprint(json.dumps(json.loads(str({"('delegating',)": alices_public_key})))
# pprint(json.dumps(json.loads(str(bobs_public_key)))
# pprint(f'{"delegating": {alices_public_key}}')
# pprint(f'{"receiving": {bobs_public_key}}')
# pprint(f'{"verifying": {alices_verifying_key}}')
# pprint(f"capsule: bob_capsule")
shelf = shelve.open('mydata') # open for reading and writing, creating if nec
#shelf.update({'delegating':apk_hex})
shelf["delegating"] = apk_hex
shelf["privKey"] = priv_hex
shelf.close()
shelf = shelve.open('mydata')
pprint(shelf["delegating"])
priv_key_fromBytesFile = UmbralPrivateKey.from_bytes(
bytes.fromhex(shelf["privKey"]))
key_fromBytesFile = UmbralPublicKey.from_bytes(
bytes.fromhex(shelf["delegating"]))
pprint(key_fromBytesFile)
pprint(priv_key_fromBytesFile)
shelf.close()
my_dict = {'delegating': apk_hex}
def dict_to_binary(the_dict):
str = json.dumps(the_dict)
binary = ' '.join(format(ord(letter), 'b') for letter in str)
return binary
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)
signing_privkey = UmbralPrivateKey.from_bytes(signing_privkey_bytes,
params)
receiving_pubkey = UmbralPublicKey.from_bytes(receiving_pubkey_bytes,
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)
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)
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
def createBobToResolveData(sub_uuid, sender, event_uuid, sub_private_key,
sub_signer_key, policy_pub_key, policy_sign_key,
label):
SEEDNODE_URI = "127.0.0.1:10151"
# TODO: path joins?
TEMP_DOCTOR_DIR = "{}/doctor-files".format(
os.path.dirname(os.path.abspath(__file__)))
# Remove previous demo files and create new ones
shutil.rmtree(TEMP_DOCTOR_DIR, ignore_errors=True)
ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URI,
federated_only=True,
minimum_stake=0)
# doctor private key
encdoctor = UmbralPrivateKey.from_bytes(bytes.fromhex(sub_private_key))
signdoctor = UmbralPrivateKey.from_bytes(bytes.fromhex(sub_signer_key))
bob_enc_keypair = DecryptingKeypair(private_key=encdoctor)
bob_sig_keypair = SigningKeypair(private_key=signdoctor)
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
print("Creating the Doctor ...")
doctor = Bob(
domains={TEMPORARY_DOMAIN},
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
print("Doctor = ", doctor)
policy_pub_keys = UmbralPublicKey.from_bytes(bytes.fromhex(policy_pub_key))
policy_sign_keys = UmbralPublicKey.from_bytes(
bytes.fromhex(policy_sign_key))
label = label.encode()
print("The Doctor joins policy for label '{}'".format(
label.decode("utf-8")))
doctor.join_policy(label, policy_sign_keys)
data = msgpack.load(open(event_uuid + ".msgpack", "rb"), raw=False)
message_kits = UmbralMessageKit.from_bytes(data['data'])
data_source = Enrico.from_public_keys(
verifying_key=data['data_source'],
policy_encrypting_key=policy_pub_keys)
try:
retrieved_plaintexts = doctor.retrieve(
message_kits,
label=label,
enrico=data_source,
alice_verifying_key=policy_sign_keys)
plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False)
# Now we can get the heart rate and the associated timestamp,
# generated by the heart rate monitor.
location_decrypted = plaintext['data_enc']
print(location_decrypted)
except Exception as e:
# We just want to know what went wrong and continue the demo
traceback.print_exc()
return location_decrypted
def decryptDelegated():
json_data = json.loads(request.data.decode('utf-8'))
bob_private_keys = json.loads(json_data['bobKeys'])
policy_public_key = json_data['policy_public_key']
alice_signing_key = json_data['alice_sig_pubkey']
label = json_data['label']
# username = json_data['username']
message = json_data['message']
data_source = json_data['data_source']
data_source = bytes.fromhex(data_source)
print (bob_private_keys['enc'])
enc = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["enc"]))
sig = UmbralPrivateKey.from_bytes(bytes.fromhex(bob_private_keys["sig"]))
# signingPublic = sig.get_pubkey()
# bobFilePath = os.path.join(os.getcwd(), 'bob/' + username + '.json')
# doctor_pubkeys = _get_keys(bobFilePath, UmbralPublicKey)
# print (signingPublic == doctor_pubkeys['sig'])
# print (signingPublic)
# print (doctor_pubkeys['sig'])
print ('\n\n\n')
bob_enc_keypair = DecryptingKeypair(private_key=enc)
bob_sig_keypair = SigningKeypair(private_key=sig)
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
doctor = Bob(
domains={'TEMPORARY_DOMAIN'},
is_me=True,
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes={ursula},
save_metadata=False,
network_middleware=RestMiddleware()
)
policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(policy_public_key))
alices_sig_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(alice_signing_key))
label = label.encode()
doctor.join_policy(label, alices_sig_pubkey)
message_kit = UmbralMessageKit.from_bytes(bytes.fromhex(message))
print (message_kit == MessageKit)
print (message_kit)
print (MessageKit)
print ('\n\n\n')
data_source = Enrico.from_public_keys(
{SigningPower: data_source},
policy_encrypting_key=policy_pubkey
)
retrieved_plaintexts = doctor.retrieve(
label=label,
message_kit=message_kit,
data_source=data_source,
alice_verifying_key=alices_sig_pubkey
)
# the object to be sent back to front end
# {
# "fileFieldCount": 2,
# "textFieldCount": 2,
# "files (stringified)": {
# "fileKey1": "fileUrl1",
# "fileKey2": "fileUrl2"
# },
# "textFields (stringified)": {
# "age": "18",
# "name": "arvind"
# }
# }
plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False)
# the object from plaintext
# data_obj = createDataObject(plaintext, json_data['label'])
return jsonify(plaintext)
from umbral.keys import UmbralPrivateKey, UmbralPublicKey
from api import Api
policy_expiration = maya.now() + datetime.timedelta(days=365)
m = 1
n = 1
api = Api(node_meta_dir='../examples/examples-runtime-cruft')
# private_key1, public_key1 = api.gen_keypair()
# private_key2, public_key2 = api.gen_keypair()
private_key1 = UmbralPrivateKey.from_bytes(
'DGgxOtqZOrqY-lh_E_L5H2YpNBoT3HEW6whMcVcqf5c=',
decoder=base64.urlsafe_b64decode)
public_key1 = private_key1.get_pubkey()
print(bytes(public_key1))
private_key2 = UmbralPrivateKey.from_bytes(
'8886EWu9cnGOCoZjNcI1SPEoyOiUTHBYwflfAA5YgCA=',
decoder=base64.urlsafe_b64decode)
public_key2 = private_key2.get_pubkey()
print(private_key1.to_bytes())
label = 'test-2'.encode('utf-8')
policy = api.create_policy(label, private_key1, public_key2, policy_expiration,
m, n)
def downloadFile(self, downloadFilename, recipient_privkeys, receipt,
policy_info):
hash = receipt['hash_key']
input = self.ipfs.cat(hash)
ursula = Ursula.from_seed_and_stake_info(
seed_uri=self.URSULA_SEEDNODE_URI,
federated_only=True,
minimum_stake=0)
bob_enc_keypair = DecryptingKeypair(
private_key=UmbralPrivateKey.from_bytes(
bytes.fromhex(recipient_privkeys["enc"])))
bob_sig_keypair = SigningKeypair(
private_key=UmbralPrivateKey.from_bytes(
bytes.fromhex(recipient_privkeys["sig"])))
enc_power = DecryptingPower(keypair=bob_enc_keypair)
sig_power = SigningPower(keypair=bob_sig_keypair)
power_ups = [enc_power, sig_power]
authorizedRecipient = Bob(
is_me=True,
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,
abort_on_learning_error=True,
known_nodes=[ursula],
save_metadata=False,
network_middleware=RestMiddleware(),
)
policy_pubkey = UmbralPublicKey.from_bytes(
bytes.fromhex(policy_info["policy_pubkey"]))
enrico_as_understood = Enrico.from_public_keys(
{
SigningPower:
UmbralPublicKey.from_bytes(
bytes.fromhex(receipt['data_source_public_key']))
},
#{SigningPower: data_source_public_key},
policy_encrypting_key=policy_pubkey)
alice_pubkey_restored = UmbralPublicKey.from_bytes(
(policy_info['alice_sig_pubkey']))
authorizedRecipient.join_policy(policy_info['label'].encode(),
alice_pubkey_restored)
kit = UmbralMessageKit.from_bytes(input)
delivered_cleartexts = authorizedRecipient.retrieve(
message_kit=kit,
data_source=enrico_as_understood,
alice_verifying_key=alice_pubkey_restored,
label=(policy_info['label'].encode()))
#delivered_cleartexts = authorizedRecipient.retrieve(message_kit=kit,data_source=data_source,alice_verifying_key=alice_pubkey_restored, label=(policy_info['label'].encode()) )
data = base64.b64decode(delivered_cleartexts[0])
output = open('./' + downloadFilename, 'wb')
output.write(data)
output.close()
