superlocalmemory 3.8.3 → 3.8.6

package/src/superlocalmemory/server/write_identity.py

@@ -18,6 +18,8 @@ from typing import Any
 
 from fastapi import HTTPException, Request
 
+from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
+
 
 # H-04 (3.7.9): the test-client auth bypass must be impossible in a real daemon
 # even if SLM_TEST_ISOLATION=1 leaks into a production environment. Anchor it to
@@ -89,7 +91,7 @@ def require_write_actor(
         # missing peer address (e.g. behind a proxy that strips it) must not be
         # trusted just because an install token is presented. require_http_mutation_actor
         # already excludes "" from its loopback set; keep the two paths consistent.
-        if is_test_client or client_host in ("127.0.0.1", "::1", "localhost"):
+        if is_test_client or _is_loopback_host(client_host):
             from superlocalmemory.core.engine_ingestion import local_trusted_actor_id
 
             return local_trusted_actor_id(actor_kind)
@@ -103,7 +105,15 @@ def require_write_actor(
         ).hexdigest()
         return f"api-key:{actor_kind}:{fingerprint}"
 
-    raise HTTPException(403, detail="Authenticated write capability required")
+    raise HTTPException(
+        403,
+        detail=(
+            "Write rejected: this origin requires an API key (X-SLM-API-Key). "
+            "The install token (X-Install-Token) is accepted only from loopback "
+            "(127.x.x.x / ::1 / localhost). If calling from a container or "
+            "remote host, configure SLM_API_KEY and present it as X-SLM-API-Key."
+        ),
+    )
 
 
 def require_http_mutation_actor(
@@ -134,7 +144,7 @@ def require_http_mutation_actor(
 
     client_host = request.client.host if request.client else ""
     is_test_client = client_host == "testclient" and _TEST_ISOLATION_ALLOWED
-    loopback = client_host in ("127.0.0.1", "::1", "localhost")
+    loopback = _is_loopback_host(client_host)
     # H-01: the loopback trusted-actor bypass is suppressed when the operator
     # opts into SLM_REQUIRE_CREDENTIALS; in-process tests keep the bypass.
     if is_test_client or (loopback and not _REQUIRE_CREDENTIALS):
@@ -153,7 +163,15 @@ def require_http_mutation_actor(
             ).hexdigest()
             return f"mesh-secret:{fingerprint}"
 
-    raise HTTPException(403, detail="Authenticated mutation capability required")
+    raise HTTPException(
+        403,
+        detail=(
+            "Mutation rejected: present one of X-SLM-Daemon-Capability, "
+            "X-Install-Token (loopback only), or X-SLM-API-Key. "
+            "Uncredentialed writes are accepted only from loopback. "
+            "See SLM_API_KEY in the deployment guide for network access."
+        ),
+    )
 
 
 def authenticated_request_actor(

package/src/superlocalmemory/storage/admission_codec.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""Production encryption codec for durable remember admission commands."""
+
+from __future__ import annotations
+
+import os
+import stat
+import time
+from pathlib import Path
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from superlocalmemory.infra.data_root import state_path
+
+_KEY_BYTES = 32
+_NONCE_BYTES = 12
+_FORMAT_VERSION = b"\x01"
+_ASSOCIATED_DATA = b"superlocalmemory:remember-admission:v1"
+_KEY_READ_ATTEMPTS = 100
+_KEY_READ_RETRY_SECONDS = 0.005
+
+
+class AdmissionKeyError(RuntimeError):
+    """The machine-local admission key cannot be created or loaded safely."""
+
+
+class MachineKeyCommandCodec:
+    """AES-256-GCM codec backed by a machine-local, permission-bound key.
+
+    The key is intentionally separate from cache encryption keys.  Exclusive
+    creation makes concurrent daemon startup converge on one key, while the
+    format byte and AEAD associated data prevent cross-protocol ciphertext use.
+    """
+
+    def __init__(self, key_path: str | Path | None = None) -> None:
+        self.key_path = Path(key_path) if key_path is not None else state_path(
+            "admission-key.bin"
+        )
+        self._key = _load_or_create_key(self.key_path)
+
+    def encrypt(self, plaintext: bytes) -> bytes:
+        if not isinstance(plaintext, bytes):
+            raise TypeError("plaintext must be bytes")
+        nonce = os.urandom(_NONCE_BYTES)
+        ciphertext = AESGCM(self._key).encrypt(nonce, plaintext, _ASSOCIATED_DATA)
+        return _FORMAT_VERSION + nonce + ciphertext
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        if not isinstance(ciphertext, bytes):
+            raise TypeError("ciphertext must be bytes")
+        minimum = len(_FORMAT_VERSION) + _NONCE_BYTES + 16
+        if len(ciphertext) < minimum or ciphertext[:1] != _FORMAT_VERSION:
+            raise ValueError("unsupported admission ciphertext format")
+        nonce = ciphertext[1 : 1 + _NONCE_BYTES]
+        payload = ciphertext[1 + _NONCE_BYTES :]
+        return AESGCM(self._key).decrypt(nonce, payload, _ASSOCIATED_DATA)
+
+
+def _load_or_create_key(path: Path) -> bytes:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if os.name != "nt":
+        os.chmod(path.parent, 0o700)
+
+    try:
+        fd = os.open(
+            path,
+            os.O_WRONLY
+            | os.O_CREAT
+            | os.O_EXCL
+            | getattr(os, "O_BINARY", 0),
+            0o600,
+        )
+    except FileExistsError:
+        fd = -1
+    else:
+        try:
+            key = os.urandom(_KEY_BYTES)
+            view = memoryview(key)
+            written = 0
+            while written < _KEY_BYTES:
+                count = os.write(fd, view[written:])
+                if count <= 0:
+                    raise AdmissionKeyError("admission key write was incomplete")
+                written += count
+            os.fsync(fd)
+        except BaseException:
+            try:
+                path.unlink()
+            except OSError:
+                pass
+            raise
+        finally:
+            os.close(fd)
+
+    for attempt in range(_KEY_READ_ATTEMPTS):
+        try:
+            info = path.lstat()
+        except OSError as exc:
+            raise AdmissionKeyError("admission key is unavailable") from exc
+        if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+            raise AdmissionKeyError("admission key path must be a regular file")
+        if os.name != "nt":
+            if info.st_uid != os.getuid():
+                raise AdmissionKeyError("admission key is not owned by the current user")
+            os.chmod(path, 0o600)
+        try:
+            key = path.read_bytes()
+        except OSError as exc:
+            raise AdmissionKeyError("admission key cannot be read") from exc
+        if len(key) == _KEY_BYTES:
+            return key
+        # A process that lost O_EXCL may observe the winning creator between
+        # file creation and its final fsync/close. Wait only for that bounded
+        # window; a persistently truncated or oversized key still fails closed.
+        if attempt + 1 < _KEY_READ_ATTEMPTS:
+            time.sleep(_KEY_READ_RETRY_SECONDS)
+    raise AdmissionKeyError("admission key has an invalid length")