Nucypher
/
nucypher
mirror of https://github.com/nucypher/nucypher.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

More b64 serialization deprecation; Flask response nucypher versioing

pull/775/head
Kieran R. Prasch 2019-02-16 11:58:52 -07:00
parent abdd9ceda8
commit e7da2240eb
3 changed files with 50 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
nucypher/characters/lawful.py
View File

@ -46,6 +46,8 @@ from bytestring_splitter import BytestringKwargifier, BytestringSplittingError
from bytestring_splitter import BytestringSplitter, VariableLengthBytestring
from constant_sorrow import constants, constant_or_bytes
from constant_sorrow.constants import INCLUDED_IN_BYTESTRING, PUBLIC_ONLY
import nucypher
from nucypher.blockchain.eth.actors import PolicyAuthor, Miner
from nucypher.blockchain.eth.agents import MinerAgent
from nucypher.characters.base import Character, Learner
@ -255,7 +257,8 @@ class Alice(Character, PolicyAuthor):
response_data = {
'result': {
'policy_encrypting_pubkey': bytes(policy_pubkey).hex(),
}
},
'version': str(nucypher.__version__)
}
return Response(json.dumps(response_data), status=200)
@ -281,11 +284,10 @@ class Alice(Character, PolicyAuthor):
request_data['expiration_time'])
else:
expiration_time = (maya.now() + datetime.timedelta(days=3))
federated_only = True # const for now
bob = Bob.from_public_keys({DecryptingPower: bob_pubkey_enc,
SigningPower: bob_pubkey_sig},
federated_only=True)
federated_only=True) # TODO: Const for now
except (KeyError, JSONDecodeError) as e:
print(e) # TODO: Make this a genuine log. Just for demos for now.
return Response(str(e), status=400)
@ -298,8 +300,9 @@ class Alice(Character, PolicyAuthor):
'treasure_map': b64encode(bytes(new_policy.treasure_map)).decode(),
'policy_encrypting_pubkey': bytes(new_policy.public_key).hex(),
'alice_signing_pubkey': bytes(new_policy.alice.stamp).hex(),
'label': b64encode(new_policy.label).decode(),
}
'label': new_policy.label.decode(),
},
'version': str(nucypher.__version__)
}
return Response(json.dumps(response_data), status=200)
@ -579,11 +582,12 @@ class Bob(Character):
policy_encrypting_key = UmbralPublicKey.from_bytes(policy_pubkey_enc)
alice_pubkey_sig = UmbralPublicKey.from_bytes(alice_pubkey_sig)
message_kit = UmbralMessageKit.from_bytes(message_kit)
message_kit = UmbralMessageKit.from_bytes(message_kit) # TODO: May raise UnknownOpenSSLError... great.
data_source = Enrico.from_public_keys({SigningPower: message_kit.sender_pubkey_sig},
policy_encrypting_key=policy_encrypting_key,
label=label)
drone_bob.join_policy(label=label, alice_pubkey_sig=alice_pubkey_sig)
plaintexts = drone_bob.retrieve(message_kit=message_kit,
data_source=data_source,
@ -594,7 +598,8 @@ class Bob(Character):
response_data = {
'result': {
'plaintext': plaintexts,
}
},
'version': str(nucypher.__version__)
}
return Response(json.dumps(response_data), status=200)
@ -1132,18 +1137,22 @@ class Enrico(Character):
"""
try:
request_data = json.loads(request.data)
message = b64decode(request_data['message'])
message = request_data['message']
except (KeyError, JSONDecodeError) as e:
return Response(str(e), status=400)
message_kit, signature = drone_enrico.encrypt_message(message)
# Encrypt
message_kit, signature = drone_enrico.encrypt_message(bytes(message, encoding='utf-8'))
m = UmbralMessageKit.from_bytes(bytes(message_kit))
assert m == message_kit
response_data = {
'result': {
'message_kit': b64encode(message_kit.to_bytes()).decode(),
'message_kit': b64encode(bytes(message_kit)).decode(),
'signature': b64encode(bytes(signature)).decode(),
}
},
'version': str(nucypher.__version__)
}
return Response(json.dumps(response_data), status=200)

2
nucypher/utilities/sandbox/policy.py
View File

@ -86,7 +86,7 @@ def generate_random_label() -> bytes:
Generates a random bytestring for use as a test label.
:return: bytes
"""
adjs = ('my', 'sesame street', 'black', 'cute')
adjs = ('my', 'sesame-street', 'black', 'cute')
nouns = ('lizard', 'super-secret', 'data', 'coffee')
combinations = list('-'.join((a, n)) for a in adjs for n in nouns)
selection = random.choice(combinations)

40
tests/characters/test_character_control.py
View File

@ -22,6 +22,7 @@ def test_alice_character_control_create_policy(alice_control_test_client, federa
}
response = alice_control_test_client.put('/create_policy', data=json.dumps(request_data))
assert response.status_code == 200
assert 'version' in response.data
assert response.data == b'Policy created!'
# Send bad data to assert error returns
@ -100,7 +101,7 @@ def test_bob_character_control_retrieve(bob_control_test_client, enacted_federat
message_kit, data_source = capsule_side_channel
request_data = {
'label': b64encode(enacted_federated_policy.label).decode(),
'label': enacted_federated_policy.label.decode(),
'policy_encrypting_pubkey': bytes(enacted_federated_policy.public_key).hex(),
'alice_signing_pubkey': bytes(enacted_federated_policy.alice.stamp).hex(),
'message_kit': b64encode(message_kit.to_bytes()).decode(),
@ -137,8 +138,7 @@ def test_enrico_character_control_encrypt_message(enrico_control_test_client):
assert 'signature' in response_data['result']
# Check that it serializes correctly.
message_kit = UmbralMessageKit.from_bytes(
b64decode(response_data['result']['message_kit']))
message_kit = UmbralMessageKit.from_bytes(b64decode(response_data['result']['message_kit']))
# Send bad data to assert error return
response = enrico_control_test_client.post('/encrypt_message', data='bad')
@ -149,27 +149,35 @@ def test_enrico_character_control_encrypt_message(enrico_control_test_client):
assert response.status_code == 400
def test_character_control_lifecycle(alice_control_test_client, bob_control_test_client,
def test_character_control_lifecycle(alice_control_test_client,
bob_control_test_client,
enrico_control_from_alice,
federated_alice, federated_bob):
federated_alice,
federated_bob,
federated_ursulas):
random_label = generate_random_label().decode() # Unicode string
# Create a policy via Alice control
alice_request_data = {
'bob_encrypting_key': bytes(federated_bob.public_keys(DecryptingPower)).hex(),
'label': 'test',
'bob_signing_key': bytes(federated_bob.stamp).hex(),
'm': 2, 'n': 3,
'expiration_time': (maya.now() + datetime.timedelta(days=3)).iso8601(),
'bob_encrypting_key': bytes(federated_bob.public_keys(DecryptingPower)).hex(),
'm': 1, 'n': 1,
'label': random_label,
# 'expiration_time': (maya.now() + datetime.timedelta(days=3)).iso8601(), # TODO
}
response = alice_control_test_client.put('/grant', data=json.dumps(alice_request_data))
assert response.status_code == 200
# Check Response Keys
alice_response_data = json.loads(response.data)
assert 'treasure_map' in alice_response_data['result']
assert 'policy_encrypting_pubkey' in alice_response_data['result']
assert 'alice_signing_pubkey' in alice_response_data['result']
assert 'label' in alice_response_data['result']
assert 'version' in alice_response_data
assert str(nucypher.__version__) == alice_response_data['version']
# This is sidechannel policy metadata. It should be given to Bob by the
# application developer at some point.
@ -180,8 +188,10 @@ def test_character_control_lifecycle(alice_control_test_client, bob_control_test
# Encrypt some data via Enrico control
# Alice will also be Enrico via Enrico.from_alice
# (see enrico_control_from_alice fixture)
enrico_encoded_message = "I'm bereaved, not a sap!" # type: str
enrico_request_data = {
'message': b64encode(b"I'm bereaved, not a sap!").decode(),
'message': enrico_encoded_message,
}
response = enrico_control_from_alice.post('/encrypt_message', data=json.dumps(enrico_request_data))
@ -191,17 +201,23 @@ def test_character_control_lifecycle(alice_control_test_client, bob_control_test
assert 'message_kit' in enrico_response_data['result']
assert 'signature' in enrico_response_data['result']
kit_bytes = b64decode(enrico_response_data['result']['message_kit'])
kit_bytes = b64decode(enrico_response_data['result']['message_kit'].encode())
bob_message_kit = UmbralMessageKit.from_bytes(kit_bytes)
# Retrieve data via Bob control
encoded_message_kit = b64encode(bytes(bob_message_kit)).decode()
bob_request_data = {
'label': label,
'policy_encrypting_pubkey': policy_pubkey_enc_hex,
'alice_signing_pubkey': alice_pubkey_sig_hex,
'message_kit': b64encode(bob_message_kit.to_bytes()).decode(),
'message_kit': encoded_message_kit,
}
# Give bob a node to remember
teacher = list(federated_ursulas)[1]
federated_bob.remember_node(teacher)
response = bob_control_test_client.post('/retrieve', data=json.dumps(bob_request_data))
assert response.status_code == 200