@agimon-ai/doompi-web-security 0.0.1-alpha.10

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Vuong Ngo
+Copyright (c) 2026 pulseaiclub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# @agimon-ai/doompi-web-security
+
+Shared security primitives for the DoomPi web cockpit: the sealed-channel envelope, its `node:crypto`
+and WebCrypto halves, and the signed bundle manifest.
+
+This package holds no policy and starts nothing. It exists because three different programs need to
+agree byte for byte on the same crypto: the cockpit hub (Node), the cockpit page (browser), and every
+web plugin bundled into that page.
+
+## Why it is a package
+
+A plugin in another package cannot import from a client application, and the sealed transport is a
+module singleton whose nonce counters every caller must share. A second copy would start counting at
+zero and the receiver would reject everything it sent as a replay. One package, deduped in the
+bundle, is what makes that impossible.
+
+## Subpaths
+
+| Import                                   | Runs where | What it carries                                                                                          |
+| ---------------------------------------- | ---------- | -------------------------------------------------------------------------------------------------------- |
+| `@agimon-ai/doompi-web-security`         | both       | The envelope contract, the bundle manifest shape, the canonical serialization both sides sign and verify |
+| `@agimon-ai/doompi-web-security/browser` | the page   | The WebCrypto channel and `sealedTransport`, the shared instance plugins use                             |
+| `@agimon-ai/doompi-web-security/node`    | the hub    | The `node:crypto` channel, the host handshake, and the bundle signer                                     |
+
+## The sealed channel
+
+A hosted tunnel terminates TLS at its provider's edge, so without application sealing everything the
+cockpit carries is plaintext to them. Sealing the payload underneath their TLS leaves them a relay that
+sees timing and sizes but not content.
+
+The QR pairing path anchors key exchange out of band. The host's ephemeral P-256 public key is printed on
+the screen the user is holding, so the relay cannot substitute its own. A returning device instead receives
+the current public key after proving a passkey. That path depends on the trusted code-delivery edge described
+above, and the key itself is public rather than secret.
+
+Three properties worth knowing, because getting any of them wrong is silent:
+
+- **Separate keys per direction.** Derived with different HKDF info strings, so a message the server
+  sent can never be replayed back at it as though the client had sent it.
+- **Nonces are a random per-channel prefix plus a monotonic counter**, never random per message. A
+  repeated nonce under one AES-GCM key leaks the XOR of two plaintexts and the authentication subkey;
+  96 bits is small enough that random nonces collide at a rate worth caring about.
+- **Both directions are serialized.** Sealing advances the counter and opening demands it strictly
+  increase, so overlapping asynchronous calls are a correctness bug, not a race worth tolerating.
+  `createSerialQueue` is what prevents a burst of socket sends from reordering into a self-inflicted
+  replay.
+
+Every failure names itself. A decryption failure otherwise shows up as a blank page with nothing to
+go on.
+
+## The signed bundle-manifest primitive
+
+The Node signer traverses a public asset root without following symlinks, requires `/index.html`, hashes each
+byte sequence, and signs a strict canonical manifest v2 with ECDSA P-256. Revision state and the private key
+are persisted atomically at mode `0600`; malformed or replaced state fails closed instead of rotating
+silently.
+
+The browser verifier accepts only the public SPKI and minimum revision pinned by the physical QR. DoomPi's
+package-owned service worker verifies the envelope and every asset before committing a Cache Storage revision,
+then atomically records the active bundle in IndexedDB. A same-revision digest conflict, signer mismatch,
+missing cache, bad MIME metadata, length mismatch, or hash mismatch is refused. The last-known-good bundle
+remains active during a failed refresh.
+
+This does not make the package-owned bootstrap self-protecting. A TLS edge that replaces `/pair` or `/sw.js`
+could remove the verifier before it runs. Once the intended bootstrap is installed, however, host and plugin
+JavaScript cannot execute until its signed bytes pass verification.
+
+`canonicalManifest` is hand-rolled rather than `JSON.stringify` of the whole object, because a signature
+is only worth anything if signer and verifier agree byte for byte, and key order in a JSON object is an
+implementation detail.
+
+## Public API
+
+```ts
+import { canonicalManifest, describeSealedFailure, isSealedEnvelope } from '@agimon-ai/doompi-web-security';
+import { sealedTransport } from '@agimon-ai/doompi-web-security/browser';
+import { createBundleSigner, createHostHandshake } from '@agimon-ai/doompi-web-security/node';
+```
+
+## Development
+
+```bash
+pnpm build
+pnpm typecheck
+pnpm test
+pnpm lint
+```
+
+The round-trip test is the one that matters: it seals with `node:crypto` and opens with real
+WebCrypto, so the two implementations cannot drift apart without a failure.
+
+Maintained by [Agimon](https://agimon.ai/about).

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));exports.__toESM=s;

package/dist/adapters/browserBundleVerifier.cjs

@@ -0,0 +1,2 @@
+const e=require("../types/bundleManifest.cjs");function t(e){let t=e.replaceAll(`-`,`+`).replaceAll(`_`,`/`),n=t.padEnd(Math.ceil(t.length/4)*4,`=`),r=atob(n),i=new Uint8Array(r.length);for(let e=0;e<r.length;e+=1)i[e]=r.charCodeAt(e);return i.buffer}function n(e){return[...new Uint8Array(e)].map(e=>e.toString(16).padStart(2,`0`)).join(``)}async function r(n,r,i=0){if(!e.isSignedBundleManifest(n))return{ok:!1,failure:{code:`invalid-envelope`}};let a=n;if(a.publicKey!==r)return{ok:!1,failure:{code:`untrusted-public-key`}};if(!Number.isSafeInteger(i)||i<0||a.manifest.revision<i)return{ok:!1,failure:{code:`stale-revision`,minimumRevision:i,actualRevision:a.manifest.revision}};let o;try{o=await crypto.subtle.importKey(`spki`,t(r),{name:`ECDSA`,namedCurve:`P-256`},!1,[`verify`])}catch{return{ok:!1,failure:{code:`invalid-public-key`}}}try{return await crypto.subtle.verify({name:`ECDSA`,hash:`SHA-256`},o,t(a.signature),new TextEncoder().encode(e.canonicalManifest(a.manifest)))?{ok:!0,manifest:a.manifest}:{ok:!1,failure:{code:`invalid-signature`}}}catch{return{ok:!1,failure:{code:`invalid-signature`}}}}async function i(t,r,i){let a=e.assetFor(t,r);return a===void 0?{ok:!1,failure:{code:`asset-not-listed`,path:r}}:i.byteLength===a.byteLength?n(await crypto.subtle.digest(`SHA-256`,i))===a.sha256?{ok:!0}:{ok:!1,failure:{code:`digest-mismatch`}}:{ok:!1,failure:{code:`byte-length-mismatch`,expected:a.byteLength,actual:i.byteLength}}}exports.verifyBundleAsset=i,exports.verifySignedBundleManifest=r;
+//# sourceMappingURL=browserBundleVerifier.cjs.map

package/dist/adapters/browserBundleVerifier.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserBundleVerifier.cjs","names":["isSignedBundleManifest","canonicalManifest","assetFor"],"sources":["../../src/adapters/browserBundleVerifier.ts"],"sourcesContent":["import {\n  type BundleManifest,\n  type SignedBundleManifest,\n  assetFor,\n  canonicalManifest,\n  isSignedBundleManifest,\n} from '../types/bundleManifest.ts';\n\nexport type BundleVerificationFailure =\n  | { code: 'invalid-envelope' }\n  | { code: 'untrusted-public-key' }\n  | { code: 'stale-revision'; minimumRevision: number; actualRevision: number }\n  | { code: 'invalid-public-key' }\n  | { code: 'invalid-signature' };\n\nexport type BundleVerificationResult =\n  | { ok: true; manifest: BundleManifest }\n  | { ok: false; failure: BundleVerificationFailure };\n\nexport type BundleAssetVerificationFailure =\n  | { code: 'asset-not-listed'; path: string }\n  | { code: 'byte-length-mismatch'; expected: number; actual: number }\n  | { code: 'digest-mismatch' };\n\nexport type BundleAssetVerificationResult = { ok: true } | { ok: false; failure: BundleAssetVerificationFailure };\n\nfunction decodeBase64Url(value: string): ArrayBuffer {\n  const standard = value.replaceAll('-', '+').replaceAll('_', '/');\n  const padded = standard.padEnd(Math.ceil(standard.length / 4) * 4, '=');\n  const binary = atob(padded);\n  const bytes = new Uint8Array(binary.length);\n  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);\n  return bytes.buffer;\n}\n\nfunction hex(bytes: ArrayBuffer): string {\n  return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, '0')).join('');\n}\n\n/** Verifies a strict envelope against a separately trusted key and revision floor. */\nexport async function verifySignedBundleManifest(\n  value: unknown,\n  trustedPublicKey: string,\n  minimumRevision = 0,\n): Promise<BundleVerificationResult> {\n  if (!isSignedBundleManifest(value)) return { ok: false, failure: { code: 'invalid-envelope' } };\n  const signed: SignedBundleManifest = value;\n  if (signed.publicKey !== trustedPublicKey) return { ok: false, failure: { code: 'untrusted-public-key' } };\n  if (!Number.isSafeInteger(minimumRevision) || minimumRevision < 0 || signed.manifest.revision < minimumRevision) {\n    return {\n      ok: false,\n      failure: { code: 'stale-revision', minimumRevision, actualRevision: signed.manifest.revision },\n    };\n  }\n\n  let key: CryptoKey;\n  try {\n    key = await crypto.subtle.importKey(\n      'spki',\n      decodeBase64Url(trustedPublicKey),\n      { name: 'ECDSA', namedCurve: 'P-256' },\n      false,\n      ['verify'],\n    );\n  } catch {\n    return { ok: false, failure: { code: 'invalid-public-key' } };\n  }\n\n  try {\n    const verified = await crypto.subtle.verify(\n      { name: 'ECDSA', hash: 'SHA-256' },\n      key,\n      decodeBase64Url(signed.signature),\n      new TextEncoder().encode(canonicalManifest(signed.manifest)),\n    );\n    return verified ? { ok: true, manifest: signed.manifest } : { ok: false, failure: { code: 'invalid-signature' } };\n  } catch {\n    return { ok: false, failure: { code: 'invalid-signature' } };\n  }\n}\n\n/** Verifies fetched raw response bytes against an authenticated manifest. */\nexport async function verifyBundleAsset(\n  manifest: BundleManifest,\n  assetPath: string,\n  bytes: ArrayBuffer,\n): Promise<BundleAssetVerificationResult> {\n  const asset = assetFor(manifest, assetPath);\n  if (asset === undefined) return { ok: false, failure: { code: 'asset-not-listed', path: assetPath } };\n  if (bytes.byteLength !== asset.byteLength) {\n    return {\n      ok: false,\n      failure: { code: 'byte-length-mismatch', expected: asset.byteLength, actual: bytes.byteLength },\n    };\n  }\n  const digest = hex(await crypto.subtle.digest('SHA-256', bytes));\n  return digest === asset.sha256 ? { ok: true } : { ok: false, failure: { code: 'digest-mismatch' } };\n}\n"],"mappings":"+CA0BA,SAAS,EAAgB,EAA4B,CACnD,IAAM,EAAW,EAAM,WAAW,IAAK,GAAG,CAAC,CAAC,WAAW,IAAK,GAAG,EACzD,EAAS,EAAS,OAAO,KAAK,KAAK,EAAS,OAAS,CAAC,EAAI,EAAG,GAAG,EAChE,EAAS,KAAK,CAAM,EACpB,EAAQ,IAAI,WAAW,EAAO,MAAM,EAC1C,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAO,OAAQ,GAAS,EAAG,EAAM,GAAS,EAAO,WAAW,CAAK,EAC7F,OAAO,EAAM,MACf,CAEA,SAAS,EAAI,EAA4B,CACvC,MAAO,CAAC,GAAG,IAAI,WAAW,CAAK,CAAC,CAAC,CAAC,IAAK,GAAS,EAAK,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAC7F,CAGA,eAAsB,EACpB,EACA,EACA,EAAkB,EACiB,CACnC,GAAI,CAACA,EAAAA,uBAAuB,CAAK,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,kBAAmB,CAAE,EAC9F,IAAM,EAA+B,EACrC,GAAI,EAAO,YAAc,EAAkB,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,sBAAuB,CAAE,EACzG,GAAI,CAAC,OAAO,cAAc,CAAe,GAAK,EAAkB,GAAK,EAAO,SAAS,SAAW,EAC9F,MAAO,CACL,GAAI,GACJ,QAAS,CAAE,KAAM,iBAAkB,kBAAiB,eAAgB,EAAO,SAAS,QAAS,CAC/F,EAGF,IAAI,EACJ,GAAI,CACF,EAAM,MAAM,OAAO,OAAO,UACxB,OACA,EAAgB,CAAgB,EAChC,CAAE,KAAM,QAAS,WAAY,OAAQ,EACrC,GACA,CAAC,QAAQ,CACX,CACF,MAAQ,CACN,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,oBAAqB,CAAE,CAC9D,CAEA,GAAI,CAOF,OAAO,MANgB,OAAO,OAAO,OACnC,CAAE,KAAM,QAAS,KAAM,SAAU,EACjC,EACA,EAAgB,EAAO,SAAS,EAChC,IAAI,YAAY,CAAC,CAAC,OAAOC,EAAAA,kBAAkB,EAAO,QAAQ,CAAC,CAC7D,EACkB,CAAE,GAAI,GAAM,SAAU,EAAO,QAAS,EAAI,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,mBAAoB,CAAE,CAClH,MAAQ,CACN,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,mBAAoB,CAAE,CAC7D,CACF,CAGA,eAAsB,EACpB,EACA,EACA,EACwC,CACxC,IAAM,EAAQC,EAAAA,SAAS,EAAU,CAAS,EAS1C,OARI,IAAU,IAAA,GAAkB,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,mBAAoB,KAAM,CAAU,CAAE,EAChG,EAAM,aAAe,EAAM,WAMhB,EAAI,MAAM,OAAO,OAAO,OAAO,UAAW,CAAK,CAClD,IAAM,EAAM,OAAS,CAAE,GAAI,EAAK,EAAI,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,iBAAkB,CAAE,EANzF,CACL,GAAI,GACJ,QAAS,CAAE,KAAM,uBAAwB,SAAU,EAAM,WAAY,OAAQ,EAAM,UAAW,CAChG,CAIJ"}

package/dist/adapters/browserBundleVerifier.d.cts

@@ -0,0 +1,45 @@
+import { BundleManifest } from "../types/bundleManifest.cjs";
+//#region src/adapters/browserBundleVerifier.d.ts
+type BundleVerificationFailure = {
+  code: 'invalid-envelope';
+} | {
+  code: 'untrusted-public-key';
+} | {
+  code: 'stale-revision';
+  minimumRevision: number;
+  actualRevision: number;
+} | {
+  code: 'invalid-public-key';
+} | {
+  code: 'invalid-signature';
+};
+type BundleVerificationResult = {
+  ok: true;
+  manifest: BundleManifest;
+} | {
+  ok: false;
+  failure: BundleVerificationFailure;
+};
+type BundleAssetVerificationFailure = {
+  code: 'asset-not-listed';
+  path: string;
+} | {
+  code: 'byte-length-mismatch';
+  expected: number;
+  actual: number;
+} | {
+  code: 'digest-mismatch';
+};
+type BundleAssetVerificationResult = {
+  ok: true;
+} | {
+  ok: false;
+  failure: BundleAssetVerificationFailure;
+};
+/** Verifies a strict envelope against a separately trusted key and revision floor. */
+declare function verifySignedBundleManifest(value: unknown, trustedPublicKey: string, minimumRevision?: number): Promise<BundleVerificationResult>;
+/** Verifies fetched raw response bytes against an authenticated manifest. */
+declare function verifyBundleAsset(manifest: BundleManifest, assetPath: string, bytes: ArrayBuffer): Promise<BundleAssetVerificationResult>;
+//#endregion
+export { BundleAssetVerificationFailure, BundleAssetVerificationResult, BundleVerificationFailure, BundleVerificationResult, verifyBundleAsset, verifySignedBundleManifest };
+//# sourceMappingURL=browserBundleVerifier.d.cts.map

package/dist/adapters/browserBundleVerifier.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserBundleVerifier.d.cts","names":[],"sources":["../../src/adapters/browserBundleVerifier.ts"],"mappings":";;KAQY;EACN;;EACA;;EACA;EAAwB;EAAyB;;EACjD;;EACA;;KAEM;EACN;EAAU,UAAU;;EACpB;EAAW,SAAS;;KAEd;EACN;EAA0B;;EAC1B;EAA8B;EAAkB;;EAChD;;KAEM;EAAkC;;EAAe;EAAW,SAAS;;;iBAgB3D,2BACpB,gBACA,0BACA,2BACC,QAAQ;;iBAsCW,kBACpB,UAAU,gBACV,mBACA,OAAO,cACN,QAAQ"}

package/dist/adapters/browserBundleVerifier.d.mts

@@ -0,0 +1,45 @@
+import { BundleManifest } from "../types/bundleManifest.mjs";
+//#region src/adapters/browserBundleVerifier.d.ts
+type BundleVerificationFailure = {
+  code: 'invalid-envelope';
+} | {
+  code: 'untrusted-public-key';
+} | {
+  code: 'stale-revision';
+  minimumRevision: number;
+  actualRevision: number;
+} | {
+  code: 'invalid-public-key';
+} | {
+  code: 'invalid-signature';
+};
+type BundleVerificationResult = {
+  ok: true;
+  manifest: BundleManifest;
+} | {
+  ok: false;
+  failure: BundleVerificationFailure;
+};
+type BundleAssetVerificationFailure = {
+  code: 'asset-not-listed';
+  path: string;
+} | {
+  code: 'byte-length-mismatch';
+  expected: number;
+  actual: number;
+} | {
+  code: 'digest-mismatch';
+};
+type BundleAssetVerificationResult = {
+  ok: true;
+} | {
+  ok: false;
+  failure: BundleAssetVerificationFailure;
+};
+/** Verifies a strict envelope against a separately trusted key and revision floor. */
+declare function verifySignedBundleManifest(value: unknown, trustedPublicKey: string, minimumRevision?: number): Promise<BundleVerificationResult>;
+/** Verifies fetched raw response bytes against an authenticated manifest. */
+declare function verifyBundleAsset(manifest: BundleManifest, assetPath: string, bytes: ArrayBuffer): Promise<BundleAssetVerificationResult>;
+//#endregion
+export { BundleAssetVerificationFailure, BundleAssetVerificationResult, BundleVerificationFailure, BundleVerificationResult, verifyBundleAsset, verifySignedBundleManifest };
+//# sourceMappingURL=browserBundleVerifier.d.mts.map

package/dist/adapters/browserBundleVerifier.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserBundleVerifier.d.mts","names":[],"sources":["../../src/adapters/browserBundleVerifier.ts"],"mappings":";;KAQY;EACN;;EACA;;EACA;EAAwB;EAAyB;;EACjD;;EACA;;KAEM;EACN;EAAU,UAAU;;EACpB;EAAW,SAAS;;KAEd;EACN;EAA0B;;EAC1B;EAA8B;EAAkB;;EAChD;;KAEM;EAAkC;;EAAe;EAAW,SAAS;;;iBAgB3D,2BACpB,gBACA,0BACA,2BACC,QAAQ;;iBAsCW,kBACpB,UAAU,gBACV,mBACA,OAAO,cACN,QAAQ"}

package/dist/adapters/browserBundleVerifier.mjs

@@ -0,0 +1,2 @@
+import{assetFor as e,canonicalManifest as t,isSignedBundleManifest as n}from"../types/bundleManifest.mjs";function r(e){let t=e.replaceAll(`-`,`+`).replaceAll(`_`,`/`),n=t.padEnd(Math.ceil(t.length/4)*4,`=`),r=atob(n),i=new Uint8Array(r.length);for(let e=0;e<r.length;e+=1)i[e]=r.charCodeAt(e);return i.buffer}function i(e){return[...new Uint8Array(e)].map(e=>e.toString(16).padStart(2,`0`)).join(``)}async function a(e,i,a=0){if(!n(e))return{ok:!1,failure:{code:`invalid-envelope`}};let o=e;if(o.publicKey!==i)return{ok:!1,failure:{code:`untrusted-public-key`}};if(!Number.isSafeInteger(a)||a<0||o.manifest.revision<a)return{ok:!1,failure:{code:`stale-revision`,minimumRevision:a,actualRevision:o.manifest.revision}};let s;try{s=await crypto.subtle.importKey(`spki`,r(i),{name:`ECDSA`,namedCurve:`P-256`},!1,[`verify`])}catch{return{ok:!1,failure:{code:`invalid-public-key`}}}try{return await crypto.subtle.verify({name:`ECDSA`,hash:`SHA-256`},s,r(o.signature),new TextEncoder().encode(t(o.manifest)))?{ok:!0,manifest:o.manifest}:{ok:!1,failure:{code:`invalid-signature`}}}catch{return{ok:!1,failure:{code:`invalid-signature`}}}}async function o(t,n,r){let a=e(t,n);return a===void 0?{ok:!1,failure:{code:`asset-not-listed`,path:n}}:r.byteLength===a.byteLength?i(await crypto.subtle.digest(`SHA-256`,r))===a.sha256?{ok:!0}:{ok:!1,failure:{code:`digest-mismatch`}}:{ok:!1,failure:{code:`byte-length-mismatch`,expected:a.byteLength,actual:r.byteLength}}}export{o as verifyBundleAsset,a as verifySignedBundleManifest};
+//# sourceMappingURL=browserBundleVerifier.mjs.map

package/dist/adapters/browserBundleVerifier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserBundleVerifier.mjs","names":[],"sources":["../../src/adapters/browserBundleVerifier.ts"],"sourcesContent":["import {\n  type BundleManifest,\n  type SignedBundleManifest,\n  assetFor,\n  canonicalManifest,\n  isSignedBundleManifest,\n} from '../types/bundleManifest.ts';\n\nexport type BundleVerificationFailure =\n  | { code: 'invalid-envelope' }\n  | { code: 'untrusted-public-key' }\n  | { code: 'stale-revision'; minimumRevision: number; actualRevision: number }\n  | { code: 'invalid-public-key' }\n  | { code: 'invalid-signature' };\n\nexport type BundleVerificationResult =\n  | { ok: true; manifest: BundleManifest }\n  | { ok: false; failure: BundleVerificationFailure };\n\nexport type BundleAssetVerificationFailure =\n  | { code: 'asset-not-listed'; path: string }\n  | { code: 'byte-length-mismatch'; expected: number; actual: number }\n  | { code: 'digest-mismatch' };\n\nexport type BundleAssetVerificationResult = { ok: true } | { ok: false; failure: BundleAssetVerificationFailure };\n\nfunction decodeBase64Url(value: string): ArrayBuffer {\n  const standard = value.replaceAll('-', '+').replaceAll('_', '/');\n  const padded = standard.padEnd(Math.ceil(standard.length / 4) * 4, '=');\n  const binary = atob(padded);\n  const bytes = new Uint8Array(binary.length);\n  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);\n  return bytes.buffer;\n}\n\nfunction hex(bytes: ArrayBuffer): string {\n  return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, '0')).join('');\n}\n\n/** Verifies a strict envelope against a separately trusted key and revision floor. */\nexport async function verifySignedBundleManifest(\n  value: unknown,\n  trustedPublicKey: string,\n  minimumRevision = 0,\n): Promise<BundleVerificationResult> {\n  if (!isSignedBundleManifest(value)) return { ok: false, failure: { code: 'invalid-envelope' } };\n  const signed: SignedBundleManifest = value;\n  if (signed.publicKey !== trustedPublicKey) return { ok: false, failure: { code: 'untrusted-public-key' } };\n  if (!Number.isSafeInteger(minimumRevision) || minimumRevision < 0 || signed.manifest.revision < minimumRevision) {\n    return {\n      ok: false,\n      failure: { code: 'stale-revision', minimumRevision, actualRevision: signed.manifest.revision },\n    };\n  }\n\n  let key: CryptoKey;\n  try {\n    key = await crypto.subtle.importKey(\n      'spki',\n      decodeBase64Url(trustedPublicKey),\n      { name: 'ECDSA', namedCurve: 'P-256' },\n      false,\n      ['verify'],\n    );\n  } catch {\n    return { ok: false, failure: { code: 'invalid-public-key' } };\n  }\n\n  try {\n    const verified = await crypto.subtle.verify(\n      { name: 'ECDSA', hash: 'SHA-256' },\n      key,\n      decodeBase64Url(signed.signature),\n      new TextEncoder().encode(canonicalManifest(signed.manifest)),\n    );\n    return verified ? { ok: true, manifest: signed.manifest } : { ok: false, failure: { code: 'invalid-signature' } };\n  } catch {\n    return { ok: false, failure: { code: 'invalid-signature' } };\n  }\n}\n\n/** Verifies fetched raw response bytes against an authenticated manifest. */\nexport async function verifyBundleAsset(\n  manifest: BundleManifest,\n  assetPath: string,\n  bytes: ArrayBuffer,\n): Promise<BundleAssetVerificationResult> {\n  const asset = assetFor(manifest, assetPath);\n  if (asset === undefined) return { ok: false, failure: { code: 'asset-not-listed', path: assetPath } };\n  if (bytes.byteLength !== asset.byteLength) {\n    return {\n      ok: false,\n      failure: { code: 'byte-length-mismatch', expected: asset.byteLength, actual: bytes.byteLength },\n    };\n  }\n  const digest = hex(await crypto.subtle.digest('SHA-256', bytes));\n  return digest === asset.sha256 ? { ok: true } : { ok: false, failure: { code: 'digest-mismatch' } };\n}\n"],"mappings":"0GA0BA,SAAS,EAAgB,EAA4B,CACnD,IAAM,EAAW,EAAM,WAAW,IAAK,GAAG,CAAC,CAAC,WAAW,IAAK,GAAG,EACzD,EAAS,EAAS,OAAO,KAAK,KAAK,EAAS,OAAS,CAAC,EAAI,EAAG,GAAG,EAChE,EAAS,KAAK,CAAM,EACpB,EAAQ,IAAI,WAAW,EAAO,MAAM,EAC1C,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAO,OAAQ,GAAS,EAAG,EAAM,GAAS,EAAO,WAAW,CAAK,EAC7F,OAAO,EAAM,MACf,CAEA,SAAS,EAAI,EAA4B,CACvC,MAAO,CAAC,GAAG,IAAI,WAAW,CAAK,CAAC,CAAC,CAAC,IAAK,GAAS,EAAK,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAC7F,CAGA,eAAsB,EACpB,EACA,EACA,EAAkB,EACiB,CACnC,GAAI,CAAC,EAAuB,CAAK,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,kBAAmB,CAAE,EAC9F,IAAM,EAA+B,EACrC,GAAI,EAAO,YAAc,EAAkB,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,sBAAuB,CAAE,EACzG,GAAI,CAAC,OAAO,cAAc,CAAe,GAAK,EAAkB,GAAK,EAAO,SAAS,SAAW,EAC9F,MAAO,CACL,GAAI,GACJ,QAAS,CAAE,KAAM,iBAAkB,kBAAiB,eAAgB,EAAO,SAAS,QAAS,CAC/F,EAGF,IAAI,EACJ,GAAI,CACF,EAAM,MAAM,OAAO,OAAO,UACxB,OACA,EAAgB,CAAgB,EAChC,CAAE,KAAM,QAAS,WAAY,OAAQ,EACrC,GACA,CAAC,QAAQ,CACX,CACF,MAAQ,CACN,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,oBAAqB,CAAE,CAC9D,CAEA,GAAI,CAOF,OAAO,MANgB,OAAO,OAAO,OACnC,CAAE,KAAM,QAAS,KAAM,SAAU,EACjC,EACA,EAAgB,EAAO,SAAS,EAChC,IAAI,YAAY,CAAC,CAAC,OAAO,EAAkB,EAAO,QAAQ,CAAC,CAC7D,EACkB,CAAE,GAAI,GAAM,SAAU,EAAO,QAAS,EAAI,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,mBAAoB,CAAE,CAClH,MAAQ,CACN,MAAO,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,mBAAoB,CAAE,CAC7D,CACF,CAGA,eAAsB,EACpB,EACA,EACA,EACwC,CACxC,IAAM,EAAQ,EAAS,EAAU,CAAS,EAS1C,OARI,IAAU,IAAA,GAAkB,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,mBAAoB,KAAM,CAAU,CAAE,EAChG,EAAM,aAAe,EAAM,WAMhB,EAAI,MAAM,OAAO,OAAO,OAAO,UAAW,CAAK,CAClD,IAAM,EAAM,OAAS,CAAE,GAAI,EAAK,EAAI,CAAE,GAAI,GAAO,QAAS,CAAE,KAAM,iBAAkB,CAAE,EANzF,CACL,GAAI,GACJ,QAAS,CAAE,KAAM,uBAAwB,SAAU,EAAM,WAAY,OAAQ,EAAM,UAAW,CAChG,CAIJ"}

package/dist/adapters/browserSealedChannel.cjs

@@ -0,0 +1,2 @@
+const e=require("../types/sealedChannel.cjs"),t={name:`ECDH`,namedCurve:`P-256`},n=`AES-GCM`;function r(e){let t;try{t=atob(e.replaceAll(`-`,`+`).replaceAll(`_`,`/`))}catch{return}let n=new Uint8Array(new ArrayBuffer(t.length));for(let e=0;e<t.length;e+=1)n[e]=t.charCodeAt(e);return n}function i(e){let t=``;for(let n of e)t+=String.fromCharCode(n);return btoa(t).replaceAll(`+`,`-`).replaceAll(`/`,`_`).replaceAll(`=`,``)}function a(e){let t=new Uint8Array(new ArrayBuffer(e.length));return t.set(e),t.buffer}async function o(t,r){let i=await crypto.subtle.importKey(`raw`,t,`HKDF`,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:`HKDF`,hash:`SHA-256`,salt:a(new TextEncoder().encode(`doompi/sealed/v1`)),info:a(new TextEncoder().encode(e.infoFor(r)))},i,{name:n,length:256},!1,[`encrypt`,`decrypt`])}function s(e,t){let n=new Uint8Array(12);return n.set(e.subarray(0,4),0),new DataView(n.buffer).setBigUint64(4,t,!1),n}function c(t,o,c){let l=0n,u=-1n;return{async seal(r){if(l>=BigInt(e.MAX_MESSAGES_PER_KEY))return{ok:!1,failure:`exhausted`};let o=s(c,l),u=await crypto.subtle.encrypt({name:n,iv:a(o),tagLength:128},t,a(r));return l+=1n,{ok:!0,envelope:{v:1,n:i(o),c:i(new Uint8Array(u))}}},async open(t){let i=t;if(typeof i?.n!=`string`||typeof i.c!=`string`)return{ok:!1,failure:`malformed`};if(i.v!==1)return{ok:!1,failure:`version`};if(!e.isSealedEnvelope(t))return{ok:!1,failure:`malformed`};let s=r(t.n),c=r(t.c);if(s===void 0||c===void 0||s.length!==12||c.length<16)return{ok:!1,failure:`malformed`};let l=new DataView(a(s)).getBigUint64(4,!1);if(l<=u)return{ok:!1,failure:`replay`};let d;try{d=await crypto.subtle.decrypt({name:n,iv:a(s),tagLength:128},o,a(c))}catch{return{ok:!1,failure:`auth`}}return u=l,{ok:!0,plaintext:new Uint8Array(d)}}}}async function l(e){if(globalThis.crypto?.subtle!==void 0)try{let n=await crypto.subtle.generateKey(t,!1,[`deriveBits`]),s=r(e);if(s===void 0)return;let l=await crypto.subtle.importKey(`raw`,a(s),t,!1,[]),u=await crypto.subtle.deriveBits({name:`ECDH`,public:l},n.privateKey,256),d=i(new Uint8Array(await crypto.subtle.exportKey(`raw`,n.publicKey)));return{channel:c(await o(u,`c2s`),await o(u,`s2c`),new Uint8Array(4)),clientPublicKey:d}}catch{return}}async function u(e,t,n){return c(await o(e,t),await o(e,t===`c2s`?`s2c`:`c2s`),n)}exports.channelFromSecret=u,exports.connectSealedChannel=l;
+//# sourceMappingURL=browserSealedChannel.cjs.map

package/dist/adapters/browserSealedChannel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.cjs","names":["infoFor","MAX_MESSAGES_PER_KEY","isSealedEnvelope"],"sources":["../../src/adapters/browserSealedChannel.ts"],"sourcesContent":["import {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\n/**\n * The browser half of the sealed channel.\n *\n * Mirrors `nodeSealedChannel.ts` exactly, on WebCrypto instead of\n * `node:crypto`. Two implementations rather than one because a shared one would\n * drag node builtins into every browser bundle that imports it, and this\n * package is imported by plugins that ship to the page. The envelope contract\n * they both read lives in `../types/sealedChannel.ts`, and a round-trip test\n * pins the two together so they cannot drift.\n */\n\nconst KEY_ALGORITHM = { name: 'ECDH', namedCurve: 'P-256' } as const;\nconst CIPHER = 'AES-GCM';\nconst KEY_BITS = 256;\nconst TAG_BITS = 128;\nconst TAG_BYTES = 16;\nconst HKDF_SALT = 'doompi/sealed/v1';\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  seal(plaintext: Uint8Array): Promise<SealResult>;\n  open(envelope: unknown): Promise<OpenResult>;\n}\n\n/** Undefined rather than a throw: a malformed field is a verdict, not an exception. */\nfunction bytes(value: string): Uint8Array | undefined {\n  let binary: string;\n  try {\n    binary = atob(value.replaceAll('-', '+').replaceAll('_', '/'));\n  } catch {\n    return undefined;\n  }\n  const out = new Uint8Array(new ArrayBuffer(binary.length));\n  for (let index = 0; index < binary.length; index += 1) out[index] = binary.charCodeAt(index);\n  return out;\n}\n\nfunction base64Url(value: Uint8Array): string {\n  let binary = '';\n  for (const byte of value) binary += String.fromCharCode(byte);\n  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');\n}\n\nfunction view(value: Uint8Array): ArrayBuffer {\n  const copy = new Uint8Array(new ArrayBuffer(value.length));\n  copy.set(value);\n  return copy.buffer;\n}\n\nasync function derive(secret: ArrayBuffer, direction: SealedDirection): Promise<CryptoKey> {\n  const material = await crypto.subtle.importKey('raw', secret, 'HKDF', false, ['deriveKey']);\n  return await crypto.subtle.deriveKey(\n    {\n      name: 'HKDF',\n      hash: 'SHA-256',\n      salt: view(new TextEncoder().encode(HKDF_SALT)),\n      info: view(new TextEncoder().encode(infoFor(direction))),\n    },\n    material,\n    { name: CIPHER, length: KEY_BITS },\n    false,\n    ['encrypt', 'decrypt'],\n  );\n}\n\nfunction nonceFor(prefix: Uint8Array, counter: bigint): Uint8Array {\n  const nonce = new Uint8Array(NONCE_BYTES);\n  nonce.set(prefix.subarray(0, NONCE_PREFIX_BYTES), 0);\n  new DataView(nonce.buffer).setBigUint64(NONCE_PREFIX_BYTES, counter, false);\n  return nonce;\n}\n\nfunction channelFrom(sendKey: CryptoKey, receiveKey: CryptoKey, noncePrefix: Uint8Array): SealedChannel {\n  let sendCounter = 0n;\n  let highestReceived = -1n;\n\n  return {\n    async seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const sealed = await crypto.subtle.encrypt(\n        { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n        sendKey,\n        view(plaintext),\n      );\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: base64Url(nonce), c: base64Url(new Uint8Array(sealed)) },\n      };\n    },\n\n    async open(envelope) {\n      // Shape before version, matching the server: something with no `v` at all\n      // is malformed rather than a protocol skew.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = bytes(envelope.n);\n      const body = bytes(envelope.c);\n      if (nonce === undefined || body === undefined) return { ok: false, failure: 'malformed' };\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = new DataView(view(nonce)).getBigUint64(NONCE_PREFIX_BYTES, false);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      let plaintext: ArrayBuffer;\n      try {\n        plaintext = await crypto.subtle.decrypt(\n          { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n          receiveKey,\n          view(body),\n        );\n      } catch {\n        // A failed tag means the message was altered in transit; there is no\n        // partial result worth salvaging.\n        return { ok: false, failure: 'auth' };\n      }\n      // Only after the tag verified, so a forged high counter cannot lock out\n      // every message that legitimately follows it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * Completes the handshake against the host key read out of the QR fragment.\n *\n * That key never travelled through the tunnel, which is what makes this\n * authenticated: a relay can watch the client's public key go past and learn\n * nothing, and it cannot substitute the host's because it never carried it.\n */\nexport async function connectSealedChannel(\n  hostPublicKey: string,\n): Promise<{ channel: SealedChannel; clientPublicKey: string } | undefined> {\n  if (globalThis.crypto?.subtle === undefined) return undefined;\n  try {\n    const pair = await crypto.subtle.generateKey(KEY_ALGORITHM, false, ['deriveBits']);\n    const hostKey = bytes(hostPublicKey);\n    if (hostKey === undefined) return undefined;\n    const peer = await crypto.subtle.importKey('raw', view(hostKey), KEY_ALGORITHM, false, []);\n    const secret = await crypto.subtle.deriveBits({ name: 'ECDH', public: peer }, pair.privateKey, KEY_BITS);\n    const clientPublicKey = base64Url(new Uint8Array(await crypto.subtle.exportKey('raw', pair.publicKey)));\n    return {\n      channel: channelFrom(\n        await derive(secret, 'c2s'),\n        await derive(secret, 's2c'),\n        new Uint8Array(NONCE_PREFIX_BYTES),\n      ),\n      clientPublicKey,\n    };\n  } catch {\n    // A malformed host key or a context without ECDH; the caller falls back to\n    // an unsealed channel and says so rather than failing silently.\n    return undefined;\n  }\n}\n\n/** Exposed so a test can build the browser side against a known secret. */\nexport async function channelFromSecret(\n  secret: ArrayBuffer,\n  sendDirection: SealedDirection,\n  noncePrefix: Uint8Array,\n): Promise<SealedChannel> {\n  const send = await derive(secret, sendDirection);\n  const receive = await derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  return channelFrom(send, receive, noncePrefix);\n}\n"],"mappings":"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"}

package/dist/adapters/browserSealedChannel.d.cts

@@ -0,0 +1,36 @@
+import { SealedDirection, SealedEnvelope, SealedFailure } from "../types/sealedChannel.cjs";
+//#region src/adapters/browserSealedChannel.d.ts
+type SealResult = {
+  ok: true;
+  envelope: SealedEnvelope;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+type OpenResult = {
+  ok: true;
+  plaintext: Uint8Array;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+interface SealedChannel {
+  seal(plaintext: Uint8Array): Promise<SealResult>;
+  open(envelope: unknown): Promise<OpenResult>;
+}
+/**
+ * Completes the handshake against the host key read out of the QR fragment.
+ *
+ * That key never travelled through the tunnel, which is what makes this
+ * authenticated: a relay can watch the client's public key go past and learn
+ * nothing, and it cannot substitute the host's because it never carried it.
+ */
+declare function connectSealedChannel(hostPublicKey: string): Promise<{
+  channel: SealedChannel;
+  clientPublicKey: string;
+} | undefined>;
+/** Exposed so a test can build the browser side against a known secret. */
+declare function channelFromSecret(secret: ArrayBuffer, sendDirection: SealedDirection, noncePrefix: Uint8Array): Promise<SealedChannel>;
+//#endregion
+export { OpenResult, SealResult, SealedChannel, channelFromSecret, connectSealedChannel };
+//# sourceMappingURL=browserSealedChannel.d.cts.map

package/dist/adapters/browserSealedChannel.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.d.cts","names":[],"sources":["../../src/adapters/browserSealedChannel.ts"],"mappings":";;KA8BY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;KAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;UAEpE;EACf,KAAK,WAAW,aAAa,QAAQ;EACrC,KAAK,oBAAoB,QAAQ;;;;;;;;;iBA+Gb,qBACpB,wBACC;EAAU,SAAS;EAAe;;;iBAyBf,kBACpB,QAAQ,aACR,eAAe,iBACf,aAAa,aACZ,QAAQ"}

package/dist/adapters/browserSealedChannel.d.mts

@@ -0,0 +1,36 @@
+import { SealedDirection, SealedEnvelope, SealedFailure } from "../types/sealedChannel.mjs";
+//#region src/adapters/browserSealedChannel.d.ts
+type SealResult = {
+  ok: true;
+  envelope: SealedEnvelope;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+type OpenResult = {
+  ok: true;
+  plaintext: Uint8Array;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+interface SealedChannel {
+  seal(plaintext: Uint8Array): Promise<SealResult>;
+  open(envelope: unknown): Promise<OpenResult>;
+}
+/**
+ * Completes the handshake against the host key read out of the QR fragment.
+ *
+ * That key never travelled through the tunnel, which is what makes this
+ * authenticated: a relay can watch the client's public key go past and learn
+ * nothing, and it cannot substitute the host's because it never carried it.
+ */
+declare function connectSealedChannel(hostPublicKey: string): Promise<{
+  channel: SealedChannel;
+  clientPublicKey: string;
+} | undefined>;
+/** Exposed so a test can build the browser side against a known secret. */
+declare function channelFromSecret(secret: ArrayBuffer, sendDirection: SealedDirection, noncePrefix: Uint8Array): Promise<SealedChannel>;
+//#endregion
+export { OpenResult, SealResult, SealedChannel, channelFromSecret, connectSealedChannel };
+//# sourceMappingURL=browserSealedChannel.d.mts.map

package/dist/adapters/browserSealedChannel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.d.mts","names":[],"sources":["../../src/adapters/browserSealedChannel.ts"],"mappings":";;KA8BY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;KAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;UAEpE;EACf,KAAK,WAAW,aAAa,QAAQ;EACrC,KAAK,oBAAoB,QAAQ;;;;;;;;;iBA+Gb,qBACpB,wBACC;EAAU,SAAS;EAAe;;;iBAyBf,kBACpB,QAAQ,aACR,eAAe,iBACf,aAAa,aACZ,QAAQ"}

package/dist/adapters/browserSealedChannel.mjs

@@ -0,0 +1,2 @@
+import{MAX_MESSAGES_PER_KEY as e,infoFor as t,isSealedEnvelope as n}from"../types/sealedChannel.mjs";const r={name:`ECDH`,namedCurve:`P-256`},i=`AES-GCM`;function a(e){let t;try{t=atob(e.replaceAll(`-`,`+`).replaceAll(`_`,`/`))}catch{return}let n=new Uint8Array(new ArrayBuffer(t.length));for(let e=0;e<t.length;e+=1)n[e]=t.charCodeAt(e);return n}function o(e){let t=``;for(let n of e)t+=String.fromCharCode(n);return btoa(t).replaceAll(`+`,`-`).replaceAll(`/`,`_`).replaceAll(`=`,``)}function s(e){let t=new Uint8Array(new ArrayBuffer(e.length));return t.set(e),t.buffer}async function c(e,n){let r=await crypto.subtle.importKey(`raw`,e,`HKDF`,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:`HKDF`,hash:`SHA-256`,salt:s(new TextEncoder().encode(`doompi/sealed/v1`)),info:s(new TextEncoder().encode(t(n)))},r,{name:i,length:256},!1,[`encrypt`,`decrypt`])}function l(e,t){let n=new Uint8Array(12);return n.set(e.subarray(0,4),0),new DataView(n.buffer).setBigUint64(4,t,!1),n}function u(t,r,c){let u=0n,d=-1n;return{async seal(n){if(u>=BigInt(e))return{ok:!1,failure:`exhausted`};let r=l(c,u),a=await crypto.subtle.encrypt({name:i,iv:s(r),tagLength:128},t,s(n));return u+=1n,{ok:!0,envelope:{v:1,n:o(r),c:o(new Uint8Array(a))}}},async open(e){let t=e;if(typeof t?.n!=`string`||typeof t.c!=`string`)return{ok:!1,failure:`malformed`};if(t.v!==1)return{ok:!1,failure:`version`};if(!n(e))return{ok:!1,failure:`malformed`};let o=a(e.n),c=a(e.c);if(o===void 0||c===void 0||o.length!==12||c.length<16)return{ok:!1,failure:`malformed`};let l=new DataView(s(o)).getBigUint64(4,!1);if(l<=d)return{ok:!1,failure:`replay`};let u;try{u=await crypto.subtle.decrypt({name:i,iv:s(o),tagLength:128},r,s(c))}catch{return{ok:!1,failure:`auth`}}return d=l,{ok:!0,plaintext:new Uint8Array(u)}}}}async function d(e){if(globalThis.crypto?.subtle!==void 0)try{let t=await crypto.subtle.generateKey(r,!1,[`deriveBits`]),n=a(e);if(n===void 0)return;let i=await crypto.subtle.importKey(`raw`,s(n),r,!1,[]),l=await crypto.subtle.deriveBits({name:`ECDH`,public:i},t.privateKey,256),d=o(new Uint8Array(await crypto.subtle.exportKey(`raw`,t.publicKey)));return{channel:u(await c(l,`c2s`),await c(l,`s2c`),new Uint8Array(4)),clientPublicKey:d}}catch{return}}async function f(e,t,n){return u(await c(e,t),await c(e,t===`c2s`?`s2c`:`c2s`),n)}export{f as channelFromSecret,d as connectSealedChannel};
+//# sourceMappingURL=browserSealedChannel.mjs.map

package/dist/adapters/browserSealedChannel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.mjs","names":[],"sources":["../../src/adapters/browserSealedChannel.ts"],"sourcesContent":["import {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\n/**\n * The browser half of the sealed channel.\n *\n * Mirrors `nodeSealedChannel.ts` exactly, on WebCrypto instead of\n * `node:crypto`. Two implementations rather than one because a shared one would\n * drag node builtins into every browser bundle that imports it, and this\n * package is imported by plugins that ship to the page. The envelope contract\n * they both read lives in `../types/sealedChannel.ts`, and a round-trip test\n * pins the two together so they cannot drift.\n */\n\nconst KEY_ALGORITHM = { name: 'ECDH', namedCurve: 'P-256' } as const;\nconst CIPHER = 'AES-GCM';\nconst KEY_BITS = 256;\nconst TAG_BITS = 128;\nconst TAG_BYTES = 16;\nconst HKDF_SALT = 'doompi/sealed/v1';\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  seal(plaintext: Uint8Array): Promise<SealResult>;\n  open(envelope: unknown): Promise<OpenResult>;\n}\n\n/** Undefined rather than a throw: a malformed field is a verdict, not an exception. */\nfunction bytes(value: string): Uint8Array | undefined {\n  let binary: string;\n  try {\n    binary = atob(value.replaceAll('-', '+').replaceAll('_', '/'));\n  } catch {\n    return undefined;\n  }\n  const out = new Uint8Array(new ArrayBuffer(binary.length));\n  for (let index = 0; index < binary.length; index += 1) out[index] = binary.charCodeAt(index);\n  return out;\n}\n\nfunction base64Url(value: Uint8Array): string {\n  let binary = '';\n  for (const byte of value) binary += String.fromCharCode(byte);\n  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');\n}\n\nfunction view(value: Uint8Array): ArrayBuffer {\n  const copy = new Uint8Array(new ArrayBuffer(value.length));\n  copy.set(value);\n  return copy.buffer;\n}\n\nasync function derive(secret: ArrayBuffer, direction: SealedDirection): Promise<CryptoKey> {\n  const material = await crypto.subtle.importKey('raw', secret, 'HKDF', false, ['deriveKey']);\n  return await crypto.subtle.deriveKey(\n    {\n      name: 'HKDF',\n      hash: 'SHA-256',\n      salt: view(new TextEncoder().encode(HKDF_SALT)),\n      info: view(new TextEncoder().encode(infoFor(direction))),\n    },\n    material,\n    { name: CIPHER, length: KEY_BITS },\n    false,\n    ['encrypt', 'decrypt'],\n  );\n}\n\nfunction nonceFor(prefix: Uint8Array, counter: bigint): Uint8Array {\n  const nonce = new Uint8Array(NONCE_BYTES);\n  nonce.set(prefix.subarray(0, NONCE_PREFIX_BYTES), 0);\n  new DataView(nonce.buffer).setBigUint64(NONCE_PREFIX_BYTES, counter, false);\n  return nonce;\n}\n\nfunction channelFrom(sendKey: CryptoKey, receiveKey: CryptoKey, noncePrefix: Uint8Array): SealedChannel {\n  let sendCounter = 0n;\n  let highestReceived = -1n;\n\n  return {\n    async seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const sealed = await crypto.subtle.encrypt(\n        { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n        sendKey,\n        view(plaintext),\n      );\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: base64Url(nonce), c: base64Url(new Uint8Array(sealed)) },\n      };\n    },\n\n    async open(envelope) {\n      // Shape before version, matching the server: something with no `v` at all\n      // is malformed rather than a protocol skew.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = bytes(envelope.n);\n      const body = bytes(envelope.c);\n      if (nonce === undefined || body === undefined) return { ok: false, failure: 'malformed' };\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = new DataView(view(nonce)).getBigUint64(NONCE_PREFIX_BYTES, false);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      let plaintext: ArrayBuffer;\n      try {\n        plaintext = await crypto.subtle.decrypt(\n          { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n          receiveKey,\n          view(body),\n        );\n      } catch {\n        // A failed tag means the message was altered in transit; there is no\n        // partial result worth salvaging.\n        return { ok: false, failure: 'auth' };\n      }\n      // Only after the tag verified, so a forged high counter cannot lock out\n      // every message that legitimately follows it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * Completes the handshake against the host key read out of the QR fragment.\n *\n * That key never travelled through the tunnel, which is what makes this\n * authenticated: a relay can watch the client's public key go past and learn\n * nothing, and it cannot substitute the host's because it never carried it.\n */\nexport async function connectSealedChannel(\n  hostPublicKey: string,\n): Promise<{ channel: SealedChannel; clientPublicKey: string } | undefined> {\n  if (globalThis.crypto?.subtle === undefined) return undefined;\n  try {\n    const pair = await crypto.subtle.generateKey(KEY_ALGORITHM, false, ['deriveBits']);\n    const hostKey = bytes(hostPublicKey);\n    if (hostKey === undefined) return undefined;\n    const peer = await crypto.subtle.importKey('raw', view(hostKey), KEY_ALGORITHM, false, []);\n    const secret = await crypto.subtle.deriveBits({ name: 'ECDH', public: peer }, pair.privateKey, KEY_BITS);\n    const clientPublicKey = base64Url(new Uint8Array(await crypto.subtle.exportKey('raw', pair.publicKey)));\n    return {\n      channel: channelFrom(\n        await derive(secret, 'c2s'),\n        await derive(secret, 's2c'),\n        new Uint8Array(NONCE_PREFIX_BYTES),\n      ),\n      clientPublicKey,\n    };\n  } catch {\n    // A malformed host key or a context without ECDH; the caller falls back to\n    // an unsealed channel and says so rather than failing silently.\n    return undefined;\n  }\n}\n\n/** Exposed so a test can build the browser side against a known secret. */\nexport async function channelFromSecret(\n  secret: ArrayBuffer,\n  sendDirection: SealedDirection,\n  noncePrefix: Uint8Array,\n): Promise<SealedChannel> {\n  const send = await derive(secret, sendDirection);\n  const receive = await derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  return channelFrom(send, receive, noncePrefix);\n}\n"],"mappings":"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"}

package/dist/adapters/bundleSigner.cjs

@@ -0,0 +1,2 @@
+const e=require("../_virtual/_rolldown/runtime.cjs"),t=require("../types/bundleManifest.cjs");let n=require("node:crypto"),r=require("node:fs");r=e.__toESM(r,1);let i=require("node:path");i=e.__toESM(i,1);const a=`signing.json`,o=new Set([`.map`]),s={".css":`text/css`,".gif":`image/gif`,".html":`text/html`,".ico":`image/x-icon`,".jpeg":`image/jpeg`,".jpg":`image/jpeg`,".js":`text/javascript`,".json":`application/json`,".mjs":`text/javascript`,".png":`image/png`,".svg":`image/svg+xml`,".txt":`text/plain`,".wasm":`application/wasm`,".webp":`image/webp`,".woff":`font/woff`,".woff2":`font/woff2`};function c(e){r.default.mkdirSync(e,{recursive:!0,mode:448});let t=r.default.lstatSync(e);if(!t.isDirectory()||t.isSymbolicLink())throw Error(`bundle signing state is not a directory: ${e}`);r.default.chmodSync(e,448)}function l(e,t){c(e);let n=i.default.join(e,`signing.lock`),a;for(let e=0;e<500;e+=1)try{a=r.default.openSync(n,`wx`,384);break}catch(e){if(e.code!==`EEXIST`)throw e;Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,10)}if(a===void 0)throw Error(`timed out waiting for bundle signing state lock: ${n}`);try{return t()}finally{r.default.closeSync(a),r.default.rmSync(n,{force:!0})}}function u(e,t){let o=i.default.join(e,a),s=i.default.join(e,`.${a}.${process.pid}.${(0,n.randomBytes)(8).toString(`hex`)}`),c=r.default.openSync(s,`wx`,384);try{r.default.writeFileSync(c,`${JSON.stringify(t,void 0,2)}\n`),r.default.fsyncSync(c)}finally{r.default.closeSync(c)}try{r.default.renameSync(s,o),r.default.chmodSync(o,384)}catch(e){throw r.default.rmSync(s,{force:!0}),e}}function d(e,t){if(typeof e!=`object`||!e)throw Error(`invalid bundle signing state: ${t}`);let n=e;if(typeof n.privateKey!=`string`||typeof n.publicKey!=`string`)throw Error(`invalid bundle signing state: ${t}`);let r=n.revision===void 0?0:n.revision;if(!Number.isSafeInteger(r)||r<0)throw Error(`invalid bundle signing revision: ${t}`);let i;try{i=_(n.privateKey)}catch{throw Error(`invalid bundle signing private key: ${t}`)}if(i!==n.publicKey)throw Error(`bundle signing keys do not match: ${t}`);return{privateKey:n.privateKey,publicKey:n.publicKey,revision:r}}function f(e){return l(e,()=>{let t=i.default.join(e,a);try{let n=r.default.lstatSync(t);if(!n.isFile()||n.isSymbolicLink())throw Error(`invalid bundle signing state file: ${t}`);let i=JSON.parse(r.default.readFileSync(t,`utf8`)),a=d(i,t);return r.default.chmodSync(t,384),i.revision===void 0&&u(e,a),a}catch(e){if(e.code!==`ENOENT`)throw e}let o=(0,n.generateKeyPairSync)(`ec`,{namedCurve:`prime256v1`,privateKeyEncoding:{type:`pkcs8`,format:`pem`},publicKeyEncoding:{type:`spki`,format:`der`}}),s={privateKey:o.privateKey,publicKey:Buffer.from(o.publicKey).toString(`base64url`),revision:0};return u(e,s),s})}function p(e,t){return l(e,()=>{let n=i.default.join(e,a),o=d(JSON.parse(r.default.readFileSync(n,`utf8`)),n);if(o.publicKey!==t)throw Error(`bundle signing key changed while the signer was active`);if(o.revision===2**53-1)throw Error(`bundle signing revision is exhausted`);let s={...o,revision:o.revision+1};return u(e,s),s.revision})}function m(e){return s[i.default.extname(e).toLowerCase()]??`application/octet-stream`}function h(e,t,a){let s=r.default.readdirSync(t,{withFileTypes:!0});for(let c of s){let s=i.default.join(t,c.name),l=r.default.lstatSync(s);if(l.isSymbolicLink())throw Error(`refusing to sign symbolic link: ${s}`);if(l.isDirectory()){h(e,s,a);continue}if(!l.isFile())throw Error(`refusing to omit unsupported asset: ${s}`);if(o.has(i.default.extname(c.name)))continue;let u=r.default.readFileSync(s);a.push({path:`/${i.default.relative(e,s).split(i.default.sep).map(e=>encodeURIComponent(e)).join(`/`)}`,sha256:(0,n.createHash)(`sha256`).update(u).digest(`hex`),byteLength:u.byteLength,contentType:m(s)})}}function g(e,a=()=>{}){let o=f(e),s=(0,n.createPrivateKey)(o.privateKey),c=new Map,l=i=>{let a=r.default.lstatSync(i);if(!a.isDirectory()||a.isSymbolicLink())throw Error(`refusing to sign an unsafe asset root: ${i}`);let c=[];if(h(i,i,c),c.length===0)return;c.sort((e,t)=>e.path.localeCompare(t.path));let l={version:2,revision:p(e,o.publicKey),builtAt:Date.now(),assets:c};if(!t.isBundleManifest(l))throw Error(`refusing to sign an invalid bundle manifest`);return{manifest:l,signature:(0,n.createSign)(`sha256`).update(t.canonicalManifest(l)).sign({key:s,dsaEncoding:`ieee-p1363`}).toString(`base64url`),publicKey:o.publicKey}},u=e=>{let t=i.default.resolve(e);if(c.has(t))return c.get(t);let n=l(t);return c.set(t,n),n};return{publicKey:()=>o.publicKey,sign:u,refresh(e){let t=i.default.resolve(e);return c.delete(t),u(t)},invalidate(e){e===void 0?c.clear():c.delete(i.default.resolve(e))}}}function _(e){return Buffer.from((0,n.createPublicKey)(e).export({type:`spki`,format:`der`})).toString(`base64url`)}exports.createBundleSigner=g,exports.publicKeyOf=_;
+//# sourceMappingURL=bundleSigner.cjs.map

package/dist/adapters/bundleSigner.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.cjs","names":["fs","path","randomBytes","generateKeyPairSync","createHash","createPrivateKey","isBundleManifest","createSign","canonicalManifest","createPublicKey"],"sources":["../../src/adapters/bundleSigner.ts"],"sourcesContent":["import {\n  createHash,\n  createPrivateKey,\n  createPublicKey,\n  createSign,\n  generateKeyPairSync,\n  randomBytes,\n} from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport {\n  BUNDLE_MANIFEST_VERSION,\n  type BundleAsset,\n  type BundleManifest,\n  type SignedBundleManifest,\n  canonicalManifest,\n  isBundleManifest,\n} from '../types/bundleManifest.ts';\n\nconst SIGNING_FILE = 'signing.json';\nconst LOCK_FILE = 'signing.lock';\nconst FILE_MODE = 0o600;\nconst DIRECTORY_MODE = 0o700;\nconst CURVE = 'prime256v1';\nconst SIGN_ALGORITHM = 'sha256';\nconst SKIPPED = new Set(['.map']);\nconst MIME_TYPES: Readonly<Record<string, string>> = {\n  '.css': 'text/css',\n  '.gif': 'image/gif',\n  '.html': 'text/html',\n  '.ico': 'image/x-icon',\n  '.jpeg': 'image/jpeg',\n  '.jpg': 'image/jpeg',\n  '.js': 'text/javascript',\n  '.json': 'application/json',\n  '.mjs': 'text/javascript',\n  '.png': 'image/png',\n  '.svg': 'image/svg+xml',\n  '.txt': 'text/plain',\n  '.wasm': 'application/wasm',\n  '.webp': 'image/webp',\n  '.woff': 'font/woff',\n  '.woff2': 'font/woff2',\n};\n\nexport interface BundleSigner {\n  /** Base64url SPKI for an independently trusted verifier to pin. */\n  publicKey(): string;\n  /** Hashes and signs once per asset directory. Undefined when the bundle is empty. */\n  sign(assetsDir: string): SignedBundleManifest | undefined;\n  /** Invalidates and immediately rebuilds one cached manifest. */\n  refresh(assetsDir: string): SignedBundleManifest | undefined;\n  /** Invalidates one cached directory, or every cached directory when omitted. */\n  invalidate(assetsDir?: string): void;\n}\n\ninterface StoredState {\n  privateKey: string;\n  publicKey: string;\n  revision: number;\n}\n\nfunction ensureStateDirectory(stateDir: string): void {\n  fs.mkdirSync(stateDir, { recursive: true, mode: DIRECTORY_MODE });\n  const stat = fs.lstatSync(stateDir);\n  if (!stat.isDirectory() || stat.isSymbolicLink())\n    throw new Error(`bundle signing state is not a directory: ${stateDir}`);\n  fs.chmodSync(stateDir, DIRECTORY_MODE);\n}\n\nfunction withStateLock<T>(stateDir: string, operation: () => T): T {\n  ensureStateDirectory(stateDir);\n  const lockPath = path.join(stateDir, LOCK_FILE);\n  let descriptor: number | undefined;\n  for (let attempt = 0; attempt < 500; attempt += 1) {\n    try {\n      descriptor = fs.openSync(lockPath, 'wx', FILE_MODE);\n      break;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;\n      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);\n    }\n  }\n  if (descriptor === undefined) throw new Error(`timed out waiting for bundle signing state lock: ${lockPath}`);\n  try {\n    return operation();\n  } finally {\n    fs.closeSync(descriptor);\n    fs.rmSync(lockPath, { force: true });\n  }\n}\n\nfunction atomicWriteState(stateDir: string, state: StoredState): void {\n  const destination = path.join(stateDir, SIGNING_FILE);\n  const temporary = path.join(stateDir, `.${SIGNING_FILE}.${process.pid}.${randomBytes(8).toString('hex')}`);\n  const descriptor = fs.openSync(temporary, 'wx', FILE_MODE);\n  try {\n    fs.writeFileSync(descriptor, `${JSON.stringify(state, undefined, 2)}\\n`);\n    fs.fsyncSync(descriptor);\n  } finally {\n    fs.closeSync(descriptor);\n  }\n  try {\n    fs.renameSync(temporary, destination);\n    fs.chmodSync(destination, FILE_MODE);\n  } catch (error) {\n    fs.rmSync(temporary, { force: true });\n    throw error;\n  }\n}\n\nfunction parseState(value: unknown, keyPath: string): StoredState {\n  if (typeof value !== 'object' || value === null) throw new Error(`invalid bundle signing state: ${keyPath}`);\n  const candidate = value as Partial<StoredState>;\n  if (typeof candidate.privateKey !== 'string' || typeof candidate.publicKey !== 'string') {\n    throw new Error(`invalid bundle signing state: ${keyPath}`);\n  }\n  const revision = candidate.revision === undefined ? 0 : candidate.revision;\n  if (!Number.isSafeInteger(revision) || revision < 0) throw new Error(`invalid bundle signing revision: ${keyPath}`);\n  let derived: string;\n  try {\n    derived = publicKeyOf(candidate.privateKey);\n  } catch {\n    throw new Error(`invalid bundle signing private key: ${keyPath}`);\n  }\n  if (derived !== candidate.publicKey) throw new Error(`bundle signing keys do not match: ${keyPath}`);\n  return { privateKey: candidate.privateKey, publicKey: candidate.publicKey, revision };\n}\n\nfunction loadOrCreateState(stateDir: string): StoredState {\n  return withStateLock(stateDir, () => {\n    const keyPath = path.join(stateDir, SIGNING_FILE);\n    try {\n      const stat = fs.lstatSync(keyPath);\n      if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`invalid bundle signing state file: ${keyPath}`);\n      const parsed: unknown = JSON.parse(fs.readFileSync(keyPath, 'utf8'));\n      const state = parseState(parsed, keyPath);\n      fs.chmodSync(keyPath, FILE_MODE);\n      if ((parsed as Partial<StoredState>).revision === undefined) atomicWriteState(stateDir, state);\n      return state;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;\n    }\n\n    const pair = generateKeyPairSync('ec', {\n      namedCurve: CURVE,\n      privateKeyEncoding: { type: 'pkcs8', format: 'pem' },\n      publicKeyEncoding: { type: 'spki', format: 'der' },\n    });\n    const state: StoredState = {\n      privateKey: pair.privateKey,\n      publicKey: Buffer.from(pair.publicKey).toString('base64url'),\n      revision: 0,\n    };\n    atomicWriteState(stateDir, state);\n    return state;\n  });\n}\n\nfunction reserveRevision(stateDir: string, expectedPublicKey: string): number {\n  return withStateLock(stateDir, () => {\n    const keyPath = path.join(stateDir, SIGNING_FILE);\n    const state = parseState(JSON.parse(fs.readFileSync(keyPath, 'utf8')) as unknown, keyPath);\n    if (state.publicKey !== expectedPublicKey)\n      throw new Error('bundle signing key changed while the signer was active');\n    if (state.revision === Number.MAX_SAFE_INTEGER) throw new Error('bundle signing revision is exhausted');\n    const next = { ...state, revision: state.revision + 1 };\n    atomicWriteState(stateDir, next);\n    return next.revision;\n  });\n}\n\nfunction contentTypeFor(filePath: string): string {\n  return MIME_TYPES[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';\n}\n\n/** Every servable regular file under the asset root, as browser paths. */\nfunction walk(root: string, current: string, into: BundleAsset[]): void {\n  const entries = fs.readdirSync(current, { withFileTypes: true });\n  for (const entry of entries) {\n    const full = path.join(current, entry.name);\n    const stat = fs.lstatSync(full);\n    if (stat.isSymbolicLink()) throw new Error(`refusing to sign symbolic link: ${full}`);\n    if (stat.isDirectory()) {\n      walk(root, full, into);\n      continue;\n    }\n    if (!stat.isFile()) throw new Error(`refusing to omit unsupported asset: ${full}`);\n    if (SKIPPED.has(path.extname(entry.name))) continue;\n    const bytes = fs.readFileSync(full);\n    into.push({\n      path: `/${path\n        .relative(root, full)\n        .split(path.sep)\n        .map((segment) => encodeURIComponent(segment))\n        .join('/')}`,\n      sha256: createHash('sha256').update(bytes).digest('hex'),\n      byteLength: bytes.byteLength,\n      contentType: contentTypeFor(full),\n    });\n  }\n}\n\nexport function createBundleSigner(stateDir: string, _onNotice: (message: string) => void = () => {}): BundleSigner {\n  const key = loadOrCreateState(stateDir);\n  const privateKey = createPrivateKey(key.privateKey);\n  const cache = new Map<string, SignedBundleManifest | undefined>();\n\n  const signFresh = (assetsDir: string): SignedBundleManifest | undefined => {\n    const rootStat = fs.lstatSync(assetsDir);\n    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {\n      throw new Error(`refusing to sign an unsafe asset root: ${assetsDir}`);\n    }\n    const assets: BundleAsset[] = [];\n    walk(assetsDir, assetsDir, assets);\n    if (assets.length === 0) return undefined;\n    assets.sort((left, right) => left.path.localeCompare(right.path));\n    const manifest: BundleManifest = {\n      version: BUNDLE_MANIFEST_VERSION,\n      revision: reserveRevision(stateDir, key.publicKey),\n      builtAt: Date.now(),\n      assets,\n    };\n    if (!isBundleManifest(manifest)) throw new Error('refusing to sign an invalid bundle manifest');\n    const signature = createSign(SIGN_ALGORITHM)\n      .update(canonicalManifest(manifest))\n      .sign({ key: privateKey, dsaEncoding: 'ieee-p1363' })\n      .toString('base64url');\n    return { manifest, signature, publicKey: key.publicKey };\n  };\n\n  const sign = (assetsDir: string): SignedBundleManifest | undefined => {\n    const cacheKey = path.resolve(assetsDir);\n    if (cache.has(cacheKey)) return cache.get(cacheKey);\n    const signed = signFresh(cacheKey);\n    cache.set(cacheKey, signed);\n    return signed;\n  };\n\n  return {\n    publicKey: () => key.publicKey,\n    sign,\n    refresh(assetsDir) {\n      const cacheKey = path.resolve(assetsDir);\n      cache.delete(cacheKey);\n      return sign(cacheKey);\n    },\n    invalidate(assetsDir) {\n      if (assetsDir === undefined) cache.clear();\n      else cache.delete(path.resolve(assetsDir));\n    },\n  };\n}\n\n/** Re-derives the public key from a stored private key. */\nexport function publicKeyOf(privateKeyPem: string): string {\n  return Buffer.from(createPublicKey(privateKeyPem).export({ type: 'spki', format: 'der' }) as Buffer).toString(\n    'base64url',\n  );\n}\n"],"mappings":"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"}

package/dist/adapters/bundleSigner.d.cts

@@ -0,0 +1,18 @@
+import { SignedBundleManifest } from "../types/bundleManifest.cjs";
+//#region src/adapters/bundleSigner.d.ts
+interface BundleSigner {
+  /** Base64url SPKI for an independently trusted verifier to pin. */
+  publicKey(): string;
+  /** Hashes and signs once per asset directory. Undefined when the bundle is empty. */
+  sign(assetsDir: string): SignedBundleManifest | undefined;
+  /** Invalidates and immediately rebuilds one cached manifest. */
+  refresh(assetsDir: string): SignedBundleManifest | undefined;
+  /** Invalidates one cached directory, or every cached directory when omitted. */
+  invalidate(assetsDir?: string): void;
+}
+declare function createBundleSigner(stateDir: string, _onNotice?: (message: string) => void): BundleSigner;
+/** Re-derives the public key from a stored private key. */
+declare function publicKeyOf(privateKeyPem: string): string;
+//#endregion
+export { BundleSigner, createBundleSigner, publicKeyOf };
+//# sourceMappingURL=bundleSigner.d.cts.map

package/dist/adapters/bundleSigner.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.d.cts","names":[],"sources":["../../src/adapters/bundleSigner.ts"],"mappings":";;UA6CiB;;EAEf;;EAEA,KAAK,oBAAoB;;EAEzB,QAAQ,oBAAoB;;EAE5B,WAAW;;iBAsJG,mBAAmB,kBAAkB,aAAY,2BAAsC;;iBAoDvF,YAAY"}

package/dist/adapters/bundleSigner.d.mts

@@ -0,0 +1,18 @@
+import { SignedBundleManifest } from "../types/bundleManifest.mjs";
+//#region src/adapters/bundleSigner.d.ts
+interface BundleSigner {
+  /** Base64url SPKI for an independently trusted verifier to pin. */
+  publicKey(): string;
+  /** Hashes and signs once per asset directory. Undefined when the bundle is empty. */
+  sign(assetsDir: string): SignedBundleManifest | undefined;
+  /** Invalidates and immediately rebuilds one cached manifest. */
+  refresh(assetsDir: string): SignedBundleManifest | undefined;
+  /** Invalidates one cached directory, or every cached directory when omitted. */
+  invalidate(assetsDir?: string): void;
+}
+declare function createBundleSigner(stateDir: string, _onNotice?: (message: string) => void): BundleSigner;
+/** Re-derives the public key from a stored private key. */
+declare function publicKeyOf(privateKeyPem: string): string;
+//#endregion
+export { BundleSigner, createBundleSigner, publicKeyOf };
+//# sourceMappingURL=bundleSigner.d.mts.map

package/dist/adapters/bundleSigner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.d.mts","names":[],"sources":["../../src/adapters/bundleSigner.ts"],"mappings":";;UA6CiB;;EAEf;;EAEA,KAAK,oBAAoB;;EAEzB,QAAQ,oBAAoB;;EAE5B,WAAW;;iBAsJG,mBAAmB,kBAAkB,aAAY,2BAAsC;;iBAoDvF,YAAY"}

package/dist/adapters/bundleSigner.mjs

@@ -0,0 +1,2 @@
+import{canonicalManifest as e,isBundleManifest as t}from"../types/bundleManifest.mjs";import{createHash as n,createPrivateKey as r,createPublicKey as i,createSign as a,generateKeyPairSync as o,randomBytes as s}from"node:crypto";import c from"node:fs";import l from"node:path";const u=`signing.json`,d=new Set([`.map`]),f={".css":`text/css`,".gif":`image/gif`,".html":`text/html`,".ico":`image/x-icon`,".jpeg":`image/jpeg`,".jpg":`image/jpeg`,".js":`text/javascript`,".json":`application/json`,".mjs":`text/javascript`,".png":`image/png`,".svg":`image/svg+xml`,".txt":`text/plain`,".wasm":`application/wasm`,".webp":`image/webp`,".woff":`font/woff`,".woff2":`font/woff2`};function p(e){c.mkdirSync(e,{recursive:!0,mode:448});let t=c.lstatSync(e);if(!t.isDirectory()||t.isSymbolicLink())throw Error(`bundle signing state is not a directory: ${e}`);c.chmodSync(e,448)}function m(e,t){p(e);let n=l.join(e,`signing.lock`),r;for(let e=0;e<500;e+=1)try{r=c.openSync(n,`wx`,384);break}catch(e){if(e.code!==`EEXIST`)throw e;Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,10)}if(r===void 0)throw Error(`timed out waiting for bundle signing state lock: ${n}`);try{return t()}finally{c.closeSync(r),c.rmSync(n,{force:!0})}}function h(e,t){let n=l.join(e,u),r=l.join(e,`.${u}.${process.pid}.${s(8).toString(`hex`)}`),i=c.openSync(r,`wx`,384);try{c.writeFileSync(i,`${JSON.stringify(t,void 0,2)}\n`),c.fsyncSync(i)}finally{c.closeSync(i)}try{c.renameSync(r,n),c.chmodSync(n,384)}catch(e){throw c.rmSync(r,{force:!0}),e}}function g(e,t){if(typeof e!=`object`||!e)throw Error(`invalid bundle signing state: ${t}`);let n=e;if(typeof n.privateKey!=`string`||typeof n.publicKey!=`string`)throw Error(`invalid bundle signing state: ${t}`);let r=n.revision===void 0?0:n.revision;if(!Number.isSafeInteger(r)||r<0)throw Error(`invalid bundle signing revision: ${t}`);let i;try{i=S(n.privateKey)}catch{throw Error(`invalid bundle signing private key: ${t}`)}if(i!==n.publicKey)throw Error(`bundle signing keys do not match: ${t}`);return{privateKey:n.privateKey,publicKey:n.publicKey,revision:r}}function _(e){return m(e,()=>{let t=l.join(e,u);try{let n=c.lstatSync(t);if(!n.isFile()||n.isSymbolicLink())throw Error(`invalid bundle signing state file: ${t}`);let r=JSON.parse(c.readFileSync(t,`utf8`)),i=g(r,t);return c.chmodSync(t,384),r.revision===void 0&&h(e,i),i}catch(e){if(e.code!==`ENOENT`)throw e}let n=o(`ec`,{namedCurve:`prime256v1`,privateKeyEncoding:{type:`pkcs8`,format:`pem`},publicKeyEncoding:{type:`spki`,format:`der`}}),r={privateKey:n.privateKey,publicKey:Buffer.from(n.publicKey).toString(`base64url`),revision:0};return h(e,r),r})}function v(e,t){return m(e,()=>{let n=l.join(e,u),r=g(JSON.parse(c.readFileSync(n,`utf8`)),n);if(r.publicKey!==t)throw Error(`bundle signing key changed while the signer was active`);if(r.revision===2**53-1)throw Error(`bundle signing revision is exhausted`);let i={...r,revision:r.revision+1};return h(e,i),i.revision})}function y(e){return f[l.extname(e).toLowerCase()]??`application/octet-stream`}function b(e,t,r){let i=c.readdirSync(t,{withFileTypes:!0});for(let a of i){let i=l.join(t,a.name),o=c.lstatSync(i);if(o.isSymbolicLink())throw Error(`refusing to sign symbolic link: ${i}`);if(o.isDirectory()){b(e,i,r);continue}if(!o.isFile())throw Error(`refusing to omit unsupported asset: ${i}`);if(d.has(l.extname(a.name)))continue;let s=c.readFileSync(i);r.push({path:`/${l.relative(e,i).split(l.sep).map(e=>encodeURIComponent(e)).join(`/`)}`,sha256:n(`sha256`).update(s).digest(`hex`),byteLength:s.byteLength,contentType:y(i)})}}function x(n,i=()=>{}){let o=_(n),s=r(o.privateKey),u=new Map,d=r=>{let i=c.lstatSync(r);if(!i.isDirectory()||i.isSymbolicLink())throw Error(`refusing to sign an unsafe asset root: ${r}`);let l=[];if(b(r,r,l),l.length===0)return;l.sort((e,t)=>e.path.localeCompare(t.path));let u={version:2,revision:v(n,o.publicKey),builtAt:Date.now(),assets:l};if(!t(u))throw Error(`refusing to sign an invalid bundle manifest`);return{manifest:u,signature:a(`sha256`).update(e(u)).sign({key:s,dsaEncoding:`ieee-p1363`}).toString(`base64url`),publicKey:o.publicKey}},f=e=>{let t=l.resolve(e);if(u.has(t))return u.get(t);let n=d(t);return u.set(t,n),n};return{publicKey:()=>o.publicKey,sign:f,refresh(e){let t=l.resolve(e);return u.delete(t),f(t)},invalidate(e){e===void 0?u.clear():u.delete(l.resolve(e))}}}function S(e){return Buffer.from(i(e).export({type:`spki`,format:`der`})).toString(`base64url`)}export{x as createBundleSigner,S as publicKeyOf};
+//# sourceMappingURL=bundleSigner.mjs.map

package/dist/adapters/bundleSigner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.mjs","names":[],"sources":["../../src/adapters/bundleSigner.ts"],"sourcesContent":["import {\n  createHash,\n  createPrivateKey,\n  createPublicKey,\n  createSign,\n  generateKeyPairSync,\n  randomBytes,\n} from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport {\n  BUNDLE_MANIFEST_VERSION,\n  type BundleAsset,\n  type BundleManifest,\n  type SignedBundleManifest,\n  canonicalManifest,\n  isBundleManifest,\n} from '../types/bundleManifest.ts';\n\nconst SIGNING_FILE = 'signing.json';\nconst LOCK_FILE = 'signing.lock';\nconst FILE_MODE = 0o600;\nconst DIRECTORY_MODE = 0o700;\nconst CURVE = 'prime256v1';\nconst SIGN_ALGORITHM = 'sha256';\nconst SKIPPED = new Set(['.map']);\nconst MIME_TYPES: Readonly<Record<string, string>> = {\n  '.css': 'text/css',\n  '.gif': 'image/gif',\n  '.html': 'text/html',\n  '.ico': 'image/x-icon',\n  '.jpeg': 'image/jpeg',\n  '.jpg': 'image/jpeg',\n  '.js': 'text/javascript',\n  '.json': 'application/json',\n  '.mjs': 'text/javascript',\n  '.png': 'image/png',\n  '.svg': 'image/svg+xml',\n  '.txt': 'text/plain',\n  '.wasm': 'application/wasm',\n  '.webp': 'image/webp',\n  '.woff': 'font/woff',\n  '.woff2': 'font/woff2',\n};\n\nexport interface BundleSigner {\n  /** Base64url SPKI for an independently trusted verifier to pin. */\n  publicKey(): string;\n  /** Hashes and signs once per asset directory. Undefined when the bundle is empty. */\n  sign(assetsDir: string): SignedBundleManifest | undefined;\n  /** Invalidates and immediately rebuilds one cached manifest. */\n  refresh(assetsDir: string): SignedBundleManifest | undefined;\n  /** Invalidates one cached directory, or every cached directory when omitted. */\n  invalidate(assetsDir?: string): void;\n}\n\ninterface StoredState {\n  privateKey: string;\n  publicKey: string;\n  revision: number;\n}\n\nfunction ensureStateDirectory(stateDir: string): void {\n  fs.mkdirSync(stateDir, { recursive: true, mode: DIRECTORY_MODE });\n  const stat = fs.lstatSync(stateDir);\n  if (!stat.isDirectory() || stat.isSymbolicLink())\n    throw new Error(`bundle signing state is not a directory: ${stateDir}`);\n  fs.chmodSync(stateDir, DIRECTORY_MODE);\n}\n\nfunction withStateLock<T>(stateDir: string, operation: () => T): T {\n  ensureStateDirectory(stateDir);\n  const lockPath = path.join(stateDir, LOCK_FILE);\n  let descriptor: number | undefined;\n  for (let attempt = 0; attempt < 500; attempt += 1) {\n    try {\n      descriptor = fs.openSync(lockPath, 'wx', FILE_MODE);\n      break;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;\n      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);\n    }\n  }\n  if (descriptor === undefined) throw new Error(`timed out waiting for bundle signing state lock: ${lockPath}`);\n  try {\n    return operation();\n  } finally {\n    fs.closeSync(descriptor);\n    fs.rmSync(lockPath, { force: true });\n  }\n}\n\nfunction atomicWriteState(stateDir: string, state: StoredState): void {\n  const destination = path.join(stateDir, SIGNING_FILE);\n  const temporary = path.join(stateDir, `.${SIGNING_FILE}.${process.pid}.${randomBytes(8).toString('hex')}`);\n  const descriptor = fs.openSync(temporary, 'wx', FILE_MODE);\n  try {\n    fs.writeFileSync(descriptor, `${JSON.stringify(state, undefined, 2)}\\n`);\n    fs.fsyncSync(descriptor);\n  } finally {\n    fs.closeSync(descriptor);\n  }\n  try {\n    fs.renameSync(temporary, destination);\n    fs.chmodSync(destination, FILE_MODE);\n  } catch (error) {\n    fs.rmSync(temporary, { force: true });\n    throw error;\n  }\n}\n\nfunction parseState(value: unknown, keyPath: string): StoredState {\n  if (typeof value !== 'object' || value === null) throw new Error(`invalid bundle signing state: ${keyPath}`);\n  const candidate = value as Partial<StoredState>;\n  if (typeof candidate.privateKey !== 'string' || typeof candidate.publicKey !== 'string') {\n    throw new Error(`invalid bundle signing state: ${keyPath}`);\n  }\n  const revision = candidate.revision === undefined ? 0 : candidate.revision;\n  if (!Number.isSafeInteger(revision) || revision < 0) throw new Error(`invalid bundle signing revision: ${keyPath}`);\n  let derived: string;\n  try {\n    derived = publicKeyOf(candidate.privateKey);\n  } catch {\n    throw new Error(`invalid bundle signing private key: ${keyPath}`);\n  }\n  if (derived !== candidate.publicKey) throw new Error(`bundle signing keys do not match: ${keyPath}`);\n  return { privateKey: candidate.privateKey, publicKey: candidate.publicKey, revision };\n}\n\nfunction loadOrCreateState(stateDir: string): StoredState {\n  return withStateLock(stateDir, () => {\n    const keyPath = path.join(stateDir, SIGNING_FILE);\n    try {\n      const stat = fs.lstatSync(keyPath);\n      if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`invalid bundle signing state file: ${keyPath}`);\n      const parsed: unknown = JSON.parse(fs.readFileSync(keyPath, 'utf8'));\n      const state = parseState(parsed, keyPath);\n      fs.chmodSync(keyPath, FILE_MODE);\n      if ((parsed as Partial<StoredState>).revision === undefined) atomicWriteState(stateDir, state);\n      return state;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;\n    }\n\n    const pair = generateKeyPairSync('ec', {\n      namedCurve: CURVE,\n      privateKeyEncoding: { type: 'pkcs8', format: 'pem' },\n      publicKeyEncoding: { type: 'spki', format: 'der' },\n    });\n    const state: StoredState = {\n      privateKey: pair.privateKey,\n      publicKey: Buffer.from(pair.publicKey).toString('base64url'),\n      revision: 0,\n    };\n    atomicWriteState(stateDir, state);\n    return state;\n  });\n}\n\nfunction reserveRevision(stateDir: string, expectedPublicKey: string): number {\n  return withStateLock(stateDir, () => {\n    const keyPath = path.join(stateDir, SIGNING_FILE);\n    const state = parseState(JSON.parse(fs.readFileSync(keyPath, 'utf8')) as unknown, keyPath);\n    if (state.publicKey !== expectedPublicKey)\n      throw new Error('bundle signing key changed while the signer was active');\n    if (state.revision === Number.MAX_SAFE_INTEGER) throw new Error('bundle signing revision is exhausted');\n    const next = { ...state, revision: state.revision + 1 };\n    atomicWriteState(stateDir, next);\n    return next.revision;\n  });\n}\n\nfunction contentTypeFor(filePath: string): string {\n  return MIME_TYPES[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';\n}\n\n/** Every servable regular file under the asset root, as browser paths. */\nfunction walk(root: string, current: string, into: BundleAsset[]): void {\n  const entries = fs.readdirSync(current, { withFileTypes: true });\n  for (const entry of entries) {\n    const full = path.join(current, entry.name);\n    const stat = fs.lstatSync(full);\n    if (stat.isSymbolicLink()) throw new Error(`refusing to sign symbolic link: ${full}`);\n    if (stat.isDirectory()) {\n      walk(root, full, into);\n      continue;\n    }\n    if (!stat.isFile()) throw new Error(`refusing to omit unsupported asset: ${full}`);\n    if (SKIPPED.has(path.extname(entry.name))) continue;\n    const bytes = fs.readFileSync(full);\n    into.push({\n      path: `/${path\n        .relative(root, full)\n        .split(path.sep)\n        .map((segment) => encodeURIComponent(segment))\n        .join('/')}`,\n      sha256: createHash('sha256').update(bytes).digest('hex'),\n      byteLength: bytes.byteLength,\n      contentType: contentTypeFor(full),\n    });\n  }\n}\n\nexport function createBundleSigner(stateDir: string, _onNotice: (message: string) => void = () => {}): BundleSigner {\n  const key = loadOrCreateState(stateDir);\n  const privateKey = createPrivateKey(key.privateKey);\n  const cache = new Map<string, SignedBundleManifest | undefined>();\n\n  const signFresh = (assetsDir: string): SignedBundleManifest | undefined => {\n    const rootStat = fs.lstatSync(assetsDir);\n    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {\n      throw new Error(`refusing to sign an unsafe asset root: ${assetsDir}`);\n    }\n    const assets: BundleAsset[] = [];\n    walk(assetsDir, assetsDir, assets);\n    if (assets.length === 0) return undefined;\n    assets.sort((left, right) => left.path.localeCompare(right.path));\n    const manifest: BundleManifest = {\n      version: BUNDLE_MANIFEST_VERSION,\n      revision: reserveRevision(stateDir, key.publicKey),\n      builtAt: Date.now(),\n      assets,\n    };\n    if (!isBundleManifest(manifest)) throw new Error('refusing to sign an invalid bundle manifest');\n    const signature = createSign(SIGN_ALGORITHM)\n      .update(canonicalManifest(manifest))\n      .sign({ key: privateKey, dsaEncoding: 'ieee-p1363' })\n      .toString('base64url');\n    return { manifest, signature, publicKey: key.publicKey };\n  };\n\n  const sign = (assetsDir: string): SignedBundleManifest | undefined => {\n    const cacheKey = path.resolve(assetsDir);\n    if (cache.has(cacheKey)) return cache.get(cacheKey);\n    const signed = signFresh(cacheKey);\n    cache.set(cacheKey, signed);\n    return signed;\n  };\n\n  return {\n    publicKey: () => key.publicKey,\n    sign,\n    refresh(assetsDir) {\n      const cacheKey = path.resolve(assetsDir);\n      cache.delete(cacheKey);\n      return sign(cacheKey);\n    },\n    invalidate(assetsDir) {\n      if (assetsDir === undefined) cache.clear();\n      else cache.delete(path.resolve(assetsDir));\n    },\n  };\n}\n\n/** Re-derives the public key from a stored private key. */\nexport function publicKeyOf(privateKeyPem: string): string {\n  return Buffer.from(createPublicKey(privateKeyPem).export({ type: 'spki', format: 'der' }) as Buffer).toString(\n    'base64url',\n  );\n}\n"],"mappings":"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"}

package/dist/adapters/nodeSealedChannel.cjs

@@ -0,0 +1,2 @@
+const e=require("../types/sealedChannel.cjs");let t=require("node:crypto");const n=`prime256v1`,r=`aes-256-gcm`,i=Buffer.from(`doompi/sealed/v1`);function a(n,r){return Buffer.from((0,t.hkdfSync)(`sha256`,n,i,Buffer.from(e.infoFor(r)),32))}function o(e,t){let n=Buffer.alloc(12);return e.copy(n,0,0,4),n.writeBigUInt64BE(t,4),n}function s(n,i,s){let c=a(n,i),l=a(n,i===`c2s`?`s2c`:`c2s`),u=0n,d=-1n;return{seal(n){if(u>=BigInt(e.MAX_MESSAGES_PER_KEY))return{ok:!1,failure:`exhausted`};let i=o(s,u),a=(0,t.createCipheriv)(r,c,i),l=Buffer.concat([a.update(n),a.final(),a.getAuthTag()]);return u+=1n,{ok:!0,envelope:{v:1,n:i.toString(`base64url`),c:l.toString(`base64url`)}}},open(n){let i=n;if(typeof i?.n!=`string`||typeof i.c!=`string`)return{ok:!1,failure:`malformed`};if(i.v!==1)return{ok:!1,failure:`version`};if(!e.isSealedEnvelope(n))return{ok:!1,failure:`malformed`};let a=Buffer.from(n.n,`base64url`),o=Buffer.from(n.c,`base64url`);if(a.length!==12||o.length<16)return{ok:!1,failure:`malformed`};let s=a.readBigUInt64BE(4);if(s<=d)return{ok:!1,failure:`replay`};let c=(0,t.createDecipheriv)(r,l,a);c.setAuthTag(o.subarray(o.length-16));let u;try{u=Buffer.concat([c.update(o.subarray(0,o.length-16)),c.final()])}catch{return{ok:!1,failure:`auth`}}return d=s,{ok:!0,plaintext:new Uint8Array(u)}}}}function c(){let e=(0,t.createECDH)(n);e.generateKeys();let r=new Set;return{publicKey:e.getPublicKey().toString(`base64url`),accept(i){let a,o;try{if(a=t.ECDH.convertKey(Buffer.from(i,`base64url`),n,void 0,void 0,`uncompressed`),r.has(a.toString(`base64url`)))return;o=e.computeSecret(a)}catch{return}return r.add(a.toString(`base64url`)),s(o,`s2c`,(0,t.randomBytes)(4))}}}exports.createHostHandshake=c;
+//# sourceMappingURL=nodeSealedChannel.cjs.map

package/dist/adapters/nodeSealedChannel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeSealedChannel.cjs","names":["hkdfSync","infoFor","MAX_MESSAGES_PER_KEY","createCipheriv","isSealedEnvelope","createDecipheriv","createECDH","ECDH","randomBytes"],"sources":["../../src/adapters/nodeSealedChannel.ts"],"sourcesContent":["import { ECDH, createCipheriv, createDecipheriv, createECDH, hkdfSync, randomBytes } from 'node:crypto';\nimport {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\nconst CURVE = 'prime256v1';\nconst CIPHER = 'aes-256-gcm';\nconst KEY_BYTES = 32;\nconst TAG_BYTES = 16;\nconst HKDF_HASH = 'sha256';\n/** Fixed and public: HKDF's salt need not be secret, and a constant keeps both sides in step. */\nconst HKDF_SALT = Buffer.from('doompi/sealed/v1');\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  /** Seals one message. Counters advance only on success. */\n  seal(plaintext: Uint8Array): SealResult;\n  open(envelope: unknown): OpenResult;\n}\n\nexport interface HostHandshake {\n  /** Base64url uncompressed P-256 point, printed in the QR. */\n  publicKey: string;\n  /** Completes the exchange against the peer's key and yields the channel. */\n  accept(peerPublicKey: string): SealedChannel | undefined;\n}\n\nfunction derive(secret: Buffer, direction: SealedDirection): Buffer {\n  return Buffer.from(hkdfSync(HKDF_HASH, secret, HKDF_SALT, Buffer.from(infoFor(direction)), KEY_BYTES));\n}\n\n/**\n * Builds the nonce for one message.\n *\n * A random per-channel prefix plus a monotonic counter, rather than a random\n * nonce per message: 96 bits is small enough that random nonces collide at a\n * rate worth caring about, and a repeated nonce under one AES-GCM key is\n * catastrophic rather than merely weak.\n */\nfunction nonceFor(prefix: Buffer, counter: bigint): Buffer {\n  const nonce = Buffer.alloc(NONCE_BYTES);\n  prefix.copy(nonce, 0, 0, NONCE_PREFIX_BYTES);\n  nonce.writeBigUInt64BE(counter, NONCE_PREFIX_BYTES);\n  return nonce;\n}\n\n/**\n * One direction's sealing state.\n *\n * Send and receive are separate keys and separate counters, so a message the\n * server sent can never be replayed back at it as though the client had sent it.\n */\nfunction createChannel(secret: Buffer, sendDirection: SealedDirection, noncePrefix: Buffer): SealedChannel {\n  const sendKey = derive(secret, sendDirection);\n  const receiveKey = derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  let sendCounter = 0n;\n  /** Strictly increasing: anything at or below what has been seen is a replay. */\n  let highestReceived = -1n;\n\n  return {\n    seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const cipher = createCipheriv(CIPHER, sendKey, nonce);\n      const body = Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: nonce.toString('base64url'), c: body.toString('base64url') },\n      };\n    },\n\n    open(envelope) {\n      // Shape before version: something with no `v` at all is malformed, and\n      // calling it a version mismatch would send a reader hunting for a\n      // protocol skew that is not there.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = Buffer.from(envelope.n, 'base64url');\n      const body = Buffer.from(envelope.c, 'base64url');\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = nonce.readBigUInt64BE(NONCE_PREFIX_BYTES);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      const decipher = createDecipheriv(CIPHER, receiveKey, nonce);\n      decipher.setAuthTag(body.subarray(body.length - TAG_BYTES));\n      let plaintext: Buffer;\n      try {\n        plaintext = Buffer.concat([decipher.update(body.subarray(0, body.length - TAG_BYTES)), decipher.final()]);\n      } catch {\n        // A failed tag means the message was altered, which is the whole point\n        // of having one. Never fall back to the ciphertext.\n        return { ok: false, failure: 'auth' };\n      }\n      // Advanced only after the tag verified, so a forged high counter cannot\n      // lock out the messages that follow it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * The host half of the handshake.\n *\n * The ephemeral key pair is generated per tunnel and its public half goes in the\n * QR, which is the out-of-band channel that makes this authenticated. A relay\n * that swaps the client's key gets a channel with itself and nothing from the\n * host, because the host only ever derives against the key the client presents\n * and the client only ever derives against the key it read off the screen.\n */\nexport function createHostHandshake(): HostHandshake {\n  const exchange = createECDH(CURVE);\n  exchange.generateKeys();\n  const acceptedPeers = new Set<string>();\n  return {\n    publicKey: exchange.getPublicKey().toString('base64url'),\n    accept(peerPublicKey) {\n      let peer: Buffer;\n      let secret: Buffer;\n      try {\n        peer = ECDH.convertKey(Buffer.from(peerPublicKey, 'base64url'), CURVE, undefined, undefined, 'uncompressed');\n        if (acceptedPeers.has(peer.toString('base64url'))) return undefined;\n        secret = exchange.computeSecret(peer);\n      } catch {\n        // A key that is not a point on the curve; there is no channel to make.\n        return undefined;\n      }\n      acceptedPeers.add(peer.toString('base64url'));\n      // The prefix is the host's to choose and travels in every nonce, so the\n      // client reads it off the wire rather than needing it up front.\n      return createChannel(secret, 's2c', randomBytes(NONCE_PREFIX_BYTES));\n    },\n  };\n}\n"],"mappings":"2EAaA,MAAM,EAAQ,aACR,EAAS,cAKT,EAAY,OAAO,KAAK,kBAAkB,EAkBhD,SAAS,EAAO,EAAgB,EAAoC,CAClE,OAAO,OAAO,MAAA,EAAKA,EAAAA,SAAAA,CAAS,SAAW,EAAQ,EAAW,OAAO,KAAKC,EAAAA,QAAQ,CAAS,CAAC,EAAG,EAAS,CAAC,CACvG,CAUA,SAAS,EAAS,EAAgB,EAAyB,CACzD,IAAM,EAAQ,OAAO,MAAA,EAAiB,EAGtC,OAFA,EAAO,KAAK,EAAO,EAAG,EAAA,CAAqB,EAC3C,EAAM,iBAAiB,EAAA,CAA2B,EAC3C,CACT,CAQA,SAAS,EAAc,EAAgB,EAAgC,EAAoC,CACzG,IAAM,EAAU,EAAO,EAAQ,CAAa,EACtC,EAAa,EAAO,EAAQ,IAAkB,MAAQ,MAAQ,KAAK,EACrE,EAAc,GAEd,EAAkB,CAAC,GAEvB,MAAO,CACL,KAAK,EAAW,CACd,GAAI,GAAe,OAAOC,EAAAA,oBAAoB,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1F,IAAM,EAAQ,EAAS,EAAa,CAAW,EACzC,GAAA,EAASC,EAAAA,eAAAA,CAAe,EAAQ,EAAS,CAAK,EAC9C,EAAO,OAAO,OAAO,CAAC,EAAO,OAAO,CAAS,EAAG,EAAO,MAAM,EAAG,EAAO,WAAW,CAAC,CAAC,EAE1F,MADA,IAAe,GACR,CACL,GAAI,GACJ,SAAU,CAAE,EAAA,EAAmB,EAAG,EAAM,SAAS,WAAW,EAAG,EAAG,EAAK,SAAS,WAAW,CAAE,CAC/F,CACF,EAEA,KAAK,EAAU,CAIb,IAAM,EAAQ,EACd,GAAI,OAAO,GAAO,GAAM,UAAY,OAAO,EAAM,GAAM,SAAU,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1G,GAAI,EAAM,IAAA,EAAsB,MAAO,CAAE,GAAI,GAAO,QAAS,SAAU,EACvE,GAAI,CAACC,EAAAA,iBAAiB,CAAQ,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1E,IAAM,EAAQ,OAAO,KAAK,EAAS,EAAG,WAAW,EAC3C,EAAO,OAAO,KAAK,EAAS,EAAG,WAAW,EAChD,GAAI,EAAM,SAAA,IAA0B,EAAK,OAAS,GAAW,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EACtG,IAAM,EAAU,EAAM,gBAAA,CAAkC,EACxD,GAAI,GAAW,EAAiB,MAAO,CAAE,GAAI,GAAO,QAAS,QAAS,EACtE,IAAM,GAAA,EAAWC,EAAAA,iBAAAA,CAAiB,EAAQ,EAAY,CAAK,EAC3D,EAAS,WAAW,EAAK,SAAS,EAAK,OAAS,EAAS,CAAC,EAC1D,IAAI,EACJ,GAAI,CACF,EAAY,OAAO,OAAO,CAAC,EAAS,OAAO,EAAK,SAAS,EAAG,EAAK,OAAS,EAAS,CAAC,EAAG,EAAS,MAAM,CAAC,CAAC,CAC1G,MAAQ,CAGN,MAAO,CAAE,GAAI,GAAO,QAAS,MAAO,CACtC,CAIA,MADA,GAAkB,EACX,CAAE,GAAI,GAAM,UAAW,IAAI,WAAW,CAAS,CAAE,CAC1D,CACF,CACF,CAWA,SAAgB,GAAqC,CACnD,IAAM,GAAA,EAAWC,EAAAA,WAAAA,CAAW,CAAK,EACjC,EAAS,aAAa,EACtB,IAAM,EAAgB,IAAI,IAC1B,MAAO,CACL,UAAW,EAAS,aAAa,CAAC,CAAC,SAAS,WAAW,EACvD,OAAO,EAAe,CACpB,IAAI,EACA,EACJ,GAAI,CAEF,GADA,EAAOC,EAAAA,KAAK,WAAW,OAAO,KAAK,EAAe,WAAW,EAAG,EAAO,IAAA,GAAW,IAAA,GAAW,cAAc,EACvG,EAAc,IAAI,EAAK,SAAS,WAAW,CAAC,EAAG,OACnD,EAAS,EAAS,cAAc,CAAI,CACtC,MAAQ,CAEN,MACF,CAIA,OAHA,EAAc,IAAI,EAAK,SAAS,WAAW,CAAC,EAGrC,EAAc,EAAQ,OAAA,EAAOC,EAAAA,YAAAA,CAAAA,CAA8B,CAAC,CACrE,CACF,CACF"}