Add the encrypted local cache and the sync client

Three new client projects, and the wire-contract fix they needed. DodoSSH.Client.Domain holds the decrypted item model and the three-way merge, with no I/O at all — so the suite that decides whether a credential can be lost runs in milliseconds with nothing to mock. Scalars defer to the server on a genuine clash so every replica resolves the same triple identically and two clients cannot ping-pong; directives merge per name so two people each adding one both keep theirs; the jump chain merges as a whole value because its order is the route. Whatever loses is returned rather than dropped. DodoSSH.Client.Storage is EF Core on SQLite, no SQLCipher: the rows are already ciphertext, so an encrypted file would protect protected bytes at the cost of a native dependency. It keeps the server's state and the outbox in separate tables, which is what preserves the common ancestor a merge needs. One pending operation per item, enforced by a unique index. DodoSSH.Client.Sync is the pull/apply/push loop. Pulling never decrypts — a change with no local work pending is plumbed as ciphertext — so a first sync of thousands of items does not run twice as many AEAD operations for nothing. Contracts: EncryptedPayload gains WrappedDataKey and DataKeyId. The specification has required a per-item data key since crypto.md §3, the columns have existed since the first migration and DshAad.ItemPayload binds the id, but this record had nowhere to put either — so a spec-compliant item could not be transmitted at all. Found by writing the client that has to produce one. Also closes a hole in AadResourceType, which had no value for the HostTag and HostCredential that SyncEntityType has always listed. Four bugs the tests found, not review: - SQLite refuses to order or compare its own DateTimeOffset mapping, and throws at execution rather than model build. Collecting tombstones and listing conflicts are both that shape, so this was a crash waiting for the first user with a deleted host. Timestamps are integers now, by convention so a later field cannot be the one left unconverted. - SQLitePCLRaw 2.1.11, which EF resolves, is covered by GHSA-2m69-gcr7-jv3q. Pinned forward as a family. - Resurrecting content from a remote deletion cleared the original before queueing the copy. Two transactions, so a crash between them lost the work; reversed, and the rescued id is derived from the tombstone so a replay coalesces instead of duplicating. - Several equality assertions went through Shouldly's ShouldBe, which compares IEnumerable element-wise and so tested nothing about the Equals these types exist to provide. Corrected; the falsification that caught it went from 2 failures to 6. The push response's cursor is deliberately ignored. It sits after this client's own writes, so adopting it skips anything another client committed at a lower sequence in the window between a pull and a push — permanently. Re-reading one's own writes is idempotent and costs a page. The Contracts doc that invited the shortcut now says so. 593 tests, up from 448. The delete-versus-edit rules, the ancestor retention, the fresh operation id on coalesce and the cursor safeguard were each verified by breaking them and watching the right test fail.
2026-07-29 10:27:37 +02:00
parent a878c2b6bb
commit 8d2416a602
72 changed files with 11313 additions and 30 deletions
@@ -0,0 +1,130 @@
+using DodoSSH.Contracts;
+using DodoSSH.Crypto;
+
+namespace DodoSSH.Client.Storage.Tests;
+
+/// <summary>
+/// A migrated, unlocked cache for one test.
+/// </summary>
+/// <remarks>
+/// Each harness gets its own in-memory database, so tests cannot interfere and can run in parallel.
+/// The Argon2id cost is deliberately far below the shipped profile — 8 MiB and one pass rather than
+/// 256 MiB and four. The stretching is what makes a stolen wrap expensive to attack, and none of these
+/// tests attack one; paying 320 ms per test to prove nothing would only encourage sharing state
+/// between them.
+/// </remarks>
+internal sealed class CacheHarness : IDisposable
+{
+    private static readonly Argon2Profile CheapProfile =
+        Argon2Profile.FromStoredParameters(memoryKibibytes: 8 * 1024, passes: 1, parallelism: 1);
+
+    private readonly MasterKey master;
+
+    private CacheHarness(ClientCacheFactory factory, MasterKey master, LocalCacheProtector protector)
+    {
+        Factory = factory;
+        this.master = master;
+        Protector = protector;
+
+        Items = new ItemStore(factory, protector);
+        Outbox = new OutboxStore(factory, protector, TimeProvider.System);
+        Vaults = new VaultStore(factory, TimeProvider.System);
+        Unlock = new UnlockStore(factory, TimeProvider.System);
+        SyncState = new SyncStateStore(factory);
+        Conflicts = new ConflictStore(factory, protector, TimeProvider.System);
+    }
+
+    internal static Guid VaultId { get; } = Guid.Parse("0192f0c8-aaaa-7c3d-8e4f-5a6b7c8d9e0f");
+
+    internal static Guid UserId { get; } = Guid.Parse("0192f0c8-bbbb-7c3d-8e4f-5a6b7c8d9e0f");
+
+    internal ClientCacheFactory Factory { get; }
+
+    internal LocalCacheProtector Protector { get; }
+
+    internal ItemStore Items { get; }
+
+    internal OutboxStore Outbox { get; }
+
+    internal VaultStore Vaults { get; }
+
+    internal UnlockStore Unlock { get; }
+
+    internal SyncStateStore SyncState { get; }
+
+    internal ConflictStore Conflicts { get; }
+
+    internal static async Task<CacheHarness> CreateAsync(
+        string passphrase = "correct horse battery staple")
+    {
+        var factory = ClientCacheFactory.ForMemory($"cache-{Guid.CreateVersion7():N}");
+
+        try
+        {
+            await factory.MigrateAsync(TestContext.Current.CancellationToken);
+
+            var salt = new byte[CryptoSpec.SaltSize];
+            var derived = MasterKey.Derive(passphrase, salt, CheapProfile);
+
+            return new CacheHarness(factory, derived, LocalCacheProtector.From(derived));
+        }
+        catch
+        {
+            factory.Dispose();
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Protector.Dispose();
+        master.Dispose();
+        Factory.Dispose();
+    }
+
+    // ---- Builders ----
+
+    internal static EncryptedPayload Payload(byte seed = 1, uint keyGeneration = 1) =>
+        new(
+            Envelope: [seed, (byte)(seed + 1), (byte)(seed + 2)],
+            WrappedDataKey: [(byte)(seed + 10), (byte)(seed + 11)],
+            DataKeyId: Guid.Parse($"0192f0c8-cccc-7c3d-8e4f-5a6b7c8d9e{seed:x2}"),
+            KeyGeneration: keyGeneration,
+            AadVersion: CryptoSpec.CurrentAadVersion);
+
+    internal static StoredItem Item(
+        Guid entityId,
+        int version = 1,
+        long changeSequence = 1,
+        byte seed = 1,
+        bool deleted = false,
+        SyncPlaintextFields? fields = null) =>
+        new(
+            VaultId,
+            SyncEntityType.Host,
+            entityId,
+            version,
+            changeSequence,
+            deleted ? null : Payload(seed),
+            deleted ? null : fields ?? new SyncPlaintextFields(),
+            deleted,
+            DateTimeOffset.FromUnixTimeSeconds(1_750_000_000 + changeSequence));
+
+    internal static QueuedChange Change(
+        Guid entityId,
+        SyncOperation operation = SyncOperation.Upsert,
+        int? expectedVersion = null,
+        byte seed = 1,
+        StoredAncestor? ancestor = null,
+        SyncPlaintextFields? fields = null) =>
+        new(
+            VaultId,
+            SyncEntityType.Host,
+            entityId,
+            operation,
+            expectedVersion,
+            operation == SyncOperation.Delete ? null : Payload(seed),
+            operation == SyncOperation.Delete ? null : fields ?? new SyncPlaintextFields(),
+            ancestor);
+}