distributed-state-network 0.4.1__tar.gz → 0.5.0__tar.gz

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed-state-network
-Version: 0.4.1
+Version: 0.5.0
 Summary: A tool to distribute the state of a network device to other devices on the network
 Project-URL: Homepage, https://github.com/erinclemmer/distributed_state_network
 Project-URL: Issues, https://github.com/erinclemmer/distributed_state_network/issues
@@ -54,14 +54,10 @@ The simplest DSN network is a single node:
 ```python
 from distributed_state_network import DSNodeServer, DSNodeConfig
 
-# Generate a network key (do this once for your entire network)
-DSNodeServer.generate_key("network.key")
-
 # Start a node
 node = DSNodeServer.start(DSNodeConfig(
     node_id="my_first_node",
     port=8000,
-    aes_key_file="network.key",
     bootstrap_nodes=[]  # Empty for the first node
 ))
 
@@ -89,7 +85,6 @@ Create a network of temperature sensors that share readings:
 sensor_node = DSNodeServer.start(DSNodeConfig(
     node_id=f"sensor_{location}",
     port=8000,
-    aes_key_file="network.key",
     bootstrap_nodes=[{"address": "coordinator.local", "port": 8000}]
 ))
 

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/README.md

@@ -28,14 +28,10 @@ The simplest DSN network is a single node:
 ```python
 from distributed_state_network import DSNodeServer, DSNodeConfig
 
-# Generate a network key (do this once for your entire network)
-DSNodeServer.generate_key("network.key")
-
 # Start a node
 node = DSNodeServer.start(DSNodeConfig(
     node_id="my_first_node",
     port=8000,
-    aes_key_file="network.key",
     bootstrap_nodes=[]  # Empty for the first node
 ))
 
@@ -63,7 +59,6 @@ Create a network of temperature sensors that share readings:
 sensor_node = DSNodeServer.start(DSNodeConfig(
     node_id=f"sensor_{location}",
     port=8000,
-    aes_key_file="network.key",
     bootstrap_nodes=[{"address": "coordinator.local", "port": 8000}]
 ))
 

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/documentation/ds-node-config.md

@@ -12,14 +12,14 @@ from distributed_state_network import DSNodeConfig
 class DSNodeConfig:
     node_id: str
     port: int
-    aes_key_file: str
+    aes_key: str
     bootstrap_nodes: List[Endpoint]
 ```
 
 ### Attributes
 - **node_id** (`str`): Unique identifier for the node
 - **port** (`int`): Port number for the node to listen on (UDP)
-- **aes_key_file** (`str`): Path to the AES key file for encryption/decryption
+- **aes_key** (`str`): Hexidecimal encoded AES key for network encryption
 - **bootstrap_nodes** (`List[Endpoint]`): List of initial nodes to connect to when joining the network
 
 **Note:** The node's public IP address is automatically detected by the bootstrap server during the initial handshake.
@@ -40,7 +40,6 @@ Creates a DSNodeConfig instance from a dictionary.
 config_dict = {
     "node_id": "node1",
     "port": 8000,
-    "aes_key_file": "/path/to/key.aes",
     "bootstrap_nodes": [
         {"address": "127.0.0.1", "port": 8001}
     ]
@@ -53,7 +52,6 @@ config = DSNodeConfig.from_dict(config_dict)
 config_dict = {
     "node_id": "bootstrap",
     "port": 8000,
-    "aes_key_file": "/path/to/key.aes",
     "bootstrap_nodes": []  # Empty for first node
 }
 config = DSNodeConfig.from_dict(config_dict)

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/documentation/ds-node-server.md

@@ -59,7 +59,6 @@ server = DSNodeServer.start(config)
 bootstrap_config = DSNodeConfig(
     node_id="bootstrap",
     port=8000,
-    aes_key_file="network.key",
     bootstrap_nodes=[]
 )
 bootstrap = DSNodeServer.start(bootstrap_config)
@@ -68,21 +67,20 @@ bootstrap = DSNodeServer.start(bootstrap_config)
 connector_config = DSNodeConfig(
     node_id="connector",
     port=8001,
-    aes_key_file="network.key",
     bootstrap_nodes=[Endpoint("127.0.0.1", 8000)]
 )
 connector = DSNodeServer.start(connector_config)
 ```
 
-### `generate_key(out_file_path: str) -> None`
-Generates a new AES key file for network encryption. All nodes in the same network must share the same AES key.
+### `generate_key() -> str`
+Generates a new hexadecimal encoded AES key for network encryption. All nodes in the same network must share the same AES key.
 
 **Parameters:**
-- `out_file_path` (`str`): Path where the key file will be saved
+- None
 
 **Example:**
 ```python
-DSNodeServer.generate_key("/path/to/network.key")
+DSNodeServer.generate_key()
 ```
 
 ### Instance Methods
@@ -145,13 +143,13 @@ All shared state is protected with appropriate locks.
 from distributed_state_network import DSNodeServer, DSNodeConfig, Endpoint
 
 # Generate shared AES key (only once)
-DSNodeServer.generate_key("shared.key")
+key = DSNodeServer.generate_key()
 
 # Start bootstrap node
 bootstrap = DSNodeServer.start(DSNodeConfig(
     node_id="bootstrap",
     port=8000,
-    aes_key_file="shared.key",
+    aes_key=key,
     bootstrap_nodes=[]
 ))
 
@@ -159,14 +157,14 @@ bootstrap = DSNodeServer.start(DSNodeConfig(
 node1 = DSNodeServer.start(DSNodeConfig(
     node_id="node1",
     port=8001,
-    aes_key_file="shared.key",
+    aes_key=key,
     bootstrap_nodes=[Endpoint("192.168.1.100", 8000)]
 ))
 
 node2 = DSNodeServer.start(DSNodeConfig(
     node_id="node2",
     port=8002,
-    aes_key_file="shared.key",
+    aes_key=key,
     bootstrap_nodes=[Endpoint("192.168.1.100", 8000)]
 ))
 

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/documentation/usage.md

@@ -9,7 +9,6 @@ from distributed_state_network import DSNodeServer, DSNodeConfig, Endpoint
 config = DSNodeConfig(
     node_id="node1",
     port=8000,
-    aes_key_file="/path/to/shared.key",
     bootstrap_nodes=[]  # Empty for first node
 )
 
@@ -38,7 +37,6 @@ server.stop()
 config2 = DSNodeConfig(
     node_id="node2",
     port=8001,
-    aes_key_file="/path/to/shared.key",  # Same key file as network
     bootstrap_nodes=[
         Endpoint("127.0.0.1", 8000)  # Node 1's endpoint
     ]
@@ -65,7 +63,6 @@ custom_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 config = DSNodeConfig(
     node_id="node3",
     port=8003,  # Should match the bound port
-    aes_key_file="/path/to/shared.key",
     bootstrap_nodes=[Endpoint("127.0.0.1", 8000)]
 )
 
@@ -83,7 +80,6 @@ def handle_disconnect():
 config = DSNodeConfig(
     node_id="node4",
     port=8004,
-    aes_key_file="/path/to/shared.key",
     bootstrap_nodes=[Endpoint("127.0.0.1", 8000)]
 )
 
@@ -100,7 +96,6 @@ def handle_update():
 config = DSNodeConfig(
     node_id="node5",
     port=8005,
-    aes_key_file="/path/to/shared.key",
     bootstrap_nodes=[Endpoint("127.0.0.1", 8000)]
 )
 
@@ -126,7 +121,6 @@ custom_sock.bind(("0.0.0.0", 8006))
 config = DSNodeConfig(
     node_id="node6",
     port=8006,
-    aes_key_file="/path/to/shared.key",
     bootstrap_nodes=[
         Endpoint("127.0.0.1", 8000),
         Endpoint("127.0.0.1", 8001)  # Multiple bootstrap options

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "distributed-state-network"
-version = "0.4.1"
+version = "0.5.0"
 authors = [{name="Erin Clemmer", email="erin.c.clemmer@gmail.com"}]
 description = "A tool to distribute the state of a network device to other devices on the network"
 keywords = ["distributed", "networking"]

distributed_state_network-0.5.0/src/distributed_state_network/create_key.py

@@ -0,0 +1,4 @@
+import sys
+from util.aes import generate_aes_key
+
+print("Key: " + generate_aes_key().hex())

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/src/distributed_state_network/dsnode.py

@@ -49,7 +49,7 @@ class DSNode:
         self.version = version
         self.server = None  # Reference to the Flask server
         
-        self.cred_manager = CredentialManager(config.node_id)
+        self.cred_manager = CredentialManager("credentials", config.node_id)
         self.cred_manager.generate_keys()
         
         self.node_states = {
@@ -65,19 +65,14 @@ class DSNode:
         self.logger = logging.getLogger("DSN: " + config.node_id)
         self.disconnect_cb = disconnect_callback
         self.update_cb = update_callback
-        if not os.path.exists(config.aes_key_file):
-            raise Exception(f"Could not find aes key file in {config.aes_key_file}")
         
         threading.Thread(target=self.network_tick, daemon=True).start()
 
     def set_server(self, server):
-        """Set reference to the Flask server"""
         self.server = server
 
-    def get_aes_key(self):
-        with open(self.config.aes_key_file, 'r') as f:
-            key_hex = f.read()
-            return bytes.fromhex(key_hex)
+    def get_aes_key(self) -> bytes:
+        return bytes.fromhex(self.config.aes_key)
 
     def network_tick(self):
         time.sleep(TICK_INTERVAL)
@@ -110,8 +105,9 @@ class DSNode:
         """Send HTTP request and wait for response"""
         try:
             # Prepend message type to payload
-            data_with_type = bytes([msg_type]) + payload
-            encrypted_data = self.encrypt_data(data_with_type)
+            data = bytes([msg_type]) + payload
+            if self.config.aes_key is not None:
+                data = self.encrypt_data(data)
             
             # Determine the URL path based on message type
             path = MSG_TYPE_TO_PATH.get(msg_type, '/unknown')
@@ -120,7 +116,7 @@ class DSNode:
             # Send HTTP POST request
             response = requests.post(
                 url,
-                data=encrypted_data,
+                data=data,
                 headers={'Content-Type': 'application/octet-stream'},
                 timeout=HTTP_TIMEOUT
             )
@@ -132,19 +128,21 @@ class DSNode:
             elif response.status_code != 200:
                 raise Exception(f"HTTP error: {response.status_code}")
             
+            response_data = response.content
             # Decrypt the response
-            decrypted = self.decrypt_data(response.content)
+            if self.config.aes_key is not None:
+                response_data = self.decrypt_data(response_data)
             
-            if len(decrypted) < 1:
+            if len(response_data) < 1:
                 raise Exception("Empty response")
             
             # First byte is message type
-            response_msg_type = decrypted[0]
+            response_msg_type = response_data[0]
             if response_msg_type != msg_type:
                 raise Exception(f"Response message type mismatch: expected {msg_type}, got {response_msg_type}")
             
             # Return the body (everything after the message type byte)
-            return decrypted[1:]
+            return response_data[1:]
             
         except requests.exceptions.Timeout:
             if retries < 2:

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/src/distributed_state_network/handler.py

@@ -8,7 +8,7 @@ from distributed_state_network.objects.config import DSNodeConfig
 from distributed_state_network.util.aes import generate_aes_key
 from distributed_state_network.util import stop_thread
 
-VERSION = "0.4.1"
+VERSION = "0.5.0"
 logging.basicConfig(level=logging.INFO)
 
 # Silence Flask and Werkzeug logging
@@ -66,14 +66,15 @@ class DSNodeServer:
         """Handle incoming HTTP request"""
         try:
             # Decrypt the data
-            decrypted = self.node.decrypt_data(data)
+            if self.config.aes_key is not None:
+                data = self.node.decrypt_data(data)
             
-            if len(decrypted) < 1:
+            if len(data) < 1:
                 return Response(status=400)
             
             # First byte should be message type (for verification)
-            received_msg_type = decrypted[0]
-            body = decrypted[1:]
+            received_msg_type = data[0]
+            body = data[1:]
             
             if received_msg_type != msg_type:
                 self.node.logger.error(f"Message type mismatch: expected {msg_type}, got {received_msg_type}")
@@ -98,8 +99,9 @@ class DSNodeServer:
             if response_data is not None:
                 # Prepend message type to response
                 response_with_type = bytes([msg_type]) + response_data
-                encrypted_response = self.node.encrypt_data(response_with_type)
-                return Response(encrypted_response, status=200, mimetype='application/octet-stream')
+                if self.config.aes_key is not None:
+                    response_with_type = self.node.encrypt_data(response_with_type)
+                return Response(response_with_type, status=200, mimetype='application/octet-stream')
             else:
                 return Response(status=204)  # No content
                 
@@ -130,10 +132,8 @@ class DSNodeServer:
         self.node.logger.info(f'Started DSNode on HTTP port {port}')
 
     @staticmethod
-    def generate_key(out_file_path: str):
-        key = generate_aes_key()
-        with open(out_file_path, 'wb') as f:
-            f.write(key)
+    def generate_key() -> str:
+        return generate_aes_key().hex()
 
     @staticmethod 
     def start(

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/src/distributed_state_network/objects/config.py

@@ -7,7 +7,7 @@ from distributed_state_network.objects.endpoint import Endpoint
 class DSNodeConfig:
     node_id: str
     port: int
-    aes_key_file: str
+    aes_key: str | None
     bootstrap_nodes: List[Endpoint]
 
     @staticmethod
@@ -15,6 +15,6 @@ class DSNodeConfig:
         return DSNodeConfig(
             data["node_id"], 
             data["port"], 
-            data["aes_key_file"], 
+            data["aes_key"] if "aes_key" in data else None, 
             [Endpoint.from_json(e) for e in data["bootstrap_nodes"]]
         )

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/src/distributed_state_network/util/key_manager.py

@@ -77,10 +77,6 @@ class KeyManager:
         with open(f'{self.folder}/{self.node_id}/{self.node_id}.{self.private_extension}', 'wb') as f:
             f.write(key_bytes)
 
-class CertManager(KeyManager):
-    def __init__(self, node_id: str):
-        KeyManager.__init__(self, "HTTPS", node_id, "certs", "crt", "key", generate_cert)
-
 class CredentialManager(KeyManager):
-    def __init__(self, node_id: str):
-        KeyManager.__init__(self, "ECDSA", node_id, "credentials", "pub", "key", generate_key_pair)
+    def __init__(self, folder: str, node_id: str):
+        KeyManager.__init__(self, "ECDSA", node_id, folder, "pub", "key", generate_key_pair)

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/technical.md

@@ -9,13 +9,13 @@ This is intended to be used as a middleware for another application rather than
 from distributed_state_network import DSNodeServer, DSNodeConfig
 
 # Write a new aes key to the current directory
-DSNodeServer.generate_key("test.key")
+aes_key = DSNodeServer.generate_key()
 
 # Use the key to start a new network
 bootstrap = DSNodeServer(DSNodeConfig(
     node_id="bootstrap", # Network ID for the node
     port=8000, # Port to host the server on
-    aes_key_file="test.key" # Key file for authentication to the network
+    aes_key=aes_key # Key file for authentication to the network
 ))
 ```
 
@@ -26,10 +26,12 @@ To connect another node to we will copy the AES key file to the new machine and
 ```python
 from distributed_state_network import DSNodeServer, DSNodeConfig
 
+KEY = "..."
+
 connector = DSNodeServer(DSNodeConfig(
     node_id="connector", # New node ID
     port=8000, # Port to host the new server on
-    aes_key_file= "test.key", # Key file that was copied from first machine
+    aes_key= KEY, # Key file that was copied from first machine
     bootstrap_nodes= [
         {
             # IP address of bootstrap node

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0}/tests/connections.py

@@ -8,10 +8,7 @@ sys.path.append(os.path.join(os.path.dirname(__file__), '../src'))
 
 from distributed_state_network import DSNodeServer, DSNodeConfig, Endpoint
 
-KEY_FILE = "network.key"
-
-if not os.path.exists(KEY_FILE):
-    DSNodeServer.generate_key("network.key")
+aes_key = DSNodeServer.generate_key()
 
 cb_test = 0
 
@@ -22,7 +19,7 @@ def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional
     args = {
         "node_id": node_id,
         "port": current_port,
-        "aes_key_file": KEY_FILE
+        "aes_key": aes_key
     }
     current_port += 1
     if bootstrap_port is not None:

{distributed_state_network-0.4.1 → distributed_state_network-0.5.0/tests}/test.py

@@ -7,23 +7,19 @@ import unittest
 import requests
 from typing import List, Dict
 
-sys.path.append(os.path.join(os.path.dirname(__file__), './src'))
+sys.path.append(os.path.join(os.path.dirname(__file__), '../src'))
 
 from distributed_state_network import DSNodeServer, Endpoint, DSNodeConfig
 
 from distributed_state_network.objects.state_packet import StatePacket
 from distributed_state_network.objects.hello_packet import HelloPacket
 
-from distributed_state_network.util.key_manager import CertManager
 from distributed_state_network.util.aes import generate_aes_key
 
 current_port = 8000
 nodes = []
 
-key_file = "src/distributed_state_network/test.key"
-
-if not os.path.exists(key_file):
-    DSNodeServer.generate_key(key_file)
+aes_key = DSNodeServer.generate_key()
 
 def spawn_node(node_id: str, bootstrap_nodes: List[Dict] = []):
     global current_port
@@ -31,7 +27,7 @@ def spawn_node(node_id: str, bootstrap_nodes: List[Dict] = []):
     n = DSNodeServer.start(DSNodeConfig.from_dict({
         "node_id": node_id,
         "port": current_port,
-        "aes_key_file": key_file,
+        "aes_key": aes_key,
         "bootstrap_nodes": bootstrap_nodes
     }))
     global nodes
@@ -264,7 +260,7 @@ class TestNode(unittest.TestCase):
         config_dict = {
             "node_id": "node",
             "port": 8000,
-            "aes_key_file": "test.key",
+            "aes_key": "XXX",
             "bootstrap_nodes": [
                 {
                     "address": "127.0.0.1",
@@ -276,7 +272,7 @@ class TestNode(unittest.TestCase):
         config = DSNodeConfig.from_dict(config_dict)
         self.assertEqual(config_dict["node_id"], config.node_id)
         self.assertEqual(config_dict["port"], config.port)
-        self.assertEqual(config_dict["aes_key_file"], config.aes_key_file)
+        self.assertEqual(config_dict["aes_key"], config.aes_key)
         self.assertTrue(len(config.bootstrap_nodes) > 0)
         self.assertEqual(config_dict["bootstrap_nodes"][0]["address"], config.bootstrap_nodes[0].address)
         self.assertEqual(config_dict["bootstrap_nodes"][0]["port"], config.bootstrap_nodes[0].port)
@@ -307,30 +303,8 @@ class TestNode(unittest.TestCase):
             print(e)
 
     def test_aes(self):
-        test_key_file = 'delete_me.key'
-        DSNodeServer.generate_key(test_key_file)
-        with open(test_key_file, 'rb') as f:
-            key = f.read()
-        self.assertEqual(32, len(key))
-        os.remove(test_key_file)
-
-    def test_write_cert(self):
-        if os.path.exists('certs'):
-            shutil.rmtree('certs')
-        cm = CertManager('test')
-        cm.write_public('test', b'TEST')
-        self.assertTrue(os.path.exists('certs/test/test.crt'))
-        shutil.rmtree('certs')
-
-    def test_read_public(self):
-        if os.path.exists('certs'):
-            shutil.rmtree('certs')
-        cm = CertManager('test')
-        try:
-            cm.read_public('test')
-        except Exception as e:
-            self.assertEqual(e.args[0], 401)
-            self.assertEqual(e.args[1], "Cannot find public ECDSA key for test")
+        key = DSNodeServer.generate_key()
+        self.assertEqual(64, len(key))
 
     def test_authentication_reset(self):
         bootstrap = spawn_node("bootstrap")

distributed_state_network-0.4.1/src/distributed_state_network/create_key.py

@@ -1,10 +0,0 @@
-import sys
-from util.aes import generate_aes_key
-
-if len(sys.argv) < 2:
-    raise Exception("Usage: python create_key.py [output_key_file_location]")
-
-location = sys.argv[1]
-
-with open(location, 'wb') as f:
-    f.write(generate_aes_key())