distributed-state-network 0.0.4__tar.gz → 0.1.0__tar.gz

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed-state-network
-Version: 0.0.4
+Version: 0.1.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

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/documentation/ds-node-config.md

@@ -12,6 +12,8 @@ from distributed_state_network import DSNodeConfig
 class DSNodeConfig:
     node_id: str
     port: int
+    https: bool
+    network_ip: str
     aes_key_file: str
     bootstrap_nodes: List[Endpoint]
 ```
@@ -20,6 +22,8 @@ class DSNodeConfig:
 - **node_id** (`str`): Unique identifier for the node
 - **port** (`int`): Port number for the node to listen on
 - **aes_key_file** (`str`): Path to the AES key file for encryption/decryption
+- **https** (`bool`): whether to use HTTPS network requests (true) or http (false)
+- **network_ip** (`str`): Must match network address of the current computer (only if https is on)
 - **bootstrap_nodes** (`List[Endpoint]`): List of initial nodes to connect to when joining the network
 
 ### Methods
@@ -39,6 +43,8 @@ config_dict = {
     "node_id": "node1",
     "port": 8000,
     "aes_key_file": "/path/to/key.aes",
+    "https": false,
+    "network_ip": "192.168.0.1",
     "bootstrap_nodes": [
         {"address": "127.0.0.1", "port": 8001}
     ]

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "distributed-state-network"
-version = "0.0.4"
+version = "0.1.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.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/dsnode.py

@@ -38,7 +38,8 @@ class DSNode:
         self.cert_manager = CertManager(config.node_id)
         self.cred_manager = CredentialManager(config.node_id)
 
-        self.cert_manager.generate_keys()
+        if self.config.https:
+            self.cert_manager.generate_keys(self.config.network_ip)
         self.cred_manager.generate_keys()
         
         self.node_states = {
@@ -94,8 +95,10 @@ class DSNode:
     def send_request(self, con: Endpoint, path: str, payload: bytes, verify, retries: int = 0) -> Tuple[requests.Response, bytes]:
         try:
             # Always send a ping first to throw an error if https validation does not work
-            requests.post(f'https://{con.to_string()}/ping', data=self.encrypt_data(payload), verify=verify, timeout=2)
-            res = requests.post(f'https://{con.to_string()}/{path}', data=self.encrypt_data(payload), verify=verify, timeout=2)
+            protocol = "https" if self.config.https else "http"
+            verify = verify if self.config.https else None
+            requests.post(f'{protocol}://{con.to_string()}/ping', data=self.encrypt_data(payload), verify=verify, timeout=2)
+            res = requests.post(f'{protocol}://{con.to_string()}/{path}', data=self.encrypt_data(payload), verify=verify, timeout=2)
         except Exception as e:
             self.logger.error(e)
             time.sleep(1)
@@ -178,7 +181,8 @@ class DSNode:
             self.logger.error(msg)
             raise Exception(505) # Version not supported
 
-        self.cert_manager.ensure_public(pkt.node_id, pkt.https_certificate)
+        if self.config.https:
+            self.cert_manager.ensure_public(pkt.node_id, pkt.https_certificate)
         self.cred_manager.ensure_public(pkt.node_id, pkt.ecdsa_public_key)
         
         if pkt.node_id not in self.address_book:
@@ -196,7 +200,7 @@ class DSNode:
             self.my_con(), 
             self.cred_manager.my_public(), 
             None,
-            self.cert_manager.my_public()
+            self.cert_manager.my_public() if self.config.https else None
         )
         pkt.sign(self.cred_manager.my_private())
         return pkt

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/handler.py

@@ -73,7 +73,7 @@ class DSNodeServer(HTTPServer):
         disconnect_callback: Optional[Callable] = None,
         update_callback: Optional[Callable] = None
     ):
-        super().__init__(("127.0.0.1", config.port), DSNodeHandler)
+        super().__init__(("0.0.0.0", config.port), DSNodeHandler)
         self.config = config
         self.node = DSNode(config, VERSION, disconnect_callback, update_callback)
         self.node.logger.info(f'Started DSNode on port {config.port}')
@@ -93,13 +93,14 @@ class DSNodeServer(HTTPServer):
     @staticmethod 
     def start(config: DSNodeConfig, disconnect_callback: Optional[Callable] = None, update_callback: Optional[Callable] = None) -> 'NodeServer':
         n = DSNodeServer(config, disconnect_callback, update_callback)
-        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        public_path = n.node.cert_manager.public_path(n.config.node_id)
-        ssl_context.load_cert_chain(
-            certfile=public_path,
-            keyfile=public_path.replace(".crt", ".key")
-        )
-        n.socket = ssl_context.wrap_socket(n.socket, server_side=True)
+        if config.https:
+            ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            public_path = n.node.cert_manager.public_path(n.config.node_id)
+            ssl_context.load_cert_chain(
+                certfile=public_path,
+                keyfile=public_path.replace(".crt", ".key")
+            )
+            n.socket = ssl_context.wrap_socket(n.socket, server_side=True)
         n.thread = threading.Thread(target=serve, args=(n, ))
         n.thread.start()
 

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/objects/config.py

@@ -7,9 +7,18 @@ from distributed_state_network.objects.endpoint import Endpoint
 class DSNodeConfig:
     node_id: str
     port: int
+    https: bool
+    network_ip: str
     aes_key_file: str
     bootstrap_nodes: List[Endpoint]
 
     @staticmethod
     def from_dict(data: Dict) -> 'DSNodeConfig':
-        return DSNodeConfig(data["node_id"], data["port"], data["aes_key_file"], [Endpoint.from_json(e) for e in data["bootstrap_nodes"]])
+        return DSNodeConfig(
+            data["node_id"], 
+            data["port"], 
+            data["https"],
+            data["network_ip"],
+            data["aes_key_file"], 
+            [Endpoint.from_json(e) for e in data["bootstrap_nodes"]]
+        )

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/objects/hello_packet.py

@@ -37,9 +37,10 @@ class HelloPacket(SignedPacket):
         bts.write_string(self.node_id)
         bts.write_bytes(self.connection.to_bytes())
         bts.write_bytes(self.ecdsa_public_key)
-        bts.write_bytes(self.https_certificate)
         if include_signature:
             bts.write_bytes(self.ecdsa_signature)
+        if self.https_certificate is not None:
+            bts.write_bytes(self.https_certificate)
         
         return bts.get_bytes()
 
@@ -50,10 +51,10 @@ class HelloPacket(SignedPacket):
         node_id = bts.read_string()
         connection = Endpoint.from_bytes(bts.read_bytes())
         ecdsa_public_key = bts.read_bytes()
-        https_certificate = bts.read_bytes()
         ecdsa_signature = bts.read_bytes()
+        https_certificate = bts.read_bytes() or None
 
-        if version == '' or node_id == '' or ecdsa_public_key == b'' or https_certificate == b'':
+        if version == '' or node_id == '' or ecdsa_public_key == b'':
             raise Exception(406) # Not acceptable
 
         return HelloPacket(version, node_id, connection, ecdsa_public_key, ecdsa_signature, https_certificate)

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/util/ecdsa.py

@@ -2,7 +2,7 @@ import hashlib
 
 from ecdsa import SigningKey, VerifyingKey, SECP256k1
 
-def generate_key_pair():
+def generate_key_pair(_):
     private_key = SigningKey.generate(curve=SECP256k1)
     public_key = private_key.get_verifying_key()
     return public_key.to_string(), private_key.to_string()

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/util/https.py

@@ -9,7 +9,7 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption
 
-def generate_cert():
+def generate_cert(network_ip: str):
     # Generate private key
     private_key = rsa.generate_private_key(
         public_exponent=65537,
@@ -19,11 +19,8 @@ def generate_cert():
 
     # Generate a self-signed certificate
     subject = issuer = x509.Name([
-        x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
-        x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "California"),
-        x509.NameAttribute(NameOID.LOCALITY_NAME, "San Francisco"),
-        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "My Organization"),
-        x509.NameAttribute(NameOID.COMMON_NAME, "localhost"),
+        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "DSN"),
+        x509.NameAttribute(NameOID.COMMON_NAME, "DSN"),
     ])
 
     certificate = (
@@ -36,8 +33,8 @@ def generate_cert():
         .not_valid_after(datetime.utcnow() + timedelta(days=365))
         .add_extension(
             x509.SubjectAlternativeName([
-                x509.DNSName("localhost"),
-                IPAddress(ipaddress.IPv4Address("127.0.0.1"))
+                x509.DNSName(network_ip),
+                IPAddress(ipaddress.IPv4Address(network_ip))
             ]),
             critical=False
         )

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/src/distributed_state_network/util/key_manager.py

@@ -63,11 +63,11 @@ class KeyManager:
         with open(f'{self.folder}/{self.node_id}/{self.node_id}.{self.private_extension}', 'rb') as f:
             return f.read()
 
-    def generate_keys(self):
+    def generate_keys(self, network_ip: str = None):
         if os.path.exists(f'{self.folder}/{self.node_id}/{self.node_id}.{self.private_extension}'):
             return
         logging.getLogger("DSN: " + self.node_id).info(f"Generating {self.key_type} Keys ...")
-        cert_bytes, key_bytes = self.gen_keys()
+        cert_bytes, key_bytes = self.gen_keys(network_ip)
         if not os.path.exists(self.folder):
             os.mkdir(self.folder)
         if not os.path.exists(f'{self.folder}/{self.node_id}'):

{distributed_state_network-0.0.4 → distributed_state_network-0.1.0}/tests/connections.py

@@ -17,12 +17,14 @@ cb_test = 0
 
 current_port = 5000
 
-def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional[Callable] = None, update_cb: Optional[Callable] = None):
+def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional[Callable] = None, update_cb: Optional[Callable] = None, https: bool = False):
     global current_port
     args = {
         "node_id": node_id,
         "port": current_port,
-        "aes_key_file": KEY_FILE
+        "aes_key_file": KEY_FILE,
+        "https": https,
+        "network_ip": "127.0.0.1"
     }
     current_port += 1
     if bootstrap_port is not None:
@@ -46,6 +48,12 @@ class ConnectionsTest(unittest.TestCase):
         self.assertEqual(["node-1", "node-2"], sorted(node1.node.peers()))
         self.assertEqual(["node-1", "node-2"], sorted(node2.node.peers()))
 
+    def test_https(self):
+        node1 = start_node("node-1", https=True)
+        node2 = start_node("node-2", node1.config.port, https=True)
+        self.assertEqual(["node-1", "node-2"], sorted(node1.node.peers()))
+        self.assertEqual(["node-1", "node-2"], sorted(node2.node.peers()))
+
     def test_many(self):
         bootstrap_node = start_node("bootstrap")
         nodes = []