distributed-state-network 0.6.7__tar.gz → 1.0.0__tar.gz

distributed_state_network-1.0.0/.gitignore

@@ -0,0 +1,3 @@
+dist/
+*.egg-info/
+__pycache__/

{distributed_state_network-0.6.7 → distributed_state_network-1.0.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Colton Clemmer
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 Colton Clemmer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

distributed_state_network-1.0.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: distributed-state-network
+Version: 1.0.0
+Summary: Peer-to-peer encrypted state-sharing network over HTTP
+Project-URL: Homepage, https://github.com/erinclemmer/language-pipes
+Project-URL: Issues, https://github.com/erinclemmer/language-pipes/issues
+Author-email: Erin Clemmer <erin.c.clemmer@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: distributed,encryption,networking,peer-to-peer,state
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: cryptography
+Requires-Dist: ecdsa
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# distributed-state-network
+
+A peer-to-peer network of nodes that share replicated state over HTTP, with
+per-message AES encryption and ECDSA-signed packets. Each node gossips its
+state to peers; the network self-organizes from a set of bootstrap nodes.
+
+This is the networking layer used by
+[language-pipes](https://github.com/erinclemmer/language-pipes), but has no
+dependency on it and can be used on its own.
+
+## Install
+
+```bash
+pip install distributed-state-network
+```
+
+## Usage
+
+```python
+from distributed_state_network import DSNodeServer, DSNodeConfig
+
+key = DSNodeServer.generate_key()
+server = DSNodeServer.start(DSNodeConfig(
+    node_id="node-a",
+    network_ip="127.0.0.1",
+    port=8000,
+    aes_key=key,
+))
+```
+
+See `src/distributed_state_network/` for the packet types, key management, and
+node handler implementation.
+
+## License
+
+MIT

distributed_state_network-1.0.0/README.md

@@ -0,0 +1,36 @@
+# distributed-state-network
+
+A peer-to-peer network of nodes that share replicated state over HTTP, with
+per-message AES encryption and ECDSA-signed packets. Each node gossips its
+state to peers; the network self-organizes from a set of bootstrap nodes.
+
+This is the networking layer used by
+[language-pipes](https://github.com/erinclemmer/language-pipes), but has no
+dependency on it and can be used on its own.
+
+## Install
+
+```bash
+pip install distributed-state-network
+```
+
+## Usage
+
+```python
+from distributed_state_network import DSNodeServer, DSNodeConfig
+
+key = DSNodeServer.generate_key()
+server = DSNodeServer.start(DSNodeConfig(
+    node_id="node-a",
+    network_ip="127.0.0.1",
+    port=8000,
+    aes_key=key,
+))
+```
+
+See `src/distributed_state_network/` for the packet types, key management, and
+node handler implementation.
+
+## License
+
+MIT

distributed_state_network-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "distributed-state-network"
+version = "1.0.0"
+authors = [{name="Erin Clemmer", email="erin.c.clemmer@gmail.com"}]
+description = "Peer-to-peer encrypted state-sharing network over HTTP"
+keywords = ["distributed", "networking", "peer-to-peer", "state", "encryption"]
+license = "MIT"
+readme = "README.md"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Development Status :: 4 - Beta",
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: System :: Networking",
+    "Typing :: Typed"
+]
+requires-python = ">=3.10"
+dependencies = [
+    "requests",
+    "ecdsa",
+    "cryptography"
+]
+
+[project.urls]
+Homepage = "https://github.com/erinclemmer/language-pipes"
+Issues = "https://github.com/erinclemmer/language-pipes/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/distributed_state_network"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

{distributed_state_network-0.6.7 → distributed_state_network-1.0.0}/src/distributed_state_network/__init__.py

@@ -1,4 +1,5 @@
 from distributed_state_network.handler import DSNodeServer
 from distributed_state_network.dsnode import DSNode
 from distributed_state_network.objects.config import DSNodeConfig
-from distributed_state_network.objects.endpoint import Endpoint
+from distributed_state_network.objects.endpoint import Endpoint
+from distributed_state_network.network_protocol import StateNetworkNode

{distributed_state_network-0.6.7 → distributed_state_network-1.0.0}/src/distributed_state_network/dsnode.py

@@ -1,10 +1,9 @@
-import os
 import time
 import random
 import logging
 import threading
 import requests
-from typing import Dict, List, Optional, Callable
+from typing import Dict, List, Optional, Callable, Tuple
 
 from distributed_state_network.objects.endpoint import Endpoint
 from distributed_state_network.objects.hello_packet import HelloPacket
@@ -15,11 +14,13 @@ from distributed_state_network.objects.config import DSNodeConfig
 
 from distributed_state_network.util import get_dict_hash
 from distributed_state_network.util.key_manager import CredentialManager
-from distributed_state_network.util.aes import aes_encrypt, aes_decrypt
+from distributed_state_network.util.aes import aes_encrypt, aes_decrypt, AES_KEY_LENGTH
 
 TICK_INTERVAL = 3
 HTTP_TIMEOUT = 2  # seconds
 
+MIN_TRANSFER_BYTES_PER_SEC = 1024 * 1024  # 1 MB/s floor
+
 # Message type constants (must match handler.py)
 MSG_HELLO = 1
 MSG_PEERS = 2
@@ -41,18 +42,24 @@ class DSNode:
     config: DSNodeConfig
     address_book: Dict[str, Endpoint]
     node_states: Dict[str, StatePacket]
-    shutting_down: bool = False
+    shutting_down: bool
+    logs: List[Tuple[float, str]]
+    create_alert: Callable[[str], None]
 
     def __init__(
             self, 
             config: DSNodeConfig,
             version: str,
+            create_alert: Callable[[str], None],
             disconnect_callback: Optional[Callable] = None,
             update_callback: Optional[Callable] = None,
             receive_callback: Optional[Callable] = None
         ):
         self.config = config
         self.version = version
+        self.shutting_down = False
+        self.create_alert = create_alert
+        self.logs = []
         
         self.cred_manager = CredentialManager(config.credential_dir, config.node_id)
         self.cred_manager.generate_keys()
@@ -65,31 +72,83 @@ class DSNode:
             self.config.node_id: Endpoint(self.config.network_ip, config.port)
         }
         
-        self.logger = logging.getLogger("DSN: " + config.node_id)
+        self.logger = logging.getLogger(__name__)
         self.disconnect_cb = disconnect_callback
         self.update_cb = update_callback
         self.receive_cb = receive_callback
+
+        # Validate configured AES key eagerly so bad/legacy key formats fail fast.
+        self.get_aes_key()
+        self.add_log(f"Starting network server on port {config.port}")
         
         threading.Thread(target=self.network_tick, daemon=True).start()
 
-    def get_aes_key(self) -> bytes:
-        return bytes.fromhex(self.config.aes_key)
+    def add_log(self, msg: str, level: str = "INFO"):
+        if level.upper() == "INFO":
+            self.logger.info(msg)
+        elif level.upper() == "ERROR":
+            self.logger.error(msg)
+        elif level.upper() == "DEBUG":
+            self.logger.debug(msg)
+        elif level.upper() == "WARNING":
+            self.logger.warning(msg)
+        else:
+            self.logger.info(msg)
+        
+        self.logs.append((time.time(), msg))
+
+    def get_aes_key(self) -> Optional[bytes]:
+        if self.config.aes_key is None:
+            return None
+        key = bytes.fromhex(self.config.aes_key)
+        if len(key) != AES_KEY_LENGTH:
+            raise ValueError(
+                f"Invalid AES key length ({len(key)} bytes). Expected {AES_KEY_LENGTH} bytes."
+            )
+        return key
+    
+    def _is_ip_whitelisted(self, ip: Optional[str]) -> bool:
+        if len(self.config.whitelist_ips) == 0:
+            return True
+        if ip is None:
+            return False
+        return ip in self.config.whitelist_ips
+
+    def ensure_ip_allowed(self, ip: Optional[str]):
+        if not self._is_ip_whitelisted(ip):
+            raise Exception(401, f"IP address '{ip}' is not in whitelist")
+
+    def _is_node_id_whitelisted(self, node_id: Optional[str]) -> bool:
+        if len(self.config.whitelist_node_ids) == 0:
+            return True
+        if node_id is None:
+            return False
+        if node_id == self.config.node_id:
+            return True
+        return node_id in self.config.whitelist_node_ids
+
+    def ensure_node_id_allowed(self, node_id: Optional[str]):
+        if not self._is_node_id_whitelisted(node_id):
+            raise Exception(401, f"{node_id} not in {self.config.node_id}'s whitelist")
+
+    def ensure_endpoint_allowed(self, endpoint: Endpoint):
+        self.ensure_ip_allowed(endpoint.address)
 
     def write_address_book(self, node_id: str, conn: Endpoint):
-        if conn.address == "127.0.0.1" and conn.port == self.config.port:
-            raise Exception("Trying to write address book for self")
-        self.logger.info(f"Address set: {node_id} -> {conn.address}:{conn.port}")
+        if node_id != self.config.node_id:
+            self.ensure_node_id_allowed(node_id)
+            self.ensure_endpoint_allowed(conn)
         self.address_book[node_id] = conn
 
     def network_tick(self):
-        time.sleep(TICK_INTERVAL)
-        if self.shutting_down:
-            self.logger.info("Shutting down node")
-            return
-        self.test_connections()
-        self.gossip()
-        threading.Thread(target=self.network_tick, daemon=True).start()
-
+        while True:
+            time.sleep(TICK_INTERVAL)
+            if self.shutting_down:
+                self.add_log("Shutting down node", "INFO")
+                return
+            self.test_connections()
+            self.gossip()
+        
     def gossip(self):
         if len(self.address_book.keys()) == 0:
             return
@@ -105,7 +164,6 @@ class DSNode:
                 del self.node_states[node_id]
             if node_id in self.address_book:    
                 del self.address_book[node_id]
-            self.logger.info(f"PING failed for {node_id}, disconnecting...")
         
         for node_id in self.node_states.copy().keys():
             if node_id not in self.node_states or node_id == self.config.node_id:
@@ -115,14 +173,16 @@ class DSNode:
                     return
                 self.send_ping(node_id)
             except Exception:
-                self.logger.error(f"PING Failure for {node_id}")
                 if node_id in self.node_states:  # double check if something has changed since the ping request started
                     remove(node_id)
+                    msg = f"{node_id} has disconnected"
+                    self.add_log(msg)
                     if self.disconnect_cb is not None:
                         self.disconnect_cb()
 
     def send_http_request(self, endpoint: Endpoint, msg_type: int, payload: bytes, retries: int = 0) -> bytes:
         """Send HTTP request and wait for response"""
+        self.ensure_endpoint_allowed(endpoint)
         try:
             # Prepend message type to payload
             data = bytes([msg_type]) + payload
@@ -133,12 +193,15 @@ class DSNode:
             path = MSG_TYPE_TO_PATH.get(msg_type, '/unknown')
             url = f"http://{endpoint.address}:{endpoint.port}{path}"
             
+            # Scale timeout to transfer size
+            timeout = max(HTTP_TIMEOUT, len(data) / MIN_TRANSFER_BYTES_PER_SEC)
+
             # Send HTTP POST request
             response = requests.post(
                 url,
                 data=data,
                 headers={'Content-Type': 'application/octet-stream'},
-                timeout=HTTP_TIMEOUT
+                timeout=timeout
             )
             
             # Check response status
@@ -146,7 +209,7 @@ class DSNode:
                 # No content - valid for some responses like successful HELLO with no data
                 return b''
             elif response.status_code != 200:
-                raise Exception(f"HTTP error: {response.status_code}")
+                raise Exception(response.status_code, response.content.decode())
             
             response_data = response.content
             # Decrypt the response
@@ -170,28 +233,29 @@ class DSNode:
                 return self.send_http_request(endpoint, msg_type, payload, retries + 1)
             else:
                 raise Exception(f"HTTP request to {endpoint.to_string()} timed out")
-        except requests.exceptions.RequestException as e:
+        except requests.exceptions.RequestException:
             if retries < 2:
                 time.sleep(0.5)
                 return self.send_http_request(endpoint, msg_type, payload, retries + 1)
             else:
-                raise Exception(f"HTTP request to {endpoint.to_string()} failed: {e}")
-        except Exception as e:
-            if retries < 2:
-                time.sleep(0.5)
-                return self.send_http_request(endpoint, msg_type, payload, retries + 1)
-            else:
-                raise Exception(f"HTTP request to {endpoint.to_string()} failed: {e}")
+                raise Exception(f"HTTP request to {endpoint.to_string()} failed")
 
     def send_request_to_node(self, node_id: str, msg_type: int, payload: bytes) -> bytes:
+        self.ensure_node_id_allowed(node_id)
         con = self.connection_from_node(node_id)
         return self.send_http_request(con, msg_type, payload)
 
     def encrypt_data(self, data: bytes) -> bytes:
-        return aes_encrypt(self.get_aes_key(), data)
+        key = self.get_aes_key()
+        if key is None:
+            return data
+        return aes_encrypt(key, data)
 
     def decrypt_data(self, data: bytes) -> bytes:
-        return aes_decrypt(self.get_aes_key(), data)
+        key = self.get_aes_key()
+        if key is None:
+            return data
+        return aes_decrypt(key, data)
 
     def request_peers(self, node_id: str):
         pkt = PeersPacket(self.config.node_id, None, { })
@@ -215,6 +279,7 @@ class DSNode:
 
     def handle_peers(self, data: bytes):
         pkt = PeersPacket.from_bytes(data)
+        self.ensure_node_id_allowed(pkt.node_id)
         if pkt.node_id not in self.address_book:
             raise Exception(401, f"Could not find {pkt.node_id} in address book")  # Not Authorized
         
@@ -232,20 +297,30 @@ class DSNode:
         return pkt.to_bytes()
 
     def send_hello(self, con: Endpoint):
-        self.logger.info(f"HELLO => {con.to_string()}")
-
         pkt = self.my_hello_packet()
         payload = pkt.to_bytes()
-        content = self.send_http_request(con, MSG_HELLO, payload)
-        
+        try:
+            content = self.send_http_request(con, MSG_HELLO, payload)
+        except Exception as e:
+            if e.args[0] == 505 or e.args[0] == 401:
+                msg = f"Network Error: {e.args[1]}"
+                self.add_log(msg)
+            elif "HTTP request to" in e.args[0]:
+                msg = f"Connection to {con.address}:{con.port} failed"
+                self.logs.append((time.time(), msg))
+            if len(e.args) > 1:
+                code, msg = e.args
+                if msg == "Node ID not in whitelist":
+                    self.add_log(f"Error from {con.address}:{con.port}: Not in their whitelist")
+            raise e
+
         # Get the response packet
         pkt = HelloPacket.from_bytes(content)
-        self.logger.info(f"Received HELLO from {pkt.node_id}")
-        
+
         # Verify version compatibility
         if pkt.version != self.version:
-            msg = f"HELLO => {pkt.node_id} (Version mismatch \"{pkt.version}\" != \"{self.version}\")"
-            self.logger.error(msg)
+            msg = f"Network version mismatch \"{pkt.version}\" ({pkt.node_id}) != \"{self.version}\" ({self.config.node_id})"
+            self.add_log(msg, "ERROR")
             raise Exception(505)  # Version not supported
 
         # Store the peer's public key
@@ -253,9 +328,8 @@ class DSNode:
         
         # If the server sent us our detected IP, update our address book
         if pkt.detected_address:
-            self.logger.info(f"Server detected our IP as: {pkt.detected_address}")
             # Update our own connection in the address book with the detected IP
-            self.write_address_book(self.config.node_id, pkt.detected_address, self.config.port)
+            self.write_address_book(self.config.node_id, Endpoint(pkt.detected_address, self.config.port))
         
         self.write_address_book(pkt.node_id, con)
 
@@ -268,15 +342,19 @@ class DSNode:
         self.node_states[node_id] = StatePacket(node_id, 0, b'', { })
 
     def handle_hello(self, data: bytes, detected_address: str) -> bytes:
+        self.ensure_ip_allowed(detected_address)
         pkt = HelloPacket.from_bytes(data)
-        self.logger.info(f"Received HELLO from {pkt.node_id}")
+        self.ensure_node_id_allowed(pkt.node_id)
         if pkt.version != self.version:
-            msg = f"HELLO => {pkt.node_id} (Version mismatch \"{pkt.version}\" != \"{self.version}\")"
-            self.logger.error(msg)
-            raise Exception(505)  # Version not supported
+            msg = f"Network version mismatch \"{pkt.version}\" ({pkt.node_id}) != \"{self.version}\" ({self.config.node_id})"
+            self.add_log(msg, "ERROR")
+            self.create_alert(msg)
+            raise Exception(505, msg)  # Version not supported
 
         self.cred_manager.ensure_public(pkt.node_id, pkt.ecdsa_public_key)
         self.write_address_book(pkt.node_id, Endpoint(detected_address, pkt.connection.port))
+        if pkt.node_id != self.config.node_id:
+            self.add_log(f"{pkt.node_id} has connnected")
 
         if pkt.node_id not in self.node_states:
             self.init_state(pkt.node_id)
@@ -292,7 +370,7 @@ class DSNode:
             self.config.node_id, 
             self.my_con(), 
             self.cred_manager.my_public(), 
-            None,
+            b'',
             None  # No certificate for HTTP
         )
         pkt.sign(self.cred_manager.my_private())
@@ -300,31 +378,30 @@ class DSNode:
 
     def send_ping(self, node_id: str):     
         try:
-            conn = self.connection_from_node(node_id)
-            self.logger.debug(f"PING => {node_id} ({conn.address}:{conn.port})")
             self.send_request_to_node(node_id, MSG_PING, b' ')
         except Exception as e:
             raise Exception(f'PING => {node_id}: {e}')
 
     def send_update(self, node_id: str):
-        self.logger.debug(f"UPDATE => {node_id}")
-        content = self.send_request_to_node(node_id, MSG_UPDATE, self.my_state().to_bytes())
+        try:
+            content = self.send_request_to_node(node_id, MSG_UPDATE, self.my_state().to_bytes())
+        except Exception:
+            return b''
         return content
 
     def handle_update(self, data: bytes):
         pkt = StatePacket.from_bytes(data)
+        self.ensure_node_id_allowed(pkt.node_id)
         
         if not self.update_state(pkt):
             return b''
 
-        self.logger.info(f"Received UPDATE from {pkt.node_id}")
-
         if self.update_cb is not None:
             try:
                 self.update_cb()
             except Exception as e:
-                self.logger.error("Update Error Captured:")
-                self.logger.error(str(e))
+                self.add_log("Update Error Captured:", "ERROR")
+                self.add_log(str(e), "ERROR")
 
         return self.my_state().to_bytes()
 
@@ -395,7 +472,7 @@ class DSNode:
     
     def receive_data(self, data: bytes):
         pkt = DataPacket.from_bytes(data)
-        self.logger.info(f"Received DATA from {pkt.node_id} ({len(pkt.data)} bytes)")
+        self.ensure_node_id_allowed(pkt.node_id)
         
         # Ensure sender is known
         if pkt.node_id not in self.address_book:
@@ -407,7 +484,7 @@ class DSNode:
         
         if self.receive_cb is not None:
             try:
-                self.receive_cb(pkt.data)
+                self.receive_cb(pkt.node_id, pkt.data)
             except Exception as e:
                 print(e)