astreum 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

astreum/node/crypto/ed25519.py

@@ -0,0 +1,50 @@
+# EdDSA signature algorithm over Curve25519
+
+# ed25519.py
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+from cryptography.exceptions import InvalidSignature
+from typing import Tuple
+
+def generate_key_pair() -> Tuple[Ed25519PrivateKey, Ed25519PublicKey]:
+    """
+    Generate an Ed25519 private and public key pair.
+    
+    Returns:
+        Tuple[Ed25519PrivateKey, Ed25519PublicKey]: The generated key pair.
+    """
+    private_key: Ed25519PrivateKey = ed25519.Ed25519PrivateKey.generate()
+    public_key: Ed25519PublicKey = private_key.public_key()
+    return private_key, public_key
+
+def sign_message(private_key: Ed25519PrivateKey, message: bytes) -> bytes:
+    """
+    Sign a message using the provided Ed25519 private key.
+    
+    Args:
+        private_key (Ed25519PrivateKey): The private key used for signing.
+        message (bytes): The message to sign.
+    
+    Returns:
+        bytes: The signature.
+    """
+    signature: bytes = private_key.sign(message)
+    return signature
+
+def verify_signature(public_key: Ed25519PublicKey, message: bytes, signature: bytes) -> bool:
+    """
+    Verify a message signature using the provided Ed25519 public key.
+    
+    Args:
+        public_key (Ed25519PublicKey): The public key corresponding to the private key that signed.
+        message (bytes): The original message.
+        signature (bytes): The signature to verify.
+        
+    Returns:
+        bool: True if the signature is valid, False otherwise.
+    """
+    try:
+        public_key.verify(signature, message)
+        return True
+    except InvalidSignature:
+        return False

astreum/node/crypto/x25519.py

@@ -0,0 +1,31 @@
+# Diffie-Hellman key exchange over Curve25519
+
+# x25519.py
+from cryptography.hazmat.primitives.asymmetric import x25519
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from typing import Tuple
+
+def generate_key_pair() -> Tuple[X25519PrivateKey, X25519PublicKey]:
+    """
+    Generate an X25519 private and public key pair.
+    
+    Returns:
+        Tuple[X25519PrivateKey, X25519PublicKey]: The generated key pair.
+    """
+    private_key: X25519PrivateKey = x25519.X25519PrivateKey.generate()
+    public_key: X25519PublicKey = private_key.public_key()
+    return private_key, public_key
+
+def generate_shared_key(private_key: X25519PrivateKey, peer_public_key: X25519PublicKey) -> bytes:
+    """
+    Generate a shared key using the provided private key and peer's public key.
+    
+    Args:
+        private_key (X25519PrivateKey): Our private key.
+        peer_public_key (X25519PublicKey): The peer's public key.
+        
+    Returns:
+        bytes: The shared key.
+    """
+    shared_key: bytes = private_key.exchange(peer_public_key)
+    return shared_key

astreum/node/relay/envelope.py

@@ -31,11 +31,11 @@ determined by the difficulty parameter. The nonce is adjusted until this require
 import struct
 import time
 import os
-import hashlib
 from dataclasses import dataclass
 from typing import Optional, Tuple, List
 from .message import Message, Topic
 from astreum.utils.bytes_format import encode, decode
+from ..utils import hash_data
 
 @dataclass
 class Envelope:
@@ -153,13 +153,13 @@ class Envelope:
             bytes: The Merkle root hash
         """
         if not leaves:
-            return hashlib.sha256(b'').digest()
+            return hash_data(b'')
         
         if len(leaves) == 1:
-            return hashlib.sha256(leaves[0]).digest()
+            return hash_data(leaves[0])
             
         # Hash all leaf nodes
-        hashed_leaves = [hashlib.sha256(leaf).digest() for leaf in leaves]
+        hashed_leaves = [hash_data(leaf) for leaf in leaves]
         
         # Build the Merkle tree
         while len(hashed_leaves) > 1:
@@ -171,7 +171,7 @@ class Envelope:
             next_level = []
             for i in range(0, len(hashed_leaves), 2):
                 combined = hashed_leaves[i] + hashed_leaves[i+1]
-                next_level.append(hashlib.sha256(combined).digest())
+                next_level.append(hash_data(combined))
                 
             hashed_leaves = next_level
             

astreum/node/storage/__init__.py

@@ -0,0 +1,13 @@
+"""
+Storage utilities for the Astreum node.
+"""
+
+from .merkle import MerkleTree, MerkleProof, MerkleNode
+from .merkle import find_first, find_all, map, binary_search
+from .storage import Storage
+
+__all__ = [
+    "MerkleTree", "MerkleProof", "MerkleNode", 
+    "find_first", "find_all", "map", "binary_search",
+    "Storage"
+]