cursedbelt-server 3.0.0 → 4.0.0

package/src/server/private-media/gatePolicy.spec.ts

@@ -1,98 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { Hono } from 'hono';
-import { createDiskStore } from '../storage/diskStore';
-import { generateUserSalt, sealMeta } from './crypto';
-import { createMemoryPrivateIndex } from './index-store';
-import { mountPrivateRoutes } from './mountPrivateRoutes';
-import { createUnlockService } from './unlock';
-
-// The gate password policy: the password is an ACCESS CHECK against the app's own accounts
-// (e.g. the login store), not a key-derivation input. Correct password ⇒ a STANDARD
-// (recoverable, server-key) grant; wrong/absent password ⇒ 401; password changes never
-// orphan content because the set key never depended on the password.
-
-const unlock = createUnlockService({ serverSecret: 'srv', unlockSecret: 'unlock' });
-const salt = generateUserSalt();
-
-function gateApp(verify: (password: string) => boolean) {
-  const app = new Hono();
-  const index = createMemoryPrivateIndex();
-  mountPrivateRoutes(app, {
-    store: createDiskStore('/tmp/unused-pm-gate'),
-    index,
-    unlock,
-    authorize: async () => ({ userId: 'u1', userSalt: salt }),
-    passwordPolicy: {
-      mode: 'gate',
-      verifyPassword: async (_who, password) => verify(password),
-    },
-  });
-  return { app, index };
-}
-
-const post = (app: Hono, path: string, body: unknown) =>
-  app.request(path, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  });
-
-describe('unlock gate policy', () => {
-  test('correct password ⇒ standard grant (key never derived from the password)', async () => {
-    const { app } = gateApp((pw) => pw === 'login-pw');
-    const res = await post(app, '/_private/unlock', { password: 'login-pw' });
-    expect(res.status).toBe(200);
-    const { token, mode } = (await res.json()) as { token: string; mode: string };
-    expect(mode).toBe('standard');
-    const grant = await unlock.verify(token);
-    expect(grant?.mode).toBe('standard');
-    // The grant's key equals the server-derived one — NOT a password derivation.
-    expect(grant?.setKey.equals(unlock.deriveSetKey({ userId: 'u1', userSalt: salt }))).toBe(true);
-  });
-
-  test('wrong password ⇒ 401, no token', async () => {
-    const { app } = gateApp((pw) => pw === 'login-pw');
-    const res = await post(app, '/_private/unlock', { password: 'wrong' });
-    expect(res.status).toBe(401);
-  });
-
-  test('missing password ⇒ 401 (no silent session unlock under gate)', async () => {
-    const { app } = gateApp(() => true);
-    const res = await post(app, '/_private/unlock', {});
-    expect(res.status).toBe(401);
-  });
-
-  test('reveal under gate verifies then reveals the STANDARD set', async () => {
-    const { app, index } = gateApp((pw) => pw === 'login-pw');
-    const standardKey = unlock.deriveSetKey({ userId: 'u1', userSalt: salt });
-    await index.add({
-      id: 'item1',
-      owner: 'u1',
-      sealedMeta: sealMeta(standardKey, { name: 'secret.jpg', mime: 'image/jpeg', tags: [] }),
-      wrappedContentKey: 'unused',
-      sizeBytes: 3,
-      createdAt: Date.now(),
-      status: 'ready',
-      keyMode: 'standard',
-    });
-    const bad = await post(app, '/_private/reveal', { password: 'nope' });
-    expect(bad.status).toBe(401);
-    const good = await post(app, '/_private/reveal', { password: 'login-pw' });
-    expect(good.status).toBe(200);
-    const { items } = (await good.json()) as { items: Array<{ id: string }> };
-    expect(items.map((i) => i.id)).toEqual(['item1']);
-  });
-
-  test('derive policy (default) still mints deniable sets from passwords', async () => {
-    const app = new Hono();
-    mountPrivateRoutes(app, {
-      store: createDiskStore('/tmp/unused-pm-gate'),
-      index: createMemoryPrivateIndex(),
-      unlock,
-      authorize: async () => ({ userId: 'u1', userSalt: salt }),
-    });
-    const res = await post(app, '/_private/unlock', { password: 'anything' });
-    expect(res.status).toBe(200);
-    expect(((await res.json()) as { mode: string }).mode).toBe('deniable');
-  });
-});

package/src/server/private-media/index-store.ts

@@ -1,83 +0,0 @@
-import type { ProcessingStatus } from 'cursedbelt-core/media';
-import type { KeyMode } from './crypto';
-
-// ── Private index ───────────────────────────────────────────────────────────────
-// Per-user rows for encrypted media. The row holds ONLY non-sensitive facts in the clear
-// (size, created-at, status) so a user can see "N locked files, X GB" and prune ones whose
-// password they've lost. The sensitive parts — title / thumbnail / notes / tags — live in the
-// AES-GCM `sealedMeta` envelope, and the AES-128 content key lives in `wrappedContentKey`; both
-// are opaque without the set key. The public projection (`toPublic`) is what the index endpoint
-// returns — it strips every secret, including the key MODE (so the clear index can't even hint
-// which rows are deniable). An app swaps the in-memory store for a SQLite-backed one (see
-// cursedbelt-server/sqlite) without touching the routes.
-
-export type PrivateItem = {
-  id: string;
-  owner: string;
-  sizeBytes: number;
-  createdAt: number;
-  status: ProcessingStatus;
-  keyMode: KeyMode;
-  /** AES-128 content key + IV, wrapped under the item's set key. */
-  wrappedContentKey: string;
-  /** AES-GCM envelope of { title, notes, tags, durationSeconds, … } under the item's set key. */
-  sealedMeta: string;
-};
-
-/** What the index endpoint exposes — clear, non-sensitive facts only. No title/thumb/notes/tags,
- * no key mode, no wrapped key. */
-export type PrivateIndexRow = {
-  id: string;
-  sizeBytes: number;
-  createdAt: number;
-  status: ProcessingStatus;
-};
-
-export const toPublic = (item: PrivateItem): PrivateIndexRow => ({
-  id: item.id,
-  sizeBytes: item.sizeBytes,
-  createdAt: item.createdAt,
-  status: item.status,
-});
-
-export interface PrivateIndex {
-  add(item: PrivateItem): Promise<void>;
-  get(owner: string, id: string): Promise<PrivateItem | null>;
-  list(owner: string): Promise<PrivateItem[]>;
-  update(
-    owner: string,
-    id: string,
-    patch: Partial<Omit<PrivateItem, 'id' | 'owner'>>,
-  ): Promise<void>;
-  remove(owner: string, id: string): Promise<void>;
-}
-
-export function createMemoryPrivateIndex(): PrivateIndex {
-  const byOwner = new Map<string, Map<string, PrivateItem>>();
-  const bucket = (owner: string) => {
-    let m = byOwner.get(owner);
-    if (!m) {
-      m = new Map();
-      byOwner.set(owner, m);
-    }
-    return m;
-  };
-  return {
-    async add(item) {
-      bucket(item.owner).set(item.id, item);
-    },
-    async get(owner, id) {
-      return bucket(owner).get(id) ?? null;
-    },
-    async list(owner) {
-      return [...bucket(owner).values()].sort((a, b) => b.createdAt - a.createdAt);
-    },
-    async update(owner, id, patch) {
-      const item = bucket(owner).get(id);
-      if (item) bucket(owner).set(id, { ...item, ...patch });
-    },
-    async remove(owner, id) {
-      bucket(owner).delete(id);
-    },
-  };
-}

package/src/server/private-media/mountPrivateRoutes.ts

@@ -1,265 +0,0 @@
-import type { Context, Hono } from 'hono';
-import { decodeRange, serveRange } from '../storage/streamRange';
-import { type MediaStore, privateHlsFileKey, privateSourceKey } from '../storage/types';
-import { cryptBlobRangeStream, cryptBlobStream, openMeta, unwrapContentKey } from './crypto';
-import type { PrivateIndex } from './index-store';
-import { toPublic } from './index-store';
-import type { UnlockPasswordPolicy, UnlockService } from './unlock';
-
-// Mounts the private-media routes. The unlock / index / reveal endpoints are session-guarded (a
-// fetch CAN send the app's Bearer). The byte routes under /u/<token>/ are UN-guarded (hls.js
-// can't send a Bearer) and authorized by the path-embedded unlock token instead — the same token
-// carries the sealed set key, so the content-key route can unwrap the item's AES-128 key. The
-// encrypted segments themselves are edge-cacheable ciphertext; only the tiny key is gated + no-store.
-
-/** Access-Control-Allow-Origin resolver for split-origin private streaming (media on another
- * origin than the SPA). Same shape as the storage layer's. */
-export type CorsResolver =
-  | string
-  | string[]
-  | ((requestOrigin: string | undefined) => string | null | undefined);
-
-function resolveAcao(cors: CorsResolver | undefined, reqOrigin: string | undefined): string | null {
-  if (!cors) return null;
-  if (typeof cors === 'string') return cors;
-  if (Array.isArray(cors)) return reqOrigin && cors.includes(reqOrigin) ? reqOrigin : null;
-  return cors(reqOrigin) ?? null;
-}
-
-export type MountPrivateOptions = {
-  store: MediaStore;
-  index: PrivateIndex;
-  unlock: UnlockService;
-  /** Path prefix (default '/_private'). */
-  basePath?: string;
-  /** App session auth → the caller's id + their per-user salt (created lazily, stable). Return
-   * null to reject. Gates unlock/index/reveal (the byte routes use the path token instead). */
-  authorize: (c: Context) => Promise<{ userId: string; userSalt: string } | null>;
-  /** What a supplied password means (default: derive — deniable sets). `gate` verifies it
-   * against the app's accounts and mints the recoverable server-key grant instead. */
-  passwordPolicy?: UnlockPasswordPolicy;
-  /** Cross-origin access for split-origin deploys. */
-  cors?: CorsResolver;
-};
-
-export function mountPrivateRoutes(app: Hono, opts: MountPrivateOptions): void {
-  const base = opts.basePath ?? '/_private';
-  const { store, index, unlock } = opts;
-  const cors = (c: Context, res: Response): Response => {
-    const acao = resolveAcao(opts.cors, c.req.header('origin'));
-    if (acao) {
-      res.headers.set('Access-Control-Allow-Origin', acao);
-      res.headers.set(
-        'Access-Control-Expose-Headers',
-        'Content-Range, Content-Length, Accept-Ranges',
-      );
-      res.headers.append('Vary', 'Origin');
-    }
-    return res;
-  };
-
-  const policy = opts.passwordPolicy ?? { mode: 'derive' as const };
-
-  /** Resolve what the supplied password contributes under the active policy:
-   * derive ⇒ it feeds key derivation (may be undefined ⇒ standard set);
-   * gate ⇒ it must be present AND verify against the app's accounts, then the
-   * set key is the recoverable server one (password never feeds derivation).
-   * Returns an error Response to short-circuit with, or the derivation input. */
-  const resolvePassword = async (
-    c: Context,
-    who: { userId: string; userSalt: string },
-    password: string | undefined,
-  ): Promise<{ derivePassword?: string } | { error: Response }> => {
-    if (policy.mode === 'derive') return { derivePassword: password };
-    if (!password) return { error: c.json({ error: 'password required' }, 401) };
-    if (!(await policy.verifyPassword(who, password))) {
-      return { error: c.json({ error: 'invalid password' }, 401) };
-    }
-    return {}; // verified — standard (server-key) set
-  };
-
-  // POST /unlock { password? } → a token sealing the set key (deniable w/ password, else
-  // standard; under the gate policy the password is verified and the set is always standard).
-  app.post(`${base}/unlock`, async (c) => {
-    const who = await opts.authorize(c);
-    if (!who) return c.json({ error: 'unauthorized' }, 401);
-    const body = (await c.req.json().catch(() => ({}))) as { password?: string };
-    const resolved = await resolvePassword(c, who, body.password || undefined);
-    if ('error' in resolved) return resolved.error;
-    const { token, mode } = await unlock.unlock({
-      userId: who.userId,
-      userSalt: who.userSalt,
-      password: resolved.derivePassword,
-    });
-    return c.json({ token, mode });
-  });
-
-  // GET /index → clear, non-sensitive rows only (size + createdAt + status). Never title/thumb/mode.
-  app.get(`${base}/index`, async (c) => {
-    const who = await opts.authorize(c);
-    if (!who) return c.json({ error: 'unauthorized' }, 401);
-    return c.json({ items: (await index.list(who.userId)).map(toPublic) });
-  });
-
-  // Decrypt every descriptor a set key opens, silently skipping the rest (decrypt-success IS the
-  // membership test — deniability). Shared by the password and token reveal routes.
-  const revealWithKey = async (userId: string, setKey: Buffer) => {
-    const revealed: Array<{ id: string; meta: unknown }> = [];
-    for (const item of await index.list(userId)) {
-      const meta = openMeta(setKey, item.sealedMeta);
-      if (meta !== null) revealed.push({ id: item.id, meta });
-    }
-    return revealed;
-  };
-
-  // POST /reveal { password } → which items that password unlocks (GCM decrypt-success), with
-  // their now-decrypted metadata. Others stay opaque. This is the "try a password" cleanup UX.
-  // Under the gate policy the password must verify first and the standard set is revealed.
-  app.post(`${base}/reveal`, async (c) => {
-    const who = await opts.authorize(c);
-    if (!who) return c.json({ error: 'unauthorized' }, 401);
-    const body = (await c.req.json().catch(() => ({}))) as { password?: string };
-    const resolved = await resolvePassword(c, who, body.password || undefined);
-    if ('error' in resolved) return resolved.error;
-    const setKey = unlock.deriveSetKey({
-      userId: who.userId,
-      userSalt: who.userSalt,
-      password: resolved.derivePassword,
-    });
-    return c.json({ items: await revealWithKey(who.userId, setKey) });
-  });
-
-  // POST /reveal-unlocked { token } → the same reveal, keyed by an UNLOCK TOKEN instead of the
-  // password (the token seals the set key — same mechanism the content-key route uses). Lets an
-  // already-unlocked session list its items without re-typing the password. The token must belong
-  // to the session caller.
-  app.post(`${base}/reveal-unlocked`, async (c) => {
-    const who = await opts.authorize(c);
-    if (!who) return c.json({ error: 'unauthorized' }, 401);
-    const body = (await c.req.json().catch(() => ({}))) as { token?: string };
-    if (!body.token) return c.json({ error: 'token required' }, 400);
-    const grant = await unlock.verify(body.token);
-    if (!grant || grant.userId !== who.userId) return c.json({ error: 'invalid token' }, 401);
-    return c.json({ items: await revealWithKey(who.userId, grant.setKey) });
-  });
-
-  // GET /u/:token/hls/:source/:video/* → the encrypted HLS tree. The `enc.key` sub-path returns
-  // the unwrapped AES-128 content key (gated, no-store); every other path serves the encrypted
-  // segment/playlist (edge-cacheable — hls.js decrypts with the key).
-  app.get(`${base}/u/:token/hls/:source/:video/*`, async (c) => {
-    const raw = c.req.param('token');
-    if (!raw) return c.body(null, 401);
-    const grant = await unlock.verify(raw);
-    if (!grant) return c.body(null, 401);
-    const video = c.req.param('video');
-    const prefix = `${base}/u/${raw}/hls/${c.req.param('source')}/${video}/`;
-    const rel = c.req.path.slice(prefix.length);
-    if (!rel || rel.includes('..')) return c.body(null, 400);
-
-    if (rel.endsWith('enc.key')) {
-      const item = await index.get(grant.userId, video);
-      if (!item) return c.body(null, 404);
-      const content = unwrapContentKey(grant.setKey, item.wrappedContentKey);
-      // null ⇒ this token's set key doesn't own the item (wrong password / wrong mode).
-      if (!content) return c.body(null, 403);
-      // A fresh, tightly-sized ArrayBuffer copy of the 16-byte key — an unambiguous BodyInit
-      // (wrapping the Node Buffer directly can mis-size the response).
-      const keyBytes = Uint8Array.from(content.key);
-      return cors(
-        c,
-        new Response(keyBytes.buffer, {
-          status: 200,
-          headers: { 'Content-Type': 'application/octet-stream', 'Cache-Control': 'no-store' },
-        }),
-      );
-    }
-
-    const mime = rel.endsWith('.m3u8') ? 'application/vnd.apple.mpegurl' : 'video/mp2t';
-    return cors(
-      c,
-      await serveRange(
-        store,
-        privateHlsFileKey(grant.userId, video, rel),
-        mime,
-        c.req.header('range'),
-      ),
-    );
-  });
-
-  // GET /u/:token/file/:id → a private file stored as one AES-128-CTR ciphertext blob at
-  // privateSourceKey. Decrypted server-side per request under the token's set key; the mime
-  // comes from the sealed descriptor, so a token whose set key can't open the item (wrong
-  // password / wrong mode) gets a 403 and never any bytes.
-  //
-  // RANGE SUPPORT (genapp-100): CTR is positionally keyed, so a byte range decrypts from the
-  // block-aligned ciphertext offset with the IV counter advanced (`cryptBlobRangeStream`). This
-  // is what makes a big private VIDEO scrub on a remote-store host, where no local ffmpeg means
-  // no HLS derivatives and the blob route is the only byte path. Plaintext is never stored.
-  app.get(`${base}/u/:token/file/:id`, async (c) => {
-    const raw = c.req.param('token');
-    if (!raw) return c.body(null, 401);
-    const grant = await unlock.verify(raw);
-    if (!grant) return c.body(null, 401);
-    const id = c.req.param('id');
-    const item = await index.get(grant.userId, id);
-    if (!item) return c.body(null, 404);
-    const content = unwrapContentKey(grant.setKey, item.wrappedContentKey);
-    if (!content) return c.body(null, 403);
-    const meta = openMeta<{ mime?: string }>(grant.setKey, item.sealedMeta);
-    const baseHeaders: Record<string, string> = {
-      'Content-Type': meta?.mime || 'application/octet-stream',
-      'Cache-Control': 'no-store',
-      'Accept-Ranges': 'bytes',
-    };
-
-    const key = privateSourceKey(grant.userId, id);
-    const range = item.sizeBytes > 0 ? decodeRange(c.req.header('range'), item.sizeBytes) : { kind: 'full' as const };
-    if (range.kind === 'unsatisfiable') {
-      return cors(
-        c,
-        new Response(null, { status: 416, headers: { 'Content-Range': `bytes */${item.sizeBytes}` } }),
-      );
-    }
-    if (range.kind === 'partial') {
-      // Fetch ciphertext from the BLOCK-ALIGNED start (CTR block = 16 bytes); the range
-      // stream drops the intra-block lead-in so the client sees exactly [start, end].
-      const alignedStart = range.start - (range.start % 16);
-      const stored = await store.getRange(key, { start: alignedStart, end: range.end });
-      if (!stored) return c.body(null, 404);
-      return cors(
-        c,
-        new Response(cryptBlobRangeStream(content, stored.stream, range.start), {
-          status: 206,
-          headers: {
-            ...baseHeaders,
-            'Content-Range': `bytes ${range.start}-${range.end}/${item.sizeBytes}`,
-            'Content-Length': String(range.end - range.start + 1),
-          },
-        }),
-      );
-    }
-
-    const stored = await store.getRange(key);
-    if (!stored) return c.body(null, 404);
-    const headers = { ...baseHeaders };
-    if (item.sizeBytes > 0) headers['Content-Length'] = String(item.sizeBytes);
-    return cors(c, new Response(cryptBlobStream(content, stored.stream), { status: 200, headers }));
-  });
-
-  // Preflight for the cross-origin byte routes.
-  if (opts.cors) {
-    app.options(`${base}/u/*`, (c) => {
-      const acao = resolveAcao(opts.cors, c.req.header('origin'));
-      const headers: Record<string, string> = {
-        'Access-Control-Allow-Methods': 'GET, OPTIONS',
-        'Access-Control-Allow-Headers': 'Range',
-        'Access-Control-Max-Age': '86400',
-      };
-      if (acao) {
-        headers['Access-Control-Allow-Origin'] = acao;
-        headers.Vary = 'Origin';
-      }
-      return c.body(null, 204, headers);
-    });
-  }
-}

package/src/server/private-media/pipeline.spec.ts

@@ -1,111 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { createDecipheriv } from 'node:crypto';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { isFfmpegAvailable } from '../media-bun';
-import { createDiskStore } from '../storage/diskStore';
-import { privateHlsFileKey, privateHlsMasterKey } from '../storage/types';
-import { deriveServerSetKey, unwrapContentKey } from './crypto';
-import { processPrivateVideo } from './pipeline';
-
-// Integration test — needs ffmpeg on PATH. When absent (CI image without it) the tests no-op so
-// the suite still passes; the pipeline itself returns 'failed' when ffmpeg is missing (private
-// media can't degrade to plaintext), which is the intended behavior.
-describe('processPrivateVideo (encrypted HLS)', () => {
-  let root: string;
-  let work: string;
-  let clip: string;
-  let hasFfmpeg = false;
-
-  beforeAll(async () => {
-    hasFfmpeg = await isFfmpegAvailable();
-    root = await mkdtemp(path.join(tmpdir(), 'pm-store-'));
-    work = await mkdtemp(path.join(tmpdir(), 'pm-work-'));
-    if (!hasFfmpeg) return;
-    clip = path.join(work, 'src.mp4');
-    const proc = Bun.spawn(
-      [
-        'ffmpeg',
-        '-y',
-        '-f',
-        'lavfi',
-        '-i',
-        'testsrc=size=854x480:rate=15:duration=3',
-        '-pix_fmt',
-        'yuv420p',
-        '-c:v',
-        'libx264',
-        '-preset',
-        'ultrafast',
-        '-t',
-        '3',
-        clip,
-      ],
-      { stdout: 'ignore', stderr: 'ignore' },
-    );
-    await proc.exited;
-  });
-  afterAll(async () => {
-    await rm(root, { recursive: true, force: true });
-    await rm(work, { recursive: true, force: true });
-  });
-
-  test('encrypts HLS segments; the wrapped key unwraps and decrypts a segment to valid MPEG-TS', async () => {
-    if (!hasFfmpeg) {
-      console.warn('[pipeline.spec] ffmpeg absent — skipping encrypted-HLS integration test');
-      return;
-    }
-    const store = createDiskStore(root);
-    const setKey = deriveServerSetKey('server-secret', 'user-1');
-
-    const res = await processPrivateVideo({
-      store,
-      workDir: work,
-      owner: 't1',
-      id: 'v1',
-      sourcePath: clip,
-      setKey,
-    });
-
-    expect(res.status).toBe('ready');
-    expect(res.hasHls).toBe(true);
-    expect(res.wrappedContentKey).not.toBeNull();
-
-    // The master + a 480p variant playlist exist, and the playlist declares AES-128 encryption.
-    expect(await store.stat(privateHlsMasterKey('t1', 'v1'))).not.toBeNull();
-    const playlistBytes = await store.get(privateHlsFileKey('t1', 'v1', '480/playlist.m3u8'));
-    expect(playlistBytes).not.toBeNull();
-    const playlist = new TextDecoder().decode(playlistBytes as Uint8Array);
-    expect(playlist).toContain('#EXT-X-KEY:METHOD=AES-128');
-    expect(playlist).toContain('URI="enc.key"');
-
-    // The raw content key never leaves wrapped — but unwrapping with the set key recovers it,
-    // and it correctly AES-128-CBC-decrypts a real segment back to an MPEG-TS stream (0x47 sync).
-    const content = unwrapContentKey(setKey, res.wrappedContentKey as string);
-    expect(content).not.toBeNull();
-    expect(content?.key.length).toBe(16);
-
-    const seg = await store.get(privateHlsFileKey('t1', 'v1', '480/seg_00000.ts'));
-    expect(seg).not.toBeNull();
-    const d = createDecipheriv('aes-128-cbc', content?.key as Buffer, content?.iv as Buffer);
-    const plain = Buffer.concat([d.update(Buffer.from(seg as Uint8Array)), d.final()]);
-    expect(plain[0]).toBe(0x47); // MPEG-TS sync byte ⇒ decryption + key are correct
-  }, 30_000);
-
-  test('returns failed when ffmpeg is unavailable (private media cannot go plaintext)', async () => {
-    // Documents the contract; only meaningfully exercised on a machine without ffmpeg.
-    if (hasFfmpeg) return;
-    const store = createDiskStore(root);
-    const res = await processPrivateVideo({
-      store,
-      workDir: work,
-      owner: 't',
-      id: 'v',
-      sourcePath: '/nonexistent',
-      setKey: deriveServerSetKey('s', 'u'),
-    });
-    expect(res.status).toBe('failed');
-    expect(res.wrappedContentKey).toBeNull();
-  });
-});