// @effect-diagnostics-next-line nodeBuiltinImport:off -- Effect's Crypto has no generateKeyPairSync or sign.
import * as NodeCrypto from "node:crypto";
import { describe, expect, it } from "@effect/vitest";
import {
computeDpopAccessTokenHash,
computeDpopJwkThumbprint,
type DpopPublicJwk,
} from "@t3tools/shared/dpop";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as RelayDb from "../db.ts";
import { relayDpopProofs } from "../persistence/schema.ts";
import * as DpopProofs from "./DpopProofs.ts";
interface DpopProofInsertValues {
readonly thumbprint: string;
readonly jti: string;
readonly iat: number;
readonly expiresAt: string;
readonly createdAt: string;
}
function makeDpopProof(input: {
readonly method: string;
readonly url: string;
readonly iat: number;
readonly jti: string;
readonly accessToken?: string;
}) {
const { privateKey, publicKey } = NodeCrypto.generateKeyPairSync("ec", {
namedCurve: "P-256",
});
const publicJwk = publicKey.export({ format: "jwk" }) as DpopPublicJwk;
const header = Buffer.from(
JSON.stringify({
typ: "dpop+jwt",
alg: "ES256",
jwk: publicJwk,
}),
).toString("base64url");
const payload = Buffer.from(
JSON.stringify({
htm: input.method,
htu: input.url,
jti: input.jti,
iat: input.iat,
...(input.accessToken ? { ath: computeDpopAccessTokenHash(input.accessToken) } : {}),
}),
).toString("base64url");
const signature = NodeCrypto.sign("sha256", Buffer.from(`${header}.${payload}`), {
key: privateKey,
dsaEncoding: "ieee-p1363",
}).toString("base64url");
return {
proof: `${header}.${payload}.${signature}`,
thumbprint: computeDpopJwkThumbprint(publicJwk),
};
}
function layer(
insert: (
values: DpopProofInsertValues,
) => Effect.Effect<ReadonlyArray<{ readonly jti: string }>, { _tag: string }>,
) {
const fakeDb = {
insert: (table: unknown) => {
expect(table).toBe(relayDpopProofs);
return {
values: (values: DpopProofInsertValues) => ({
onConflictDoNothing: () => ({
returning: () => {
return insert(values);
},
}),
}),
};
},
} as unknown as RelayDb.RelayDb["Service"];
return DpopProofs.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)));
}
function consumeEachProofOnce() {
const consumed = new Map<string, string>();
return {
insert: (values: DpopProofInsertValues) =>
Effect.sync(() => {
const key = `${values.thumbprint}:${values.jti}`;
if (consumed.has(key)) {
return [];
}
consumed.set(key, values.expiresAt);
return [{ jti: values.jti }];
}),
pruneExpired: (now: DateTime.DateTime) => {
const cutoff = DateTime.formatIso(now);
for (const [key, expiresAt] of consumed) {
if (expiresAt < cutoff) {
consumed.delete(key);
}
}
},
};
}
describe("DpopProofReplay.verifyAndConsume", () => {
it.effect("reports a signed proof outside the time window", () => {
const now = DateTime.makeUnsafe("2026-05-25T12:00:00.000Z");
const proof = makeDpopProof({
method: "POST",
url: "https://relay.example.com/v1/environments/env/connect",
iat: Math.floor(now.epochMilliseconds / 1_000) - 301,
jti: "proof-old",
});
return Effect.gen(function* () {
const replay = yield* DpopProofs.DpopProofReplay;
const error = yield* Effect.flip(
replay.verifyAndConsume({
proof: proof.proof,
method: "POST",
url: "https://relay.example.com/v1/environments/env/connect",
expectedThumbprint: proof.thumbprint,
now,
}),
);
expect(error).toMatchObject({
_tag: "DpopProofRejected",
code: "time_window",
});
}).pipe(Effect.provide(layer(() => Effect.die("unexpected replay persistence"))));
});
it.effect("rejects replays until a future proof's time window closes", () => {
const now = DateTime.makeUnsafe("2026-05-25T12:00:00.000Z");
const proof = makeDpopProof({
method: "POST",
url: "https://relay.example.com/v1/environments/env/connect",
iat: Math.floor(now.epochMilliseconds / 1_000) + 300,
jti: "proof-future",
});
const persistence = consumeEachProofOnce();
const input = {
proof: proof.proof,
method: "POST",
url: "https://relay.example.com/v1/environments/env/connect",
expectedThumbprint: proof.thumbprint,
now,
};
return Effect.gen(function* () {
const replay = yield* DpopProofs.DpopProofReplay;
expect(yield* replay.verifyAndConsume(input)).toBe(proof.thumbprint);
for (const { elapsedMs, code } of [
{ elapsedMs: 0, code: "replayed" },
{ elapsedMs: 301_000, code: "replayed" },
{ elapsedMs: 600_999, code: "replayed" },
{ elapsedMs: 601_000, code: "time_window" },
]) {
const retryAt = DateTime.makeUnsafe(now.epochMilliseconds + elapsedMs);
persistence.pruneExpired(retryAt);
const result = yield* Effect.result(replay.verifyAndConsume({ ...input, now: retryAt }));
expect(result, `Replay after ${elapsedMs}ms`).toMatchObject({
_tag: "Failure",
failure: { _tag: "DpopProofRejected", code },
});
}
}).pipe(Effect.provide(layer(persistence.insert)));
});
it.effect("rejects proofs missing the expected access token hash", () => {
const now = DateTime.makeUnsafe("2026-05-25T12:00:00.000Z");
const proof = makeDpopProof({
method: "POST",
url: "https://relay.example.com/v1/environments/env/connect",
iat: Math.floor(now.epochMilliseconds / 1_000),
jti: "proof-1",
});
return Effect.gen(function* () {
const replay = yield* DpopProofs.DpopProofReplay;
const error = yield* Effect.flip(
replay.verifyAndConsume({
proof: proof.proof,
method: "POST",
url: "https://relay.example.com/v1/environments/env/connect",
expectedThumbprint: proof.thumbprint,
expectedAccessToken: "clerk-access-token",
now,
}),
);
expect(error).toMatchObject({
_tag: "DpopProofRejected",
code: "access_token_hash_mismatch",
});
}).pipe(Effect.provide(layer(() => Effect.die("unexpected DPoP replay persistence"))));
});
it.effect("accepts proofs bound to the access token hash", () => {
const now = DateTime.makeUnsafe("2026-05-25T12:00:00.000Z");
const proof = makeDpopProof({
method: "POST",
url: "https://relay.example.com/v1/environments/env/status",
iat: Math.floor(now.epochMilliseconds / 1_000),
jti: "proof-status-1",
accessToken: "clerk-access-token",
});
return Effect.gen(function* () {
const replay = yield* DpopProofs.DpopProofReplay;
const thumbprint = yield* replay.verifyAndConsume({
proof: proof.proof,
method: "POST",
url: "https://relay.example.com/v1/environments/env/status",
expectedAccessToken: "clerk-access-token",
now,
});
const second = yield* Effect.exit(
replay.verifyAndConsume({
proof: proof.proof,
method: "POST",
url: "https://relay.example.com/v1/environments/env/status",
expectedAccessToken: "clerk-access-token",
now,
}),
);
expect(thumbprint).toBe(proof.thumbprint);
expect(second._tag).toBe("Failure");
}).pipe(Effect.provide(layer(consumeEachProofOnce().insert)));
});
});