Update modules/secure_memory.py

modules/secure_memory.py

@@ -1,41 +1,33 @@
-from pathlib import Path
-
-# Encrypted memory session handler template
-memory_isolation_code = """
-# secure_memory.py
-from cryptography.fernet import Fernet
-import numpy as np
 import base64
+import json
+from cryptography.fernet import Fernet
+
 class SecureMemorySession:
-    def __init__(self, encryption_key: bytes = None):
-        self.key = encryption_key or Fernet.generate_key()
+    """Handles encryption/decryption for user vectors"""
+    
+    def __init__(self, key: bytes):
+        self.key = base64.urlsafe_b64encode(key[:32].ljust(32, b'0'))  # Fernet key must be 32 bytes
         self.fernet = Fernet(self.key)
-        self.sessions = {}
-    def encrypt_vector(self, user_id: int, vector: np.ndarray) -> str:
-        vector_bytes = vector.tobytes()
-        encrypted = self.fernet.encrypt(vector_bytes)
-        encoded = base64.b64encode(encrypted).decode('utf-8')
-        if user_id not in self.sessions:
-            self.sessions[user_id] = []
-        self.sessions[user_id].append(encoded)
-        return encoded
-    def decrypt_vectors(self, user_id: int) -> list:
-        if user_id not in self.sessions:
-            return []
-        decrypted_vectors = []
-        for encoded in self.sessions[user_id]:
-            encrypted = base64.b64decode(encoded)
-            decrypted = self.fernet.decrypt(encrypted)
-            vector = np.frombuffer(decrypted, dtype=np.int64)  # adjust dtype if needed
-            decrypted_vectors.append(vector)
-        return decrypted_vectors
-    def get_encryption_key(self) -> bytes:
-        return self.key
-"""
+        self.memory_store = {}
 
-# Save it as a Python file
-memory_path = Path("/mnt/data/secure_memory.py")
-memory_path.parent.mkdir(parents=True, exist_ok=True)
-memory_path.write_text(memory_isolation_code)
+    def encrypt_vector(self, user_id, vector):
+        """Encrypts and stores vector under user ID"""
+        if user_id not in self.memory_store:
+            self.memory_store[user_id] = []
+        serialized = json.dumps(vector.tolist()).encode()
+        encrypted = self.fernet.encrypt(serialized)
+        self.memory_store[user_id].append(encrypted)
 
-memory_path
+    def decrypt_vectors(self, user_id):
+        """Decrypts and returns all stored vectors for a user"""
+        if user_id not in self.memory_store:
+            return []
+        decrypted = []
+        for enc in self.memory_store[user_id]:
+            try:
+                raw = self.fernet.decrypt(enc)
+                array = json.loads(raw.decode())
+                decrypted.append(array)
+            except Exception:
+                continue
+        return decrypted