Files
accounted/app/api/mcp-oauth/token/route.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

310 lines
11 KiB
TypeScript

import { NextResponse } from 'next/server'
import { decryptAuthCode, verifyPkce, hashAuthCode } from '@/lib/auth/oauth-codes'
import {
generateApiKey,
OAUTH_MCP_KEY_NAME,
generateRefreshToken,
hashRefreshToken,
createServiceClientNoCookies,
validateScopes,
findStageApproveConflict,
DEFAULT_OAUTH_SCOPES,
type ApiKeyScope,
} from '@/lib/auth/api-keys'
import { capScopesForRole, lookupCompanyRole } from '@/lib/auth/oauth-allowlist'
import { getActiveCompanyId } from '@/lib/company/context'
const ACCESS_TOKEN_TTL_SECONDS = 3600
// Grace window (seconds) during which a just-superseded access token and refresh
// token stay valid after a rotation. Lets a client that cannot reliably persist
// the rotated refresh token, or that fires concurrent refreshes: recover via
// idempotent replay instead of being forced into a re-auth loop (issue #710).
// Reuse of a previous refresh token AFTER this window revokes the grant.
const REFRESH_GRACE_SECONDS = 120
/**
* OAuth 2.0 Token Endpoint.
*
* Supports two grant types:
* - authorization_code: exchange a PKCE-protected auth code for a fresh
* api_key (access_token) plus a refresh_token.
* - refresh_token: rotate the refresh_token and return the same api_key
* with a fresh expires_in. The api_key itself does not expire
* server-side; expires_in is a hint so clients refresh on a cadence.
*/
export async function POST(request: Request) {
let params: URLSearchParams
const contentType = request.headers.get('content-type') || ''
if (contentType.includes('application/x-www-form-urlencoded')) {
const text = await request.text()
params = new URLSearchParams(text)
} else if (contentType.includes('application/json')) {
const json = await request.json()
params = new URLSearchParams(json as Record<string, string>)
} else {
return NextResponse.json({ error: 'unsupported_content_type' }, { status: 400 })
}
const grantType = params.get('grant_type')
if (grantType === 'authorization_code') {
return handleAuthorizationCodeGrant(params)
}
if (grantType === 'refresh_token') {
return handleRefreshTokenGrant(params)
}
return NextResponse.json(
{
error: 'unsupported_grant_type',
error_description: 'Only authorization_code and refresh_token are supported',
},
{ status: 400 }
)
}
async function handleAuthorizationCodeGrant(params: URLSearchParams) {
const code = params.get('code')
const codeVerifier = params.get('code_verifier')
const redirectUri = params.get('redirect_uri')
if (!code) {
return NextResponse.json(
{ error: 'invalid_request', error_description: 'Missing code parameter' },
{ status: 400 }
)
}
const payload = decryptAuthCode(code)
if (!payload) {
return NextResponse.json(
{ error: 'invalid_grant', error_description: 'Invalid or expired authorization code' },
{ status: 400 }
)
}
if (redirectUri && redirectUri !== payload.redirectUri) {
return NextResponse.json(
{ error: 'invalid_grant', error_description: 'redirect_uri mismatch' },
{ status: 400 }
)
}
if (!codeVerifier) {
return NextResponse.json(
{ error: 'invalid_request', error_description: 'code_verifier is required' },
{ status: 400 }
)
}
if (!verifyPkce(codeVerifier, payload.codeChallenge)) {
return NextResponse.json(
{ error: 'invalid_grant', error_description: 'PKCE verification failed' },
{ status: 400 }
)
}
const codeHash = hashAuthCode(code)
const supabase = createServiceClientNoCookies()
const { error: replayError } = await supabase
.from('oauth_used_codes')
.insert({ code_hash: codeHash })
if (replayError) {
return NextResponse.json(
{ error: 'invalid_grant', error_description: 'Authorization code already used' },
{ status: 400 }
)
}
// Clean up expired codes (non-blocking, best-effort)
supabase
.from('oauth_used_codes')
.delete()
.lt('created_at', new Date(Date.now() - 10 * 60 * 1000).toISOString())
.then(() => {})
// Bind the key to the company the consent page showed (carried in the code
// payload), so the role cap below is checked against the company the user
// actually consented for. Codes minted before the field existed, and
// companyless consents (signed up from the OAuth popup, issue #1814),
// resolve the active company here instead; null leaves the key unbound and
// validateApiKey binds it on the first call after a company exists.
const companyId =
typeof payload.companyId === 'string' && payload.companyId.length > 0
? payload.companyId
: await getActiveCompanyId(supabase, payload.userId)
const { key, hash, prefix } = generateApiKey()
const refresh = generateRefreshToken()
// Use the scopes the user consented to during /authorize. Re-validate
// every value against API_KEY_SCOPES even though /authorize already did:
// the auth code is AEAD-encrypted but we treat the boundary as
// hostile by default (V9.2.1, defense-in-depth).
let grantedScopes: ApiKeyScope[]
if (payload.scopes && Array.isArray(payload.scopes) && payload.scopes.length > 0) {
const revalidated = validateScopes(payload.scopes)
if (!revalidated) {
return NextResponse.json(
{ error: 'invalid_grant', error_description: 'Authorization code carried no valid scopes' },
{ status: 400 }
)
}
grantedScopes = revalidated
} else {
// Code minted with no scope (Claude's existing flow). Fall back to the
// read-only OAuth defaults: destructive scopes must be requested
// explicitly (GDPR Art. 25(2)).
grantedScopes = DEFAULT_OAUTH_SCOPES
}
// Re-apply the role cap /authorize computed, against the live membership:
// a viewer's key is read-only even if the code payload says otherwise, and
// a role demoted between consent and exchange is honoured. A failed lookup
// is a hard stop rather than a silent downgrade or widening.
if (companyId) {
const lookup = await lookupCompanyRole(supabase, payload.userId, companyId)
if (lookup.error) {
console.error('[mcp-oauth/token] role lookup failed', { message: lookup.error })
return NextResponse.json(
{ error: 'server_error', error_description: 'Failed to resolve company role' },
{ status: 500 }
)
}
const capped = capScopesForRole(grantedScopes, lookup.role)
grantedScopes = capped.length > 0 ? capped : capScopesForRole(DEFAULT_OAUTH_SCOPES, lookup.role)
}
// Segregation of duties, mirrored from app/api/settings/api-keys: a key
// that can both stage and approve is recorded as an acknowledged risk
// acceptance. The consent page states the rule above the Allow button, so
// the consent click is the self-attestation (ASVS V16.1.1 / SOC 2 CC6.1).
const conflictingScope = findStageApproveConflict(grantedScopes)
const sodAcknowledgedAt = conflictingScope ? new Date().toISOString() : null
const { error: insertError } = await supabase
.from('api_keys')
.insert({
user_id: payload.userId,
company_id: companyId,
key_hash: hash,
key_prefix: prefix,
name: OAUTH_MCP_KEY_NAME,
scopes: grantedScopes,
refresh_token_hash: refresh.hash,
// Literal keys (null when no conflict): the no-phantom-columns scanner
// resolves object literals only, never spreads.
sod_acknowledged_at: sodAcknowledgedAt,
sod_acknowledged_by: sodAcknowledgedAt ? payload.userId : null,
})
if (insertError) {
// This 500 was silent while api_keys.company_id was NOT NULL and every
// companyless signup died here (2026-08-26): always log the DB error.
console.error('[mcp-oauth/token] api key insert failed', {
code: insertError.code,
message: insertError.message,
companyless: companyId === null,
})
return NextResponse.json(
{ error: 'server_error', error_description: 'Failed to create API key' },
{ status: 500 }
)
}
if (conflictingScope) {
// High-risk security event, same shape the manual create route logs.
console.warn('[mcp-oauth/token] api_key.sod_acknowledged', {
keyPrefix: prefix,
conflictingScope,
scopes: grantedScopes,
acknowledgedBy: payload.userId,
companyId,
})
}
return NextResponse.json({
access_token: key,
token_type: 'Bearer',
expires_in: ACCESS_TOKEN_TTL_SECONDS,
refresh_token: refresh.token,
scope: grantedScopes.join(' '),
})
}
async function handleRefreshTokenGrant(params: URLSearchParams) {
const refreshToken = params.get('refresh_token')
if (!refreshToken) {
return NextResponse.json(
{ error: 'invalid_request', error_description: 'refresh_token is required' },
{ status: 400 }
)
}
const supabase = createServiceClientNoCookies()
const presentedHash = hashRefreshToken(refreshToken)
// Pre-generate the candidate credentials; the RPC decides whether to use them
// (rotate / idempotent replay) or ignore them (reuse / revoked / invalid).
// Doing lookup + rotate + demote in ONE SECURITY DEFINER RPC closes the
// TOCTOU gap the old SELECT-then-CAS had, and lets a just-superseded refresh
// token stay valid for a grace window so a client that cannot persist the
// rotated token, or fires concurrent refreshes: recovers instead of being
// forced into a re-auth loop (issue #710). Reuse AFTER the grace window
// revokes the grant (RFC 9700 §4.14.2 reuse detection).
const rotated = generateRefreshToken()
const { key: newKey, hash: newKeyHash, prefix: newKeyPrefix } = generateApiKey()
const { data, error } = await supabase.rpc('rotate_mcp_refresh_token', {
p_presented_hash: presentedHash,
p_new_refresh_hash: rotated.hash,
p_new_key_hash: newKeyHash,
p_new_key_prefix: newKeyPrefix,
p_grace_seconds: REFRESH_GRACE_SECONDS,
})
if (error) {
console.error('[mcp-oauth/token] refresh rotation failed', { code: error.code, message: error.message })
return NextResponse.json(
{ error: 'server_error', error_description: 'Failed to rotate refresh token' },
{ status: 500 }
)
}
const result = (Array.isArray(data) ? data[0] : data) as
| { outcome: string; scopes: string[] | null }
| undefined
const outcome = result?.outcome
// 'rotated' (normal) and 'replayed' (idempotent in-grace retry/concurrent)
// both succeed and return the freshly minted pair. Everything else maps to
// invalid_grant; for 'reuse_revoked' the grant was already revoked in the RPC.
if (outcome !== 'rotated' && outcome !== 'replayed') {
return NextResponse.json(
{
error: 'invalid_grant',
error_description:
outcome === 'revoked' ? 'Refresh token revoked' : 'Invalid or expired refresh token',
},
{ status: 400 }
)
}
// Carry the granular scopes the key was minted with (read-only OAuth defaults
// for legacy keys with null scopes) so clients don't re-authorize on refresh.
const persistedScopes = validateScopes(result?.scopes ?? null) ?? DEFAULT_OAUTH_SCOPES
return NextResponse.json({
access_token: newKey,
token_type: 'Bearer',
expires_in: ACCESS_TOKEN_TTL_SECONDS,
refresh_token: rotated.token,
scope: persistedScopes.join(' '),
})
}