@nihilium/recovery-service 0.0.0-stage → 0.9.0

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# `@nihilium/recovery-service`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The host half of value decomposition (spec §12). A wallet provider runs this and holds a recovery
+vault's **encrypted records**; the seal that makes them meaningful stays with the user.
+
+What the provider holds is inert on its own, so it has no unilateral access path — which is what
+lets the same party hold operational controls, the §6 pause key included, without holding custody.
+
+## What it deliberately cannot do
+
+- **List.** There is no listing route and no `listRecords` on `SealedDataStore`. A listing would make
+  the provider a directory of who has a recovery.
+- **Distinguish an empty record from an absent one.** An unknown id returns `{ entries: [] }`, not a
+  404, so a prober cannot enumerate.
+- **Read what it holds.** The record payload is adapter-owned ciphertext and is never inspected —
+  including its format tag, so a condition adapter written next year works against a service
+  deployed today.
+
+## Node-only by resolution
+
+The `exports` map declares `types` and `node` and deliberately no `browser` or `default` condition,
+mirroring `@nihilium/client-sdk`'s `./server` entry. A wallet bundle that imports this **fails to
+resolve** rather than quietly shipping the provider's storage side to the client.
+
+## Capabilities
+
+| | Who holds it | Mailable |
+|---|---|---|
+| `recordId` | the user, the provider, anyone | **yes** — that is what it is for |
+| append credential | the wallet, beside the seal | **no** — it is a write capability |
+| the seal | the user only | **no** — it is bearer material |
+
+Reading needs only the record id: 120 unguessable bits yielding ciphertext. Appending needs a
+separate credential, because an add-only store cannot delete — a read capability that also wrote
+would make a leaked email a permanent junk-injection vector.
+
+## Wiring it up
+
+```ts
+import { createServer } from "node:http";
+import { LocalSealedDataStore } from "@nihilium/recovery-storage-local";
+import { RecoveryDataService, hashCredential, sharedSecretAppend } from "@nihilium/recovery-service";
+
+const service = new RecoveryDataService({
+    store: new LocalSealedDataStore({ directory: "/var/lib/nihilium", domain: "acme-wallet" }),
+    append: sharedSecretAppend({ [recordId]: hashCredential(credential) }),
+});
+
+createServer(async (req, res) => {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) chunks.push(chunk as Buffer);
+    const body = chunks.length ? JSON.parse(Buffer.concat(chunks).toString()) : undefined;
+
+    const { status, body: out } = await service.handle({
+        method: req.method!,
+        path: new URL(req.url!, "http://localhost").pathname,
+        headers: req.headers as Record<string, string>,
+        body,
+    });
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(out === null ? "" : JSON.stringify(out));
+}).listen(8080);
+```
+
+Embedding it in a framework you already run? Call `listEntries` and `appendEntry` directly —
+`handle()` is a thin router over them, not the API.
+
+## Routes
+
+```
+GET  /records/:id   -> 200 { entries }      no credential
+POST /records/:id   -> 204                  X-Nihilium-Append-Credential required
+```
+
+## The failure mode to plan for
+
+Losing these records loses the recovery even with the seal in hand. Because a record is inert
+without the seal, there is no reason not to keep copies everywhere — keep one on the user's device
+and treat the provider as a **replica, never the origin**. That is the exact inverse of the seal's
+placement rule, and it is deliberate.

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+import { type SealedDataEntry, type SealedDataStore, type ServiceRequest, type ServiceResponse } from "@nihilium/recovery-core";
+/**
+ * Re-exported so this package's surface is unchanged by the move into core.
+ *
+ * `ServiceError`, `hashCredential` and the constant-time compare are shared with
+ * `@nihilium/recovery-watchtower`: two hosts must not carry two copies of the same security
+ * primitive, since copies drift and nobody reading either one can see it.
+ */
+export { ServiceError, constantTimeEquals, hashCredential, readHeader, } from "@nihilium/recovery-core";
+export type { ServiceRequest, ServiceResponse } from "@nihilium/recovery-core";
+/**
+ * `@nihilium/recovery-service` — the host half of value decomposition (spec §12).
+ *
+ * A wallet provider runs this and holds a vault's encrypted records. What it holds is meaningless
+ * without the seal, which lives with the user, so the provider has **no unilateral access path** —
+ * which is exactly what lets the same party hold operational controls, the §6 pause key included,
+ * without ever holding custody.
+ *
+ * **Node-only, by resolution rather than by convention.** The package's `exports` map declares
+ * `types` and `node` and deliberately no `browser` or `default` condition, mirroring
+ * `@nihilium/client-sdk`'s `./server` entry. A wallet bundle that imports this fails to resolve
+ * instead of quietly shipping the provider's storage side to the client.
+ *
+ * There is no `node:http` here either. The package stays runtime-agnostic and a host wires
+ * `handle()` into whatever server it already runs — see the README for the five-line Node version.
+ */
+/** Decides whether an append may proceed. See `sharedSecretAppend` for the default. */
+export interface AppendAuthorizer {
+    authorize(params: {
+        recordId: string;
+        credential: string | undefined;
+    }): Promise<void> | void;
+}
+export interface RecoveryDataServiceOptions {
+    store: SealedDataStore;
+    append: AppendAuthorizer;
+    /**
+     * Largest record accepted, in bytes of serialized JSON.
+     *
+     * A single-condition record is a few hundred bytes; an n-member quorum record is n times that
+     * plus manifest. 64 KiB is generous for both. Without a cap, an add-only store behind a bearer
+     * id is a free unbounded object store.
+     */
+    maxEntryBytes?: number;
+    /**
+     * Most entries one record may hold. A vault protecting more than a couple of hundred chains is
+     * not a thing; an append credential that leaked and is filling the record is.
+     */
+    maxEntriesPerRecord?: number;
+}
+/** Header the default authorizer reads the append credential from. */
+export declare const APPEND_CREDENTIAL_HEADER = "x-nihilium-append-credential";
+/**
+ * The host.
+ *
+ * Two layers on purpose: `listEntries`/`appendEntry` are the semantic API and are what a host
+ * embedding this in its own framework should call, while `handle()` is a thin router over them for
+ * hosts that want the HTTP shape handed to them.
+ */
+export declare class RecoveryDataService {
+    private readonly store;
+    private readonly append;
+    private readonly maxEntryBytes;
+    private readonly maxEntriesPerRecord;
+    constructor(options: RecoveryDataServiceOptions);
+    /**
+     * Every entry under `recordId`.
+     *
+     * The record id **is** the read capability: 120 unguessable bits, and what it yields is
+     * ciphertext with no unilateral access path. No credential is required, which is what makes an
+     * id safe to mail to a user for later lookup.
+     *
+     * An unknown id returns an empty list rather than 404, deliberately. A prober must not be able
+     * to tell "this vault exists but is empty" from "no such vault" — the store behaves the same
+     * way, and a 404 here would undo it.
+     */
+    listEntries(recordId: string): Promise<SealedDataEntry[]>;
+    /**
+     * Append one record.
+     *
+     * The record id is deliberately **not** sufficient here. It is designed to be emailed, and an
+     * add-only store cannot delete, so a read capability that also wrote would be a permanent
+     * junk-injection vector with no way to clean up after it.
+     */
+    appendEntry(recordId: string, entry: SealedDataEntry, credential?: string): Promise<void>;
+    /**
+     * Route a request.
+     *
+     * Exactly two routes, and the absence of a third is a design decision rather than an omission:
+     * there is **no listing endpoint**. A listing would turn the service into a directory of who has
+     * a recovery, which is the one thing a provider holding only ciphertext must not become.
+     *
+     *     GET  /records/:id   -> { entries }
+     *     POST /records/:id   -> 204, with an append credential
+     */
+    handle(req: ServiceRequest): Promise<ServiceResponse>;
+}
+/**
+ * Appends are authorized by a credential the wallet minted at seal time and kept beside the seal.
+ *
+ * Only `sha256(credential)` is stored, so a compromise of the service's own state does not yield a
+ * write capability — the same commitment discipline the quorum uses for shares. Compared in constant
+ * time, since a timing oracle on a hash comparison is cheap to remove and awkward to reason about
+ * later.
+ *
+ * The credential is a *write* capability and must never be mailed the way a record id is.
+ */
+export declare function sharedSecretAppend(credentialHashes: Readonly<Record<string, string>>): AppendAuthorizer;
+/**
+ * Lets anyone holding the record id append.
+ *
+ * Named to read badly in a configuration file, as `NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE`
+ * is. Legitimate for the first-implementation case where the service and the seal sit on the same
+ * device and the record id never leaves it. Illegitimate the moment the id is mailed: it is designed
+ * to be, and an add-only store has no way to remove what a leaked id then writes.
+ */
+export declare function openAppend_DO_NOT_USE_IN_PRODUCTION(): AppendAuthorizer;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAQH,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,eAAe,EACvB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;GAMG;AACH,OAAO,EACH,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,UAAU,GACb,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/E;;;;;;;;;;;;;;;GAeG;AAIH,uFAAuF;AACvF,MAAM,WAAW,gBAAgB;IAC7B,SAAS,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACjG;AAED,MAAM,WAAW,0BAA0B;IACvC,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sEAAsE;AACtE,eAAO,MAAM,wBAAwB,iCAAiC,CAAC;AAKvE;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;gBAEjC,OAAO,EAAE,0BAA0B;IAO/C;;;;;;;;;;OAUG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAI/D;;;;;;OAMG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,EACtB,UAAU,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC;IAyBhB;;;;;;;;;OASG;IACG,MAAM,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CA+B9D;AAID;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAC9B,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACnD,gBAAgB,CAclB;AAED;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,IAAI,gBAAgB,CAEtE"}

package/dist/index.js

@@ -0,0 +1,164 @@
+import { RecoverySdkError, ServiceError, constantTimeEquals, describeEntryShapeProblem, hashCredential, normalizeRecordId, readHeader, } from "@nihilium/recovery-core";
+/**
+ * Re-exported so this package's surface is unchanged by the move into core.
+ *
+ * `ServiceError`, `hashCredential` and the constant-time compare are shared with
+ * `@nihilium/recovery-watchtower`: two hosts must not carry two copies of the same security
+ * primitive, since copies drift and nobody reading either one can see it.
+ */
+export { ServiceError, constantTimeEquals, hashCredential, readHeader, } from "@nihilium/recovery-core";
+/** Header the default authorizer reads the append credential from. */
+export const APPEND_CREDENTIAL_HEADER = "x-nihilium-append-credential";
+const DEFAULT_MAX_ENTRY_BYTES = 64 * 1024;
+const DEFAULT_MAX_ENTRIES = 256;
+/**
+ * The host.
+ *
+ * Two layers on purpose: `listEntries`/`appendEntry` are the semantic API and are what a host
+ * embedding this in its own framework should call, while `handle()` is a thin router over them for
+ * hosts that want the HTTP shape handed to them.
+ */
+export class RecoveryDataService {
+    store;
+    append;
+    maxEntryBytes;
+    maxEntriesPerRecord;
+    constructor(options) {
+        this.store = options.store;
+        this.append = options.append;
+        this.maxEntryBytes = options.maxEntryBytes ?? DEFAULT_MAX_ENTRY_BYTES;
+        this.maxEntriesPerRecord = options.maxEntriesPerRecord ?? DEFAULT_MAX_ENTRIES;
+    }
+    /**
+     * Every entry under `recordId`.
+     *
+     * The record id **is** the read capability: 120 unguessable bits, and what it yields is
+     * ciphertext with no unilateral access path. No credential is required, which is what makes an
+     * id safe to mail to a user for later lookup.
+     *
+     * An unknown id returns an empty list rather than 404, deliberately. A prober must not be able
+     * to tell "this vault exists but is empty" from "no such vault" — the store behaves the same
+     * way, and a 404 here would undo it.
+     */
+    async listEntries(recordId) {
+        return this.store.getEntries(normalizeRecordId(recordId));
+    }
+    /**
+     * Append one record.
+     *
+     * The record id is deliberately **not** sufficient here. It is designed to be emailed, and an
+     * add-only store cannot delete, so a read capability that also wrote would be a permanent
+     * junk-injection vector with no way to clean up after it.
+     */
+    async appendEntry(recordId, entry, credential) {
+        const id = normalizeRecordId(recordId);
+        await this.append.authorize({ recordId: id, credential });
+        assertEntryShape(entry);
+        const size = JSON.stringify(entry).length;
+        if (size > this.maxEntryBytes) {
+            throw new ServiceError(413, `Record is ${size} bytes; this service accepts at most ${this.maxEntryBytes}.`);
+        }
+        const existing = await this.store.getEntries(id);
+        if (existing.length >= this.maxEntriesPerRecord) {
+            throw new ServiceError(409, `This record already holds ${existing.length} entries, the configured maximum. ` +
+                `Entries are never removed, so this limit is final for this record.`);
+        }
+        await this.store.addEntry(id, entry);
+    }
+    /**
+     * Route a request.
+     *
+     * Exactly two routes, and the absence of a third is a design decision rather than an omission:
+     * there is **no listing endpoint**. A listing would turn the service into a directory of who has
+     * a recovery, which is the one thing a provider holding only ciphertext must not become.
+     *
+     *     GET  /records/:id   -> { entries }
+     *     POST /records/:id   -> 204, with an append credential
+     */
+    async handle(req) {
+        try {
+            const recordId = recordIdFromPath(req.path);
+            if (recordId === undefined) {
+                return { status: 404, body: { error: "No such route." } };
+            }
+            if (req.method.toUpperCase() === "GET") {
+                return { status: 200, body: { entries: await this.listEntries(recordId) } };
+            }
+            if (req.method.toUpperCase() === "POST") {
+                await this.appendEntry(recordId, req.body, readHeader(req, APPEND_CREDENTIAL_HEADER));
+                return { status: 204, body: null };
+            }
+            return { status: 405, body: { error: `${req.method} is not allowed here.` } };
+        }
+        catch (error) {
+            if (error instanceof ServiceError) {
+                return { status: error.status, body: { error: error.message } };
+            }
+            if (error instanceof RecoverySdkError) {
+                // A malformed record id, a reused entry id, a store refusing a write. All of these
+                // are the caller's fault and all carry messages written to be read.
+                return { status: 400, body: { error: error.message } };
+            }
+            throw error;
+        }
+    }
+}
+// --- Append authorization -------------------------------------------------------------------------
+/**
+ * Appends are authorized by a credential the wallet minted at seal time and kept beside the seal.
+ *
+ * Only `sha256(credential)` is stored, so a compromise of the service's own state does not yield a
+ * write capability — the same commitment discipline the quorum uses for shares. Compared in constant
+ * time, since a timing oracle on a hash comparison is cheap to remove and awkward to reason about
+ * later.
+ *
+ * The credential is a *write* capability and must never be mailed the way a record id is.
+ */
+export function sharedSecretAppend(credentialHashes) {
+    return {
+        authorize({ recordId, credential }) {
+            const expected = credentialHashes[recordId];
+            if (!expected) {
+                // Same status and message whether the record is unknown or the credential is wrong,
+                // so a prober cannot use append failures to enumerate records.
+                throw new ServiceError(403, "Not authorized to append to this record.");
+            }
+            if (credential === undefined || !constantTimeEquals(hashCredential(credential), expected)) {
+                throw new ServiceError(403, "Not authorized to append to this record.");
+            }
+        },
+    };
+}
+/**
+ * Lets anyone holding the record id append.
+ *
+ * Named to read badly in a configuration file, as `NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE`
+ * is. Legitimate for the first-implementation case where the service and the seal sit on the same
+ * device and the record id never leaves it. Illegitimate the moment the id is mailed: it is designed
+ * to be, and an add-only store has no way to remove what a leaked id then writes.
+ */
+export function openAppend_DO_NOT_USE_IN_PRODUCTION() {
+    return { authorize() { } };
+}
+// --- Internals ------------------------------------------------------------------------------------
+/** `/records/:id`, with or without a trailing slash. Anything else is not a route. */
+function recordIdFromPath(path) {
+    const parts = path.split("/").filter((part) => part !== "");
+    if (parts.length !== 2 || parts[0] !== "records")
+        return undefined;
+    return decodeURIComponent(parts[1]);
+}
+/**
+ * Check what the service can check without being able to read anything.
+ *
+ * The rule itself lives in core as `describeEntryShapeProblem`, because a client applies the same
+ * one to a *response* body where a `400` would be nonsense. What stays here is the service's error
+ * policy: the shape is a client's fault, so it is a `400`.
+ */
+function assertEntryShape(entry) {
+    const problem = describeEntryShapeProblem(entry);
+    if (problem !== undefined) {
+        throw new ServiceError(400, `Request body ${problem}.`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@nihilium/recovery-service",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.0",
+  "description": "Node-only host for a recovery vault's encrypted records \u2014 value-decomposition storage a provider can run without holding custody (spec \u00a712).",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "node": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean"
+  },
+  "dependencies": {
+    "@nihilium/recovery-core": "^0.9.0"
+  },
+  "devDependencies": {
+    "@nihilium/recovery-storage-local": "^0.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}