mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-17 15:42:24 +00:00
An account created through OIDC holds no password, passkey or second factor, so the recent-proof gate in front of token minting, MCP connections, exports and the admin reset had nothing to ask it for and the web could only say "sign in again" (#1296). GET /api/auth/oidc/reproof sends the browser back to the configured provider with prompt=login and max_age=0, its own state, nonce and PKCE verifier, and the signed-in account and session sealed into the state cookie. The shared callback branches on that intent: it refuses unless the browser still carries the bound session (checked before the code is redeemed), the ID token names the account's linked issuer and subject, and auth_time lies inside the gate's five-minute window. It then stamps Session.reproofAt exactly as a password re-proof does, creates no session, and returns to the page it left with ?reproof=done|failed. recentProofMethods offers "oidc" only to an account without a second factor whose identity is linked while a provider is configured, and the fresh-factor gate never lists it. GET /api/auth/me/mfa publishes the list as proofMethods, so the passkey card offers what the account can actually give, and register-options takes { method: "oidc" } on a fresh provider re-proof, so such an account can add a passkey as a second way to confirm. Both re-proof dialogs offer the provider and a toast reports the outcome on return. The callback's missing-state branch and the passkey card's enrollment flow move into their own functions to keep both handlers under the size ratchet.
119 lines
3.7 KiB
TypeScript
119 lines
3.7 KiB
TypeScript
import { randomBytes } from "node:crypto";
|
|
import { NextRequest, NextResponse } from "next/server";
|
|
import { apiHandler, requireCookieAuth } from "@/lib/api-handler";
|
|
import { getClientIp } from "@/lib/api-response";
|
|
import { annotate, getEvent } from "@/lib/logging/context";
|
|
import { encrypt } from "@/lib/crypto";
|
|
import { shouldEmitSecureCookie } from "@/lib/auth/secure-cookie";
|
|
import { s256Challenge } from "@/lib/mcp/oauth/pkce";
|
|
import { recentProofMethods } from "@/lib/auth/second-factor";
|
|
import { throttleReproof } from "@/lib/auth/existing-factor-proof";
|
|
import {
|
|
buildAuthorizationUrl,
|
|
discoverOidcMetadata,
|
|
getOidcConfig,
|
|
getOidcRedirectUri,
|
|
sanitizeOidcNextPath,
|
|
} from "@/lib/auth/oidc";
|
|
import {
|
|
OIDC_STATE_COOKIE,
|
|
OIDC_STATE_COOKIE_PATH,
|
|
OIDC_STATE_TTL_MS,
|
|
} from "@/lib/auth/oidc-cookie";
|
|
import { OIDC_REPROOF_STAGE, reproofReturnUrl } from "@/lib/auth/oidc-reproof";
|
|
|
|
export const dynamic = "force-dynamic";
|
|
|
|
/**
|
|
* Start confirming it is you at the identity provider (#1296).
|
|
*
|
|
* A top-level navigation from the re-proof dialog, cookie session only: a
|
|
* Bearer token never re-proves this way, because a stamp on a session row
|
|
* means nothing to a token (`requireCookieAuth` reads the session cookie and
|
|
* nothing else). Offered only where `recentProofMethods` lists `oidc`, which
|
|
* is an account without a second factor whose identity is linked while a
|
|
* provider is configured; anything else goes straight back with
|
|
* `reproof=failed`.
|
|
*
|
|
* The round trip asks for a fresh authentication (`prompt=login`,
|
|
* `max_age=0`) with its own state, nonce and PKCE verifier, sealed into the
|
|
* same single-use cookie the sign-in uses, together with the account and the
|
|
* session it confirms. The callback stamps that session's `reproofAt` and
|
|
* returns to `next` (a same-origin path) with `reproof=done`. It never mints
|
|
* a session.
|
|
*
|
|
* Draws on the account's shared re-proof budget, like every other proof.
|
|
*/
|
|
export const GET = apiHandler(async (req: NextRequest) => {
|
|
annotate({ action: { name: "auth.oidc.reproof.start" } });
|
|
const { user, session } = await requireCookieAuth();
|
|
|
|
const next = sanitizeOidcNextPath(
|
|
req.nextUrl.searchParams.get("next"),
|
|
req.url,
|
|
);
|
|
const back = (reason: string): NextResponse => {
|
|
annotate({ meta: { reason } });
|
|
return NextResponse.redirect(reproofReturnUrl(next, "failed"));
|
|
};
|
|
|
|
const config = getOidcConfig();
|
|
if (!config) return back("oidc_disabled");
|
|
|
|
const methods = await recentProofMethods(user);
|
|
if (!methods.includes("oidc")) return back("not_offered");
|
|
|
|
const limited = await throttleReproof(
|
|
user.id,
|
|
getClientIp(req),
|
|
OIDC_REPROOF_STAGE,
|
|
);
|
|
if (limited) return back("rate_limited");
|
|
|
|
let metadata;
|
|
try {
|
|
metadata = await discoverOidcMetadata(config);
|
|
} catch (err) {
|
|
getEvent()?.setError(err);
|
|
return back("oidc_failed");
|
|
}
|
|
|
|
const state = randomBytes(32).toString("base64url");
|
|
const nonce = randomBytes(32).toString("base64url");
|
|
const codeVerifier = randomBytes(64).toString("base64url");
|
|
|
|
const response = NextResponse.redirect(
|
|
buildAuthorizationUrl({
|
|
metadata,
|
|
config,
|
|
state,
|
|
nonce,
|
|
codeChallenge: s256Challenge(codeVerifier),
|
|
redirectUri: getOidcRedirectUri(),
|
|
reauthenticate: true,
|
|
}),
|
|
);
|
|
response.cookies.set(
|
|
OIDC_STATE_COOKIE,
|
|
encrypt(
|
|
JSON.stringify({
|
|
state,
|
|
nonce,
|
|
codeVerifier,
|
|
next,
|
|
intent: "reproof" as const,
|
|
reproofUserId: user.id,
|
|
reproofSessionId: session.id,
|
|
}),
|
|
),
|
|
{
|
|
httpOnly: true,
|
|
secure: shouldEmitSecureCookie(),
|
|
sameSite: "lax",
|
|
maxAge: Math.floor(OIDC_STATE_TTL_MS / 1000),
|
|
path: OIDC_STATE_COOKIE_PATH,
|
|
},
|
|
);
|
|
return response;
|
|
});
|