vortexpy 6.2.0__tar.gz → 6.2.2__tar.gz

{vortexpy-6.2.0 → vortexpy-6.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 6.2.0
+Version: 6.2.2
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-6.2.0 → vortexpy-6.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "6.2.0"
+version = "6.2.2"
 license = {text = "MIT"}
 authors = [{name = "Flying Ion Pty Ltd", email = "contact@flyingion.com"}]
 description = "Flying Ion's observable, routable, data serialisation and transport code."

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortex/VortexFactory.py

@@ -995,7 +995,10 @@ class VortexFactory:
             "Vortex %s went %s", vortexName, ("online" if online else "offline")
         )
 
+        # Rebuild the connection structs before notifying: handlers react to
+        # the status change synchronously (e.g. the offline observer re-tell)
+        # and read getRemoteVortexName() from these structs.
+        cls.connectionChanged()
+
         if vortexName in cls.__vortexStatusChangeSubjectsByName:
             cls.__vortexStatusChangeSubjectsByName[vortexName].on_next(online)
-
-        cls.connectionChanged()

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortex/VortexFactory_test.py

@@ -112,3 +112,75 @@ def test_closeExistingVortexClientsForName_closesRegisteredClients() -> None:
     assert (
         VortexFactory.getLocalVortexClients("codie-mcp-local") == []
     )
+
+
+def _resetVortexFactoryClassState() -> None:
+    VortexFactory._VortexFactory__vortexInfoState = _VortexFactoryVortexInfo()
+    VortexFactory._VortexFactory__vortexStatusChangeSubjectsByName = {}
+    VortexFactory._VortexFactory__isShutdown = False
+
+
+def test_notifyOfVortexStatusChange_rebuildsStructsBeforeNotify() -> None:
+    _resetVortexFactoryClassState()
+    try:
+        client = _StubVortexClient("codie-mcp-local", "local-uuid-1")
+        VortexFactory._VortexFactory__vortexInfoState.addVortexClient(
+            "codie-mcp-local", client
+        )
+
+        # Mirror the handshake: _setNameAndUuid sets the remote info on the
+        # client before _notifyOfVortexStatusChange runs.
+        client._remote_name = "codie-hub"
+        client._remote_uuid = "hub-uuid-1"
+
+        notifications = []
+        VortexFactory.subscribeToVortexStatusChange("codie-hub").subscribe(
+            lambda online: notifications.append(
+                (online, VortexFactory.getRemoteVortexName())
+            )
+        )
+
+        VortexFactory._notifyOfVortexStatusChange("codie-hub", online=True)
+
+        assert len(notifications) == 1
+        online, remoteNames = notifications[0]
+        assert online is True
+        assert "codie-hub" in remoteNames
+    finally:
+        _resetVortexFactoryClassState()
+
+
+def test_notifyOfVortexStatusChange_offlineAfterClearDropsName() -> None:
+    _resetVortexFactoryClassState()
+    try:
+        client = _StubVortexClient(
+            "codie-mcp-local",
+            "local-uuid-1",
+            remote_name="codie-hub",
+            remote_uuid="hub-uuid-1",
+        )
+        VortexFactory._VortexFactory__vortexInfoState.addVortexClient(
+            "codie-mcp-local", client
+        )
+        assert "codie-hub" in VortexFactory.getRemoteVortexName()
+
+        # Mirror connectionLost: _clearRemoteVortexInfo clears the remote
+        # info on the client before _notifyOfVortexStatusChange runs.
+        client._remote_name = None
+        client._remote_uuid = None
+
+        notifications = []
+        VortexFactory.subscribeToVortexStatusChange("codie-hub").subscribe(
+            lambda online: notifications.append(
+                (online, VortexFactory.getRemoteVortexName())
+            )
+        )
+
+        VortexFactory._notifyOfVortexStatusChange("codie-hub", online=False)
+
+        assert len(notifications) == 1
+        online, remoteNames = notifications[0]
+        assert online is False
+        assert "codie-hub" not in remoteNames
+    finally:
+        _resetVortexFactoryClassState()

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortex/__init__.py

@@ -6,4 +6,4 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
-__version__ = '6.2.0'
+__version__ = '6.2.2'

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortex/handler/TupleDataOfflineObserverService.py

@@ -432,7 +432,10 @@ class TupleDataOfflineObserverService:
         self, cachedData: CachedSubscribedData, tupleSelector: TupleSelector
     ) -> Generator[Any, Any, None]:
         """Load the stored payload, decode it, and notify (TS :373-409)."""
-        vortexMsg = yield self._storageLoadTuplesEncoded(tupleSelector)
+        assert self._offlineStorage is not None, (
+            "offlineStorage must be set before loading tuples from storage"
+        )
+        vortexMsg = yield self._offlineStorage.loadTuplesEncoded(tupleSelector)
 
         # There is no data
         if vortexMsg is None:
@@ -444,9 +447,9 @@ class TupleDataOfflineObserverService:
             return
 
         assert isinstance(vortexMsg, str), (
-            f"Expected a plaintext str payload from storage, got"
-            f" {type(vortexMsg).__name__} — ciphered storage must be read via"
-            f" TupleDataSecureOfflineObserverService"
+            f"Expected a plaintext str payload from offline storage, got"
+            f" {type(vortexMsg).__name__} — ciphered storage must be wrapped"
+            f" in TupleOfflineStorageSecureService so reads return plaintext"
         )
         payload = yield Payload().fromEncodedPayloadDefer(vortexMsg)
 
@@ -460,39 +463,6 @@ class TupleDataOfflineObserverService:
         cachedData.tuples = payload.tuples
         self._notifyObservers(cachedData, tupleSelector, payload.tuples)
 
-    def _storageLoadTuplesEncoded(self, tupleSelector: TupleSelector) -> Deferred:
-        """Storage load hook.
-
-        ``TupleDataSecureOfflineObserverService`` overrides this to run the
-        payload through the cipher delegate after reading from storage.
-        """
-        assert self._offlineStorage is not None, (
-            "offlineStorage must be set before loading tuples from storage"
-        )
-        return self._offlineStorage.loadTuplesEncoded(tupleSelector)
-
-    def _storageSaveTuplesEncoded(
-        self, tupleSelector: TupleSelector, vortexMsg: str
-    ) -> Deferred:
-        """Storage save hook.
-
-        ``TupleDataSecureOfflineObserverService`` overrides this to run the
-        payload through the cipher delegate before writing to storage.
-        """
-        assert self._offlineStorage is not None, (
-            "offlineStorage must be set before saving encoded tuples to storage"
-        )
-        return self._offlineStorage.saveTuplesEncoded(tupleSelector, vortexMsg)
-
-    def _storageSaveTuples(
-        self, tupleSelector: TupleSelector, tuples: list[Tuple]
-    ) -> Deferred:
-        """Storage save hook for unencoded tuples."""
-        assert self._offlineStorage is not None, (
-            "offlineStorage must be set before saving tuples to storage"
-        )
-        return self._offlineStorage.saveTuples(tupleSelector, tuples)
-
     def _cleanupDeadCaches(self) -> None:
         for tsStr in list(self._cacheByTupleSelector.keys()):
             cachedData = self._cacheByTupleSelector[tsStr]
@@ -738,6 +708,6 @@ class TupleDataOfflineObserverService:
             return succeed(None)
 
         if encodedPayload is None:
-            return self._storageSaveTuples(tupleSelector, tuples)
+            return self._offlineStorage.saveTuples(tupleSelector, tuples)
 
-        return self._storageSaveTuplesEncoded(tupleSelector, encodedPayload)
+        return self._offlineStorage.saveTuplesEncoded(tupleSelector, encodedPayload)

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortex/handler/TupleDataOfflineObserverService_test.py

@@ -250,7 +250,7 @@ async def test_stored_data_loses_to_live_payload(tmp_path, monkeypatch) -> None:
         loadChains.append(deferred)
         return deferred
 
-    monkeypatch.setattr(service, "_storageLoadTuplesEncoded", gatedLoad)
+    monkeypatch.setattr(storage, "loadTuplesEncoded", gatedLoad)
     monkeypatch.setattr(
         service, "_loadStoredTuplesDefer", capturingLoadStoredTuplesDefer
     )

vortexpy-6.2.2/vortex/storage/TupleOfflineStorageSecureService.py

@@ -0,0 +1,201 @@
+# ruff: noqa: N999
+# Module names use PascalCase for vortexjs member-for-member parity.
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+from __future__ import annotations
+
+import logging
+import time
+from abc import ABCMeta, abstractmethod
+from collections.abc import Generator
+from typing import Any
+
+from twisted.internet.defer import Deferred, inlineCallbacks
+
+from vortex.Payload import Payload
+from vortex.storage.TupleOfflineStorageService import TupleOfflineStorageService
+from vortex.storage.TupleStorageServiceABC import TupleStorageBatchSaveArguments
+from vortex.storage.TupleStorageSqliteService import TupleStorageSqliteService
+from vortex.Tuple import Tuple
+from vortex.TupleSelector import TupleSelector
+
+logger = logging.getLogger(__name__)
+
+
+class OfflineStorageCipherABC(metaclass=ABCMeta):
+    """Offline Storage Cipher ABC
+
+    Cipher delegate for executor-local storage encryption. The concrete cipher
+    is supplied by the consumer — every agentic holds the only key to its own
+    cached data and there is no shared or hub-side key to protect.
+    """
+
+    @abstractmethod
+    def encrypt(self, plaintext: bytes) -> bytes:
+        """Encrypt plaintext bytes.
+
+        :param plaintext: The plaintext to encrypt.
+        :return: The ciphertext bytes.
+        """
+
+    @abstractmethod
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """Decrypt ciphertext bytes.
+
+        :param ciphertext: The ciphertext to decrypt.
+        :return: The plaintext bytes.
+        :raises Exception: when the ciphertext is not readable by this key
+            (cert rotated, wrong key, corrupt row).
+        """
+
+
+class TupleOfflineStorageSecureService(TupleOfflineStorageService):
+    """Tuple Offline Storage Secure Service
+
+    A ``TupleOfflineStorageService`` facade implementation that runs payloads
+    through the cipher delegate before writing to and after reading from the
+    inner storage backend. This is executor-local storage encryption — no
+    hub-side transport encryption; the payload format on the transport is
+    untouched (mTLS already secures transport), only the bytes landing in
+    SQLite are ciphertext.
+
+    Decrypt failure on load (cert rotated, wrong key, corrupt row) is a cache
+    miss: the row is deleted and ``None`` is returned — no plaintext fallback,
+    no partial decrypt.
+    """
+
+    def __init__(
+        self,
+        storage: TupleStorageSqliteService,
+        cipher: OfflineStorageCipherABC,
+    ) -> None:
+        """Constructor
+
+        :param storage: The constructed inner storage backend; ciphertext
+            rows are written to and read from it.
+        :param cipher: The cipher delegate for storage encryption.
+        """
+        TupleOfflineStorageService.__init__(self, storage)
+        self._cipher = cipher
+
+    @inlineCallbacks
+    def loadTuples(
+        self, tupleSelector: TupleSelector
+    ) -> Generator[Any, Any, list[Tuple]]:
+        """Load and decode the tuples stored for a selector.
+
+        Mirrors ``TupleStorageServiceABC.loadTuples`` minus the plaintext-str
+        assert — this facade's own :meth:`loadTuplesEncoded` already owns the
+        decrypt, so the decoded payload is always plaintext ``str`` here.
+
+        :param tupleSelector: The selector to load tuples for.
+        :return: A ``Deferred`` firing the stored tuples, or an empty list on
+            a lookup miss.
+        """
+        startTime = time.monotonic()
+
+        vortexMsg = yield self.loadTuplesEncoded(tupleSelector)
+        if vortexMsg is None:
+            return []
+
+        payload = yield Payload().fromEncodedPayloadDefer(vortexMsg)
+
+        logger.debug(
+            "Secure storage: loadTuples took %sms",
+            round((time.monotonic() - startTime) * 1000),
+        )
+        return payload.tuples
+
+    @inlineCallbacks
+    def loadTuplesEncoded(
+        self, tupleSelector: TupleSelector
+    ) -> Generator[Any, Any, str | None]:
+        """Load, decrypt, and return the stored payload for a selector.
+
+        A decrypt failure (cert rotated, wrong key, corrupt row) is a cache
+        miss: the row is deleted from the inner storage and ``None`` is
+        returned.
+
+        :param tupleSelector: The selector to load the payload for.
+        :return: A ``Deferred`` firing the decrypted encoded payload, or
+            ``None`` on a lookup miss.
+        """
+        stored = yield self._storage.loadTuplesEncoded(tupleSelector)
+        if stored is None:
+            return None
+
+        ciphertext = stored.encode("utf-8") if isinstance(stored, str) else stored
+        try:
+            plaintextBytes = self._cipher.decrypt(ciphertext)
+        except Exception as exception:  # noqa: BLE001 — OfflineStorageCipherABC.decrypt raises Exception by contract
+            logger.warning(
+                "Deleting undecryptable offline cache row for %s: %s",
+                tupleSelector.toJsonStr(),
+                exception,
+            )
+            yield self._storage.deleteTuples(tupleSelector)
+            return None
+
+        return plaintextBytes.decode("utf-8")
+
+    @inlineCallbacks
+    def saveTuples(
+        self, tupleSelector: TupleSelector, tuples: list[Tuple]
+    ) -> Generator[Any, Any, None]:
+        """Encode, encrypt, and store tuples for a selector.
+
+        :param tupleSelector: The selector to store tuples for.
+        :param tuples: The tuples to store.
+        :return: A ``Deferred`` that fires when the tuples are stored.
+        """
+        startTime = time.monotonic()
+
+        vortexMsg = yield Payload(tuples=tuples).toEncodedPayloadDefer()
+        yield self.saveTuplesEncoded(tupleSelector, vortexMsg)
+
+        logger.debug(
+            "Secure storage: saveTuples took %sms",
+            round((time.monotonic() - startTime) * 1000),
+        )
+
+    def saveTuplesEncoded(
+        self, tupleSelector: TupleSelector, vortexMsg: str | bytes
+    ) -> Deferred:
+        """Encrypt and store an encoded payload for a selector.
+
+        :param tupleSelector: The selector to store the payload for.
+        :param vortexMsg: The plaintext encoded payload.
+        :return: A ``Deferred`` that fires when the payload is stored.
+        """
+        plaintext = (
+            vortexMsg.encode("utf-8") if isinstance(vortexMsg, str) else vortexMsg
+        )
+        ciphertext = self._cipher.encrypt(plaintext)
+        return self._storage.saveTuplesEncoded(tupleSelector, ciphertext)
+
+    def batchSaveTuplesEncoded(
+        self, data: list[TupleStorageBatchSaveArguments]
+    ) -> Deferred:
+        """Encrypt and store multiple encoded payloads in one batch.
+
+        :param data: The selectors and plaintext encoded payloads to store.
+        :return: A ``Deferred`` that fires when the batch is stored.
+        """
+        encryptedData = [
+            TupleStorageBatchSaveArguments(
+                tupleSelector=saveArguments.tupleSelector,
+                vortexMsg=self._cipher.encrypt(
+                    saveArguments.vortexMsg.encode("utf-8")
+                    if isinstance(saveArguments.vortexMsg, str)
+                    else saveArguments.vortexMsg
+                ),
+            )
+            for saveArguments in data
+        ]
+        return self._storage.batchSaveTuplesEncoded(encryptedData)

vortexpy-6.2.2/vortex/storage/TupleOfflineStorageSecureService_test.py

@@ -0,0 +1,252 @@
+# ruff: noqa: N999 C408
+# C408: dict() with identifier keys per coding_standards/py_dict_constructor.
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from pytest_twisted import ensureDeferred
+
+from vortex.Payload import Payload
+from vortex.storage.TupleOfflineStorageNameService import (
+    TupleOfflineStorageNameService,
+)
+from vortex.storage.TupleOfflineStorageSecureService import (
+    OfflineStorageCipherABC,
+    TupleOfflineStorageSecureService,
+)
+from vortex.storage.TupleStorageServiceABC import TupleStorageBatchSaveArguments
+from vortex.storage.TupleStorageSqliteService import TupleStorageSqliteService
+from vortex.Tuple import Tuple, TupleField, addTupleType
+from vortex.TupleSelector import TupleSelector
+
+
+@addTupleType
+class OfflineSecureStorageTestTuple(Tuple):
+    __tupleType__ = "vortex.test.OfflineSecureStorageTestTuple"
+    anInt: int = TupleField()
+    aString: str = TupleField()
+
+
+class _XorCipher(OfflineStorageCipherABC):
+    """Test cipher: a key byte prefix followed by an XOR'd body.
+
+    Decrypt raises when the prefix does not match this cipher's key, standing
+    in for an authenticated cipher rejecting a rotated or wrong key.
+    """
+
+    def __init__(self, key: int) -> None:
+        self._key = key
+
+    def encrypt(self, plaintext: bytes) -> bytes:
+        return bytes([self._key]) + bytes(byte ^ self._key for byte in plaintext)
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        if not ciphertext or ciphertext[0] != self._key:
+            raise ValueError("ciphertext is not readable by this key")
+        return bytes(byte ^ self._key for byte in ciphertext[1:])
+
+
+def _makeSelector(key: str = "a") -> TupleSelector:
+    return TupleSelector(OfflineSecureStorageTestTuple, dict(key=key))
+
+
+def _makeTuples(*strings: str) -> list[OfflineSecureStorageTestTuple]:
+    return [
+        OfflineSecureStorageTestTuple(anInt=index, aString=value)
+        for index, value in enumerate(strings)
+    ]
+
+
+async def _makeInnerStorage(tmp_path: Path) -> TupleStorageSqliteService:
+    storage = TupleStorageSqliteService(
+        TupleOfflineStorageNameService("hub-credential"),
+        tmp_path / "vortex-offline",
+    )
+    await storage.open()
+    return storage
+
+
+@pytest.mark.twisted
+@ensureDeferred
+async def test_stored_bytes_are_ciphertext(tmp_path: Path) -> None:
+    innerStorage = await _makeInnerStorage(tmp_path)
+    cipher = _XorCipher(0x5A)
+    secureStorage = TupleOfflineStorageSecureService(innerStorage, cipher)
+    tupleSelector = _makeSelector()
+
+    await secureStorage.saveTuples(tupleSelector, _makeTuples("secret-payload"))
+
+    rawRow = await innerStorage.loadTuplesEncoded(tupleSelector)
+    assert isinstance(rawRow, bytes), (
+        "stored payload must be ciphertext bytes, not plaintext str"
+    )
+
+    assert b"secret-payload" not in rawRow, (
+        "the stored row must not contain the plaintext payload"
+    )
+    assert b"OfflineSecureStorageTestTuple" not in rawRow, (
+        "the stored row must not contain the plaintext tuple type name"
+    )
+
+    # The row decrypts to a standard encoded payload that decodes to the
+    # stored tuples.
+    decryptedPayload = await Payload().fromEncodedPayloadDefer(
+        cipher.decrypt(rawRow).decode("utf-8")
+    )
+    assert [t.aString for t in decryptedPayload.tuples] == ["secret-payload"], (
+        "the decrypted row decodes back to the stored tuples"
+    )
+
+
+@pytest.mark.twisted
+@ensureDeferred
+async def test_save_tuples_encoded_and_batch_are_ciphertext(
+    tmp_path: Path,
+) -> None:
+    innerStorage = await _makeInnerStorage(tmp_path)
+    cipher = _XorCipher(0x5A)
+    secureStorage = TupleOfflineStorageSecureService(innerStorage, cipher)
+
+    expectedBySelector: list[tuple[TupleSelector, str]] = []
+
+    encodedSelector = _makeSelector("encoded")
+    encodedPayload = await Payload(
+        tuples=_makeTuples("encoded-secret")
+    ).toEncodedPayloadDefer()
+    await secureStorage.saveTuplesEncoded(encodedSelector, encodedPayload)
+    expectedBySelector.append((encodedSelector, encodedPayload))
+
+    batchData: list[TupleStorageBatchSaveArguments] = []
+    for key, value in (
+        ("batch-a", "batch-secret-a"),
+        ("batch-b", "batch-secret-b"),
+    ):
+        batchSelector = _makeSelector(key)
+        batchPayload = await Payload(tuples=_makeTuples(value)).toEncodedPayloadDefer()
+        batchData.append(
+            TupleStorageBatchSaveArguments(
+                tupleSelector=batchSelector,
+                vortexMsg=batchPayload,
+            )
+        )
+        expectedBySelector.append((batchSelector, batchPayload))
+    await secureStorage.batchSaveTuplesEncoded(batchData)
+
+    for tupleSelector, plaintext in expectedBySelector:
+        rawRow = await innerStorage.loadTuplesEncoded(tupleSelector)
+        assert isinstance(rawRow, bytes), (
+            "batch and encoded saves must store ciphertext bytes"
+        )
+        assert plaintext.encode("utf-8") not in rawRow, (
+            "the stored row must not contain the plaintext encoded payload"
+        )
+        assert cipher.decrypt(rawRow).decode("utf-8") == plaintext, (
+            "the stored row decrypts back to the original encoded payload"
+        )
+
+
+@pytest.mark.twisted
+@ensureDeferred
+async def test_round_trip_via_secure_facade(tmp_path: Path) -> None:
+    innerStorage = await _makeInnerStorage(tmp_path)
+    tupleSelector = _makeSelector()
+
+    firstSecure = TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x5A))
+    await firstSecure.saveTuples(tupleSelector, _makeTuples("persisted"))
+
+    # A new secure facade with the same key — the service-restart case —
+    # reads the cached data back.
+    secondSecure = TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x5A))
+    tuples = await secondSecure.loadTuples(tupleSelector)
+    assert [t.aString for t in tuples] == ["persisted"], (
+        "a new facade with the same key reads the cached tuples back"
+    )
+
+    vortexMsg = await secondSecure.loadTuplesEncoded(tupleSelector)
+    assert isinstance(vortexMsg, str), (
+        "loadTuplesEncoded returns the decrypted plaintext payload str"
+    )
+    payload = await Payload().fromEncodedPayloadDefer(vortexMsg)
+    assert [t.aString for t in payload.tuples] == ["persisted"], (
+        "the decrypted encoded payload decodes to the stored tuples"
+    )
+
+
+@pytest.mark.twisted
+@ensureDeferred
+async def test_decrypt_failure_deletes_row_and_returns_none(
+    tmp_path: Path,
+) -> None:
+    innerStorage = await _makeInnerStorage(tmp_path)
+    tupleSelector = _makeSelector()
+
+    await TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x5A)).saveTuples(
+        tupleSelector, _makeTuples("old")
+    )
+    assert await innerStorage.loadTuplesEncoded(tupleSelector) is not None, (
+        "the seeded row exists before the wrong-key load"
+    )
+
+    # A facade holding the wrong key treats the row as a cache miss
+    wrongKeySecure = TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x33))
+    assert await wrongKeySecure.loadTuplesEncoded(tupleSelector) is None, (
+        "a wrong-key load treats the row as a cache miss"
+    )
+
+    # The miss deleted the undecryptable row
+    assert await innerStorage.loadTuplesEncoded(tupleSelector) is None, (
+        "the miss deleted the undecryptable row"
+    )
+
+    # loadTuples on a decrypt failure is the same miss: row deleted, []
+    await TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x5A)).saveTuples(
+        tupleSelector, _makeTuples("old")
+    )
+    assert await wrongKeySecure.loadTuples(tupleSelector) == [], (
+        "loadTuples on a decrypt failure returns an empty list"
+    )
+    assert await innerStorage.loadTuplesEncoded(tupleSelector) is None, (
+        "the loadTuples miss also deleted the undecryptable row"
+    )
+
+
+@pytest.mark.twisted
+@ensureDeferred
+async def test_rotated_key_makes_old_cache_unreadable(
+    tmp_path: Path,
+) -> None:
+    innerStorage = await _makeInnerStorage(tmp_path)
+    tupleSelector = _makeSelector()
+
+    # Data cached before the key rotation
+    await TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x5A)).saveTuples(
+        tupleSelector, _makeTuples("before-rotation")
+    )
+
+    # After the rotation the old cache is a miss, not silently served
+    afterRotation = TupleOfflineStorageSecureService(innerStorage, _XorCipher(0x33))
+    assert await afterRotation.loadTuplesEncoded(tupleSelector) is None, (
+        "the rotated key makes the pre-rotation cache a miss"
+    )
+    assert await innerStorage.loadTuplesEncoded(tupleSelector) is None, (
+        "the rotation miss deleted the pre-rotation row"
+    )
+
+    # Re-cached data is encrypted with the rotated key and reads back
+    await afterRotation.saveTuples(tupleSelector, _makeTuples("after-rotation"))
+    rawRow = await innerStorage.loadTuplesEncoded(tupleSelector)
+    assert isinstance(rawRow, bytes), "the re-cached row is stored as ciphertext bytes"
+    assert rawRow[0] == 0x33, "re-cached payload must be encrypted with the rotated key"
+    tuples = await afterRotation.loadTuples(tupleSelector)
+    assert [t.aString for t in tuples] == ["after-rotation"], (
+        "data cached after the rotation reads back with the rotated key"
+    )

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortex/storage/TupleStorageServiceABC.py

@@ -33,10 +33,12 @@ class TupleStorageBatchSaveArguments(NamedTuple):
     """Batch save argument bundle.
 
     Mirror of the vortexjs ``TupleStorageBatchSaveArguments`` interface.
+    ``vortexMsg`` is ``str`` for plaintext (vortexjs parity), ``bytes``
+    when a ciphering consumer stores ciphertext.
     """
 
     tupleSelector: TupleSelector
-    vortexMsg: str
+    vortexMsg: str | bytes
 
 
 class TupleStorageServiceABC(metaclass=ABCMeta):
@@ -97,8 +99,8 @@ class TupleStorageServiceABC(metaclass=ABCMeta):
 
         assert isinstance(vortexMsg, str), (
             f"loadTuples expects a plaintext str payload from storage, got"
-            f" {type(vortexMsg).__name__} — ciphered storage must be read via"
-            f" TupleDataSecureOfflineObserverService"
+            f" {type(vortexMsg).__name__} — ciphered storage must be wrapped"
+            f" in TupleOfflineStorageSecureService so reads return plaintext"
         )
         payload = yield Payload().fromEncodedPayloadDefer(vortexMsg)
 

{vortexpy-6.2.0 → vortexpy-6.2.2}/vortexpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 6.2.0
+Version: 6.2.2
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT