From 04354d79c9cd00b9d0cf4ba17fac0d9f4dc3fa0a Mon Sep 17 00:00:00 2001 From: Teknique Date: Wed, 2 Aug 2023 21:12:26 -0700 Subject: [PATCH] Cleanups and prepping for encryption This cleans up some types, moves some typing to loading and saving keys, uses clearer object names, and passes a crypto system into chatter. This lays the groundwork for adding encryption. --- veilid-python/demo/chat.py | 64 ++++++++++++++++++++---------------- veilid-python/demo/config.py | 11 +++++-- 2 files changed, 44 insertions(+), 31 deletions(-) diff --git a/veilid-python/demo/chat.py b/veilid-python/demo/chat.py index 4013dd8b..b5a5f0c7 100755 --- a/veilid-python/demo/chat.py +++ b/veilid-python/demo/chat.py @@ -19,17 +19,20 @@ async def noop_callback(*args, **kwargs): return -async def chatter(rc: veilid.api.RoutingContext, key: str, send_channel: int, recv_channel: int): +async def chatter( + router: veilid.api.RoutingContext, + crypto_system: veilid.CryptoSystem, + key: veilid.TypedKey, + send_subkey: veilid.ValueSubkey, + recv_subkey: veilid.ValueSubkey, +): """Read input, write it to the DHT, and print the response from the DHT.""" last_seq = -1 - send_subkey = veilid.types.ValueSubkey(send_channel) - recv_subkey = veilid.types.ValueSubkey(recv_channel) - # Prime the pumps. Especially when starting the conversation, this # causes the DHT key to propagate to the network. - await rc.set_dht_value(key, send_subkey, b"Hello from the world!") + await router.set_dht_value(key, send_subkey, b"Hello from the world!") while True: try: @@ -37,11 +40,11 @@ async def chatter(rc: veilid.api.RoutingContext, key: str, send_channel: int, re except EOFError: # Cat got your tongue? Hang up. print("Closing the chat.") - await rc.set_dht_value(key, send_subkey, QUIT) + await router.set_dht_value(key, send_subkey, QUIT) return # Write the input message to the DHT key. - await rc.set_dht_value(key, send_subkey, msg.encode()) + await router.set_dht_value(key, send_subkey, msg.encode()) # In the real world, don't do this. People may tease you for it. # This is meant to be easy to understand for demonstration @@ -49,7 +52,7 @@ async def chatter(rc: veilid.api.RoutingContext, key: str, send_channel: int, re # callback function to handle events asynchronously. while True: # Try to get an updated version of the receiving subkey. - resp = await rc.get_dht_value(key, recv_subkey, True) + resp = await router.get_dht_value(key, recv_subkey, True) if resp is None: continue @@ -72,30 +75,32 @@ async def start(host: str, port: int, name: str): conn = await veilid.json_api_connect(host, port, noop_callback) keys = config.read_keys() - my_key = veilid.KeyPair(keys["self"]) + my_keypair = keys["self"] + their_key = keys["peers"][name] members = [ - veilid.types.DHTSchemaSMPLMember(my_key.key(), 1), - veilid.types.DHTSchemaSMPLMember(keys["peers"][name], 1), + veilid.DHTSchemaSMPLMember(my_keypair.key(), 1), + veilid.DHTSchemaSMPLMember(their_key, 1), ] - router = await(await conn.new_routing_context()).with_privacy() - async with router: - rec = await router.create_dht_record(veilid.DHTSchema.smpl(0, members)) - print(f"New chat key: {rec.key}") + router = await (await conn.new_routing_context()).with_privacy() + crypto_system = await conn.get_crypto_system(veilid.CryptoKind.CRYPTO_KIND_VLD0) + async with router, crypto_system: + record = await router.create_dht_record(veilid.DHTSchema.smpl(0, members)) + print(f"New chat key: {record.key}") print("Give that to your friend!") # Close this key first. We'll reopen it for writing with our saved key. - await router.close_dht_record(rec.key) + await router.close_dht_record(record.key) - await router.open_dht_record(rec.key, veilid.KeyPair(keys["self"])) + await router.open_dht_record(record.key, my_keypair) try: # Write to the 1st subkey and read from the 2nd. - await chatter(router, rec.key, 0, 1) + await chatter(router, crypto_system, record.key, 0, 1) finally: - await router.close_dht_record(rec.key) - await router.delete_dht_record(rec.key) + await router.close_dht_record(record.key) + await router.delete_dht_record(record.key) async def respond(host: str, port: int, key: str): @@ -104,14 +109,15 @@ async def respond(host: str, port: int, key: str): conn = await veilid.json_api_connect(host, port, noop_callback) keys = config.read_keys() - my_key = veilid.KeyPair(keys["self"]) + my_keypair = keys["self"] - router = await(await conn.new_routing_context()).with_privacy() - async with router: - await router.open_dht_record(key, my_key) + router = await (await conn.new_routing_context()).with_privacy() + crypto_system = await conn.get_crypto_system(veilid.CryptoKind.CRYPTO_KIND_VLD0) + async with router, crypto_system: + await router.open_dht_record(key, my_keypair) # As the responder, we're writing to the 2nd subkey and reading from the 1st. - await chatter(router, key, 1, 0) + await chatter(router, crypto_system, key, 1, 0) async def keygen(host: str, port: int): @@ -121,17 +127,17 @@ async def keygen(host: str, port: int): crypto_system = await conn.get_crypto_system(veilid.CryptoKind.CRYPTO_KIND_VLD0) async with crypto_system: - my_key = await crypto_system.generate_key_pair() + my_keypair = await crypto_system.generate_key_pair() keys = config.read_keys() if keys["self"]: print("You already have a keypair.") sys.exit(1) - keys["self"] = my_key + keys["self"] = my_keypair config.write_keys(keys) - print(f"Your new public key is {my_key.key()}. Share it with your friends!") + print(f"Your new public key is {my_keypair.key()}. Share it with your friends!") async def add_friend(host: str, port: int, name: str, pubkey: str): @@ -147,7 +153,7 @@ async def clean(host: str, port: int, key: str): conn = await veilid.json_api_connect(host, port, noop_callback) - router = await(await conn.new_routing_context()).with_privacy() + router = await (await conn.new_routing_context()).with_privacy() async with router: await router.close_dht_record(key) await router.delete_dht_record(key) diff --git a/veilid-python/demo/config.py b/veilid-python/demo/config.py index 8479611e..12df6ccb 100644 --- a/veilid-python/demo/config.py +++ b/veilid-python/demo/config.py @@ -3,6 +3,8 @@ import json from pathlib import Path +import veilid + KEYFILE = Path(".demokeys") @@ -10,14 +12,19 @@ def read_keys() -> dict: """Load the stored keys from disk.""" try: - keydata = KEYFILE.read_text() + raw = KEYFILE.read_text() except FileNotFoundError: return { "self": None, "peers": {}, } - return json.loads(keydata) + keys = json.loads(raw) + if keys["self"] is not None: + keys["self"] = veilid.KeyPair(keys["self"]) + for name, pubkey in keys["peers"].items(): + keys["peers"][name] = veilid.PublicKey(pubkey) + return keys def write_keys(keydata: dict):