import {
type DpopVerificationFailureCode as DpopVerificationFailureCodeType,
verifyDpopProof,
} from "@t3tools/shared/dpop";
import type { DpopFailureReason } from "@t3tools/contracts";
import * as Digest from "effect/crypto/Digest";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Base64Url from "effect/encoding/Base64Url";
import * as Option from "effect/Option";
import * as HttpServerRequest from "effect/http/HttpServerRequest";
import {
ServerAuthDpopReplayKeyCalculationError,
ServerAuthDpopReplayStateRecordError,
ServerAuthInvalidCredentialError,
type ServerAuthInternalError,
} from "./EnvironmentAuth.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
import { requestUrl } from "../requestUrl.ts";
export const DPOP_REPLAY_MARKER_PREFIX = "dpop-proof-";
const mapDpopFailureReason = (code: DpopVerificationFailureCodeType): DpopFailureReason => {
switch (code) {
case "time_window":
return "time_window";
case "key_mismatch":
return "key_mismatch";
case "method_mismatch":
case "url_mismatch":
return "request_mismatch";
case "access_token_hash_mismatch":
return "token_mismatch";
case "missing_proof":
case "malformed_proof":
case "invalid_signature":
case "invalid_proof":
return "invalid_proof";
}
};
export const mapDpopReplayStoreError = (
error: ServerSecretStore.SecretStoreError,
): ServerAuthInvalidCredentialError | ServerAuthInternalError =>
ServerSecretStore.isSecretAlreadyExistsError(error)
? new ServerAuthInvalidCredentialError({
diagnostic: "DPoP proof replayed.",
dpopFailureReason: "replay",
cause: error,
})
: new ServerAuthDpopReplayStateRecordError({
cause: error,
});
export const verifyRequestDpopProof = Effect.fn("dpop.verifyRequestDpopProof")(function* (input: {
readonly request: HttpServerRequest.HttpServerRequest;
/** Overrides the `DPoP` header for requests that cannot carry one, such as a WebSocket upgrade. */
readonly proof?: string;
readonly expectedThumbprint?: string;
readonly expectedAccessToken?: string;
}) {
const proof = input.proof ?? input.request.headers.dpop;
const url = requestUrl(input.request);
if (Option.isNone(url)) {
return yield* new ServerAuthInvalidCredentialError({
diagnostic: "Invalid DPoP request URL.",
});
}
const now = yield* DateTime.now;
const result = verifyDpopProof({
proof,
method: input.request.method,
url: url.value.href,
nowEpochSeconds: Math.floor(now.epochMilliseconds / 1_000),
...(input.expectedThumbprint ? { expectedThumbprint: input.expectedThumbprint } : {}),
...(input.expectedAccessToken ? { expectedAccessToken: input.expectedAccessToken } : {}),
});
if (!result.ok) {
yield* Effect.annotateCurrentSpan({
"environment.dpop.failure_code": result.code,
});
return yield* new ServerAuthInvalidCredentialError({
diagnostic: result.reason,
dpopFailureReason: mapDpopFailureReason(result.code),
});
}
const secretStore = yield* ServerSecretStore.ServerSecretStore;
const replayKey = yield* Digest.Digest.pipe(
Effect.flatMap((digest) =>
digest.digest(Digest.sha256, new TextEncoder().encode(`${result.thumbprint}:${result.jti}`)),
),
Effect.map(Base64Url.encode),
Effect.mapError(
(cause) =>
new ServerAuthDpopReplayKeyCalculationError({
cause,
}),
),
);
yield* secretStore
.create(
`${DPOP_REPLAY_MARKER_PREFIX}${replayKey}`,
new TextEncoder().encode(
[
`thumbprint=${result.thumbprint}`,
`jti=${result.jti}`,
`iat=${result.iat}`,
`consumedAt=${DateTime.formatIso(now)}`,
].join("\n"),
),
)
.pipe(
Effect.catchIf(ServerSecretStore.isSecretStoreError, (error) =>
Effect.gen(function* () {
const mapped = mapDpopReplayStoreError(error);
if (mapped._tag === "ServerAuthInvalidCredentialError") {
yield* Effect.annotateCurrentSpan({
"environment.dpop.failure_code": mapped.dpopFailureReason,
});
}
return yield* mapped;
}),
),
);
return result.thumbprint;
});