naeural-client 2.3.5__tar.gz → 2.4.0__tar.gz

{naeural_client-2.3.5 → naeural_client-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: naeural_client
-Version: 2.3.5
+Version: 2.4.0
 Summary: `naeural_client` is the Python SDK required for client app development for the Naeural Edge Protocol Edge Protocol framework
 Project-URL: Homepage, https://github.com/NaeuralEdgeProtocol/naeural_client
 Project-URL: Bug Tracker, https://github.com/NaeuralEdgeProtocol/naeural_client/issues

{naeural_client-2.3.5 → naeural_client-2.4.0}/naeural_client/_ver.py

@@ -1,4 +1,4 @@
-__VER__ = "2.3.5"
+__VER__ = "2.4.0"
 
 if __name__ == "__main__":
   with open("pyproject.toml", "rt") as fd:

{naeural_client-2.3.5 → naeural_client-2.4.0}/naeural_client/bc/base.py

@@ -344,7 +344,10 @@ class BaseBlockEngine:
       boxed=boxed, 
       **kwargs
     )
-     
+  
+  @property
+  def name(self):
+    return self.__name
 
   def _init(self):
     self.P("Initializing Blockchain engine manager...", boxed=True, box_char='*', verbosity=1)

{naeural_client-2.3.5 → naeural_client-2.4.0}/naeural_client/bc/ec.py

@@ -3,6 +3,7 @@ import hashlib
 import os
 import binascii
 import zlib
+import json
 
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -273,16 +274,16 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
     if debug:
       print('derived-shared_key: ', base64.b64encode(derived_key))
     return derived_key
-  
 
-  def encrypt(
+
+  def _encrypt(
     self, 
     plaintext: str, 
     receiver_address: str, 
-    compressed: bool = True,
-    embed_compressed: bool = True,
+    compressed: bool = True, # compressed is always True
+    embed_compressed: bool = True, # embed_compressed is always True
     info: str = BCct.DEFAULT_INFO, 
-    debug: bool = False
+    debug: bool = False,
   ):
     """
     Encrypts plaintext using the sender's private key and receiver's public key, 
@@ -307,6 +308,7 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
     str
         The base64 encoded nonce and ciphertext.
     """
+    
     if compressed:
       to_encrypt_data = zlib.compress(plaintext.encode())
       compressed_flag = (1).to_bytes(1, byteorder='big')
@@ -325,8 +327,51 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
       encrypted_data = nonce + ciphertext  # Prepend the nonce to the ciphertext
     #end if      
     return base64.b64encode(encrypted_data).decode()  # Encode to base64
+  
+  
+  def encrypt(
+    self, 
+    plaintext: str, 
+    receiver_address: str, 
+    info: str = BCct.DEFAULT_INFO, 
+    debug: bool = False,
+    **kwargs
+  ):
+    """
+    Encrypts plaintext using the sender's private key and receiver's public key, 
+    then base64 encodes the output.
+
+    Parameters
+    ----------
+    receiver_address : str
+        The receiver's address
+        
+    plaintext : str
+        The plaintext to encrypt.
+        
+    Obsolete:          
+      compressed : bool, optional
+          Whether to compress the plaintext before encryption. The default is True.
+          
+      embed_compressed : bool, optional
+          Whether to embed the compressed flag in the encrypted data. The default is True.
 
-  def decrypt(
+    Returns
+    -------
+    str
+        The base64 encoded nonce and ciphertext.
+    """  
+    return self._encrypt(
+      plaintext=plaintext, 
+      receiver_address=receiver_address, 
+      compressed=True, 
+      embed_compressed=True, 
+      info=info, 
+      debug=debug,      
+    )
+    
+  
+  def _decrypt(
     self, 
     encrypted_data_b64 : str, 
     sender_address : str, 
@@ -395,6 +440,220 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
       result = None
     return result
   
+
+  ## Multi destination encryption
+  def encrypt_for_multi(
+    self, 
+    plaintext: str, 
+    receiver_addresses: list, 
+    info: str = BCct.DEFAULT_INFO, 
+    debug: bool = False
+  ):
+    """
+    Encrypts plaintext for multiple receivers.
+    
+    The overall approach is to encrypt the plaintext with a symmetric key, 
+    then encrypt the symmetric key with the public key of each receiver.
+
+    Parameters
+    ----------
+    plaintext : str
+        The plaintext to encrypt.
+        
+    receiver_addresses : list
+        List of receiver addresses.
+
+    Returns
+    -------
+    str
+        The base64 encoded encrypted package.
+    """
+    to_encrypt_data = zlib.compress(plaintext.encode())
+    compressed_flag = (1).to_bytes(1, byteorder='big')
+    
+    # Generate a random symmetric key
+    symmetric_key = os.urandom(32)  # 256-bit key
+    
+    # Encrypt the plaintext with the symmetric key
+    nonce = os.urandom(12)
+    aesgcm = AESGCM(symmetric_key)
+    ciphertext = aesgcm.encrypt(nonce, to_encrypt_data, None)
+    
+    # For each receiver, encrypt the symmetric key
+    encrypted_keys = []
+    for receiver_address in receiver_addresses:
+      receiver_pk = self._address_to_pk(receiver_address)
+      shared_key = self.__derive_shared_key(receiver_pk, info=info, debug=debug)
+      # Use shared_key to encrypt the symmetric key
+      aesgcm_shared = AESGCM(shared_key)
+      nonce_shared = os.urandom(12)
+      encrypted_symmetric_key = aesgcm_shared.encrypt(nonce_shared, symmetric_key, None)
+      full_enc_key = nonce_shared + encrypted_symmetric_key
+      encrypted_keys.append({
+        'a': receiver_address,  # Address of the receiver
+        'k': full_enc_key.hex() # Encrypted symmetric key
+      })
+    
+    # Package the encrypted symmetric keys and the ciphertext
+    encrypted_package = {
+      'M': True,                  # Multi-recipient flag
+      'c': compressed_flag.hex(), # Compressed flag
+      'n': nonce.hex(),           # Nonce
+      'd': ciphertext.hex(),      # Ciphertext
+      'k': encrypted_keys         # Encrypted symmetric keys
+    }
+    
+    # Convert to JSON, compress, and base64 encode
+    enc_data = json.dumps(encrypted_package)
+    enc_data_compressed = zlib.compress(enc_data.encode())
+    enc_data_compressed_b64 = base64.b64encode(enc_data_compressed).decode()
+    return enc_data_compressed_b64
+
+
+  def decrypt_for_multi(
+      self,
+      encrypted_data_b64: str,
+      sender_address: str,
+      info: str = BCct.DEFAULT_INFO,
+      debug: bool = False
+  ):
+    """
+    Decrypts data encrypted for multiple receivers.
+
+    Parameters
+    ----------
+    encrypted_data_b64 : str
+      The base64 encoded encrypted package as produced by encrypt_for_multi.
+    
+    sender_address : str
+      The sender's address (public key address) used to derive the shared key.
+    
+    info : str, optional
+      Additional info used in the HKDF for shared key derivation.
+    
+    debug : bool, optional
+      If True, prints debug information.
+
+    Returns
+    -------
+    str or None
+      The decrypted plaintext as a string, or None if decryption fails.
+    """
+    try:
+      # 1. Base64 decode
+      enc_data_compressed = base64.b64decode(encrypted_data_b64)
+
+      # 2. Decompress the JSON structure
+      enc_data_json = zlib.decompress(enc_data_compressed).decode()
+
+      # 3. Parse JSON
+      encrypted_package = json.loads(enc_data_json)
+
+      # Expecting keys: 'M', 'c', 'n', 'd', 'k'
+      # 'M' = True indicates multi-recipient
+      if 'M' not in encrypted_package or encrypted_package['M'] != True:
+        if debug:
+          self.P("Not a multi-recipient package.", color='y')
+        return None
+
+      # 'c' = compressed flag (hex)
+      compressed_flag_hex = encrypted_package['c']
+      compressed_flag = int(compressed_flag_hex, 16)
+
+      # 'n' = nonce (hex)
+      nonce = bytes.fromhex(encrypted_package['n'])
+
+      # 'd' = ciphertext (hex)
+      ciphertext = bytes.fromhex(encrypted_package['d'])
+
+      # 'k' = list of encrypted symmetric keys
+      encrypted_keys = encrypted_package['k']
+
+      # 4. Identify this receiver's encrypted symmetric key
+      my_address = self.address
+      my_encrypted_key_hex = None
+      for ek in encrypted_keys:
+        if ek['a'] == my_address:
+          my_encrypted_key_hex = ek['k']
+          break
+
+      if my_encrypted_key_hex is None:
+        if debug:
+          self.P("No encrypted symmetric key for this receiver.", color='r')
+        return None
+
+      # Decode the encrypted symmetric key
+      my_encrypted_key = bytes.fromhex(my_encrypted_key_hex)
+
+      # The first 12 bytes are nonce_shared, rest is encrypted symmetric key
+      nonce_shared = my_encrypted_key[:12]
+      encrypted_symmetric_key = my_encrypted_key[12:]
+
+      # 5. Derive shared key using sender's public key
+      sender_pk = self._address_to_pk(sender_address)
+      shared_key = self.__derive_shared_key(sender_pk, info=info, debug=debug)
+
+      # 6. Decrypt the symmetric key
+      aesgcm_shared = AESGCM(shared_key)
+      symmetric_key = aesgcm_shared.decrypt(nonce_shared, encrypted_symmetric_key, None)
+
+      # 7. Decrypt the ciphertext using the symmetric key
+      aesgcm = AESGCM(symmetric_key)
+      plaintext = aesgcm.decrypt(nonce, ciphertext, None)
+
+      # 8. Decompress the plaintext if compressed_flag == 1
+      if compressed_flag == 1:
+        plaintext = zlib.decompress(plaintext)
+
+      return plaintext.decode()
+
+    except Exception as exc:
+      if debug:
+        self.P(f"Error decrypting multi scenario: {exc}", color='r')
+      return None
+  
+  def decrypt(  
+    self,
+    encrypted_data_b64: str,
+    sender_address: str,
+    info: str = BCct.DEFAULT_INFO,
+    debug: bool = False,
+    is_multi: bool = True
+  ):
+    """
+    Decrypts data encrypted for a single or multi  receiver.
+
+    Parameters
+    ----------
+    encrypted_data_b64 : str
+      The base64 encoded encrypted data.
+    
+    sender_address : str
+      The sender's address (public key address) used to derive the shared key.
+    
+    info : str, optional
+      Additional info used in the HKDF for shared key derivation.
+    
+    debug : bool, optional
+      If True, prints debug information.
+    
+    is_multi : bool, optional
+      If True, decrypts as multi-recipient package.
+
+    Returns
+    -------
+    str or None
+      The decrypted plaintext as a string, or None if decryption fails.
+    """
+    result = None
+    if is_multi:
+      result = self.decrypt_for_multi(encrypted_data_b64, sender_address, info=info, debug=debug)
+    if result is None:
+      result = self._decrypt(encrypted_data_b64, sender_address, decompress=True, embed_compressed=True, info=info, debug=debug)  
+    return result
+  
+  
+  ## end multi destination encryption
   
   
   ### ETH

{naeural_client-2.3.5 → naeural_client-2.4.0}/naeural_client/const/__init__.py

@@ -3,7 +3,7 @@ from . import comms as COMMS
 from . import base as BASE_CT
 from . import payload as PAYLOAD_CT
 from .formatter import FORMATTER_DATA
-from .payload import STATUS_TYPE, PAYLOAD_DATA, COMMANDS, NOTIFICATION_CODES
+from .payload import STATUS_TYPE, PAYLOAD_DATA, COMMANDS, NOTIFICATION_CODES, NET_CONFIG
 from .base import CONFIG_STREAM, BIZ_PLUGIN_DATA, PLUGIN_INFO, BLOCKCHAIN_CONFIG
 from . import heartbeat as HB
 from .environment import ENVIRONMENT

{naeural_client-2.3.5 → naeural_client-2.4.0}/naeural_client/const/payload.py

@@ -195,3 +195,9 @@ class PAYLOAD_DATA:
   ID_TAGS = 'ID_TAGS'
   
   
+class NET_CONFIG:
+  STORE_COMMAND = "SET_CONFIG"
+  REQUEST_COMMAND = "GET_CONFIG"
+  NET_CONFIG_DATA = 'NET_CONFIG_DATA'
+  OPERATION = 'OP'
+  DESTINATION = 'DEST'

{naeural_client-2.3.5 → naeural_client-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "naeural_client"
-version = "2.3.5"
+version = "2.4.0"
 authors = [
   { name="Andrei Ionut Damian", email="andrei.damian@me.com" },
   { name="Cristan Bleotiu", email="cristibleotiu@gmail.com" },

naeural_client-2.4.0/xperimental/enc_dec/enc_dec_test.py

@@ -0,0 +1,52 @@
+import json
+
+from naeural_client import Logger, const
+from naeural_client.bc import DefaultBlockEngine
+
+
+
+if __name__ == '__main__' :
+  l = Logger("ENC", base_folder=".", app_folder="_local_cache")
+  eng1 = DefaultBlockEngine(
+    log=l, name="test1", 
+    config={
+        "PEM_FILE"     : "test1.pem",
+        "PASSWORD"     : None,      
+        "PEM_LOCATION" : "data"
+      }
+  )
+  eng2 = DefaultBlockEngine(
+    log=l, name="test2", 
+    config={
+        "PEM_FILE"     : "test2.pem",
+        "PASSWORD"     : None,      
+        "PEM_LOCATION" : "data"
+      }
+  )
+  
+  data = {
+    "test1" : " ".join([f"data1-{x}" for x in range(1, 1000)]),
+    "test2" : [f"data2-{x}" for x in range(1, 1000)],
+  }   
+  
+  l.P("Non compressed test", color='g')  
+  str_data = json.dumps(data)
+  l.P(f"Data size: {len(str_data)}")  
+  encdata = eng1._encrypt(plaintext=str_data, receiver_address=eng2.address, compressed=False, embed_compressed=False)
+  l.P(f"Encrypted data (size: {len(encdata)})")  
+  decdata = eng2._decrypt(encrypted_data_b64=encdata, sender_address=eng1.address, decompress=False, embed_compressed=False) 
+  if decdata == str_data:
+    l.P("Decrypted data matches original data", color='g')
+  else:
+    l.P("Decrypted data does not match original data", color='r')
+  
+  l.P("Compressed test", color='g')  
+  str_data = json.dumps(data)
+  l.P(f"Data size: {len(str_data)}")  
+  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address)
+  l.P(f"Encrypted data (size: {len(encdata)})")  
+  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address)
+  if decdata == str_data:
+    l.P("Decrypted data matches original data", color='g')
+  else:
+    l.P("Decrypted data does not match original data", color='r')

naeural_client-2.4.0/xperimental/multi-enc-dec/multi_test1.py

@@ -0,0 +1,91 @@
+import json
+
+from naeural_client import Logger, const
+from naeural_client.bc import DefaultBlockEngine
+
+
+
+if __name__ == '__main__' :
+  l = Logger("ENC", base_folder=".", app_folder="_local_cache")
+  eng1 = DefaultBlockEngine(
+    log=l, name="test1", 
+    config={
+        "PEM_FILE"     : "test1.pem",
+        "PASSWORD"     : None,      
+        "PEM_LOCATION" : "data"
+      }
+  )
+  
+  receivers = [
+    DefaultBlockEngine(
+      log=l, name=f"test{x}", 
+      config={
+          "PEM_FILE"     : f"test{x}.pem",
+          "PASSWORD"     : None,      
+          "PEM_LOCATION" : "data"
+        }
+    ) for x in range(2, 7)
+  ]
+  
+  
+  bandit = DefaultBlockEngine( # bandit
+    log=l, name="bandit", 
+    config={
+        "PEM_FILE"     : "bandit.pem",
+        "PASSWORD"     : None,      
+        "PEM_LOCATION" : "data"
+      }
+  )
+  
+  data = {
+    "test1" : " ".join([f"data1-{x}" for x in range(1, 1000)]),
+    "test2" : [f"data2-{x}" for x in range(1, 1000)],
+  }   
+   
+  str_data = json.dumps(data)
+  l.P("Data size: {}".format(len(str_data)), color='b')
+  enc_data1s = eng1.encrypt(
+    plaintext=str_data, 
+    receiver_address=receivers[0].address, debug=True
+  )
+  enc_data1m = eng1.encrypt_for_multi(
+    plaintext=str_data,
+    receiver_addresses=[x.address for x in receivers]
+  )
+  l.P("Encrypted data size: {}".format(len(enc_data1m)), color='b')
+  receivers.append(bandit) # bandit inserts itself into the list of receivers
+  single = receivers[0]
+  bandit = receivers[-1]
+  
+  decdata = single.decrypt(
+    encrypted_data_b64=enc_data1s, 
+    sender_address=eng1.address,
+    debug=False,
+  )
+  if decdata == str_data:
+    l.P(f"Data (single) successfully decrypted by {single.name}", color='g')
+  else:
+    l.P(f"Data (single) decryption failed by {single.name}", color='r')
+
+  decdata = bandit.decrypt(
+    encrypted_data_b64=enc_data1s, 
+    sender_address=eng1.address,
+    debug=False,
+  )
+  if decdata == str_data:
+    l.P(f"Data (single) successfully decrypted by {bandit.name}", color='g')
+  else:
+    l.P(f"Data (single) decryption failed by {bandit.name}", color='r')
+  
+  
+  for receiver in receivers:
+    decdata = receiver.decrypt(
+      encrypted_data_b64=enc_data1m, 
+      sender_address=eng1.address,
+      debug=False,
+    )
+    if decdata == str_data:
+      l.P("Data (multi) successfully decrypted by {}".format(receiver.name), color='g')
+    else:
+      l.P("Data (multi) decryption failed by {}".format(receiver.name), color='r')
+      

naeural_client-2.3.5/xperimental/enc_dec/enc_dec_test.py

@@ -1,74 +0,0 @@
-import json
-
-from naeural_client import Logger, const
-from naeural_client.bc import DefaultBlockEngine
-
-
-
-if __name__ == '__main__' :
-  l = Logger("ENC", base_folder=".", app_folder="_local_cache")
-  eng1 = DefaultBlockEngine(
-    log=l, name="test1", 
-    config={
-        "PEM_FILE"     : "test1.pem",
-        "PASSWORD"     : None,      
-        "PEM_LOCATION" : "data"
-      }
-  )
-  eng2 = DefaultBlockEngine(
-    log=l, name="test2", 
-    config={
-        "PEM_FILE"     : "test2.pem",
-        "PASSWORD"     : None,      
-        "PEM_LOCATION" : "data"
-      }
-  )
-  
-  data = {
-    "test": "data1 data2 data3 data4 data5 data6 data7 data8 data9 data10",
-    "test2": "data21 data22 data23 data24 data25 data26 data27 data28 data29 data210",
-    "test3": "data31 data32 data33 data34 data35 data36 data37 data38 data39 data310",
-    "test4" : {
-      "test5": "data5 data6 data7 data8 data9 data10 data11 data12 data13 data14",
-      "test6": "data6 data7 data8 data9 data10 data11 data12 data13 data14 data15",
-      "test7": [
-        "data7",
-        {
-          "test9": "data91 data92 data93 data94 data95 data96 data97 data98 data99 data910",
-          "test10": "data10 data11 data12 data13 data14 data15 data16 data17 data18 data19 data110",
-        }
-      ]
-    }
-  }
-  
-  l.P("Non compressed test", color='g')  
-  str_data = json.dumps(data)
-  l.P(f"Data size: {len(str_data)}")  
-  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address, compressed=False, embed_compressed=False)
-  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
-  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address, decompress=False, embed_compressed=False) 
-  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")
-  
-  l.P("Compressed test", color='g')  
-  str_data = json.dumps(data)
-  l.P(f"Data size: {len(str_data)}")  
-  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address, compressed=True, embed_compressed=False)
-  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
-  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address, decompress=True, embed_compressed=False)
-  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")  
-  
-  l.P("Compressed test with embed", color='g')  
-  str_data = json.dumps(data)
-  l.P(f"Data size: {len(str_data)}")  
-  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address, compressed=True, embed_compressed=True)
-  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
-  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address, embed_compressed=True) # decompress does not matter
-  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")    
-  
-  l.P("Default test", color='g')  
-  str_data = json.dumps(data)
-  l.P(f"Data size: {len(str_data)}")  
-  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address)
-  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
-  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address)
-  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")