'use strict'; // OAuth 2.0 authorization server for the public API. // Authorization code flow with mandatory PKCE (S256) for public clients // (mobile/desktop/sync services; no client secrets), refresh token rotation, // token revocation (RFC 7009) and server metadata (RFC 8414). const express = require('express'); const bcrypt = require('bcrypt'); const store = require('./store'); const { getDb } = require('../db'); const { getClientIp } = require('../auth'); const { publicBaseUrl, publicPathPrefix } = require('../public-url'); const router = express.Router(); const formParser = express.urlencoded({ extended: false, limit: '32kb' }); const jsonParser = express.json({ limit: '32kb' }); const LOGIN_FAIL_WINDOW_MS = 15 * 60 * 1000; const LOGIN_FAIL_MAX = 10; const loginFailures = new Map(); function issuer (req) { return publicBaseUrl(req); } function esc (v) { return String(v == null ? '' : v) .replace(/&/g, '&').replace(//g, '>') .replace(/"/g, '"').replace(/'/g, '''); } function noStore (res) { res.set('Cache-Control', 'no-store'); res.set('Pragma', 'no-cache'); } function pageHeaders (res) { noStore(res); res.set('X-Frame-Options', 'DENY'); res.set('Content-Security-Policy', "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'"); res.set('Referrer-Policy', 'no-referrer'); } function tooManyFailures (key) { const t = Date.now(); const list = (loginFailures.get(key) || []).filter((x) => t - x < LOGIN_FAIL_WINDOW_MS); loginFailures.set(key, list); return list.length >= LOGIN_FAIL_MAX; } function recordFailure (key) { const list = loginFailures.get(key) || []; list.push(Date.now()); loginFailures.set(key, list); if (loginFailures.size > 10000) loginFailures.clear(); } function resetLoginFailures () { loginFailures.clear(); } /** * Validates an authorization request. Returns { fatal } when we must NOT * redirect (unknown client or redirect URI), { redirectError } for errors * that go back to the client, or { request } when valid. */ function parseAuthorizeRequest (params) { const clientId = String(params.client_id || ''); const redirectUri = String(params.redirect_uri || ''); const client = store.getClient(clientId); if (!client || client.disabled) return { fatal: 'Unknown or disabled client_id.' }; if (!redirectUri || !store.redirectUriAllowed(client, redirectUri)) return { fatal: 'redirect_uri is not registered for this client.' }; const state = params.state != null ? String(params.state) : undefined; const fail = (error, description) => ({ redirectError: { redirectUri, error, description, state } }); if (params.response_type !== 'code') return fail('unsupported_response_type', 'Only response_type=code is supported.'); const challenge = String(params.code_challenge || ''); if (!challenge) return fail('invalid_request', 'PKCE code_challenge is required.'); if (params.code_challenge_method !== 'S256') return fail('invalid_request', 'code_challenge_method must be S256.'); if (!/^[A-Za-z0-9_-]{43}$/.test(challenge)) return fail('invalid_request', 'Malformed code_challenge.'); const scopes = store.normalizeScopes(params.scope || 'files:read'); if (!scopes || !scopes.length) return fail('invalid_scope', `Allowed scopes: ${store.SCOPES.join(' ')}`); const deviceName = String(params.device_name || '').trim().slice(0, 80) || client.name; return { request: { client, clientId, redirectUri, state, scopes, codeChallenge: challenge, deviceName } }; } function redirectWith (res, req, redirectUri, params) { const u = new URL(redirectUri); for (const [k, v] of Object.entries(params)) { if (v !== undefined && v !== null) u.searchParams.set(k, v); } u.searchParams.set('iss', issuer(req)); noStore(res); return res.redirect(302, u.toString()); } function renderError (res, status, message) { pageHeaders(res); res.status(status).type('html').send(`Authorization error

Authorization error

${esc(message)}

`); } function renderConsent (req, res, r, errorMessage, username) { pageHeaders(res); const hidden = { response_type: 'code', client_id: r.clientId, redirect_uri: r.redirectUri, scope: r.scopes.join(' '), state: r.state, code_challenge: r.codeChallenge, code_challenge_method: 'S256', device_name: r.deviceName, }; const hiddenHtml = Object.entries(hidden) .filter(([, v]) => v !== undefined) .map(([k, v]) => ``).join('\n'); const scopeHtml = r.scopes.map((s) => `
  • ${esc(s)}: ${esc(store.SCOPE_DESCRIPTIONS[s])}
  • `).join(''); let host = r.redirectUri; try { host = new URL(r.redirectUri).host || r.redirectUri; } catch { /* keep */ } res.status(errorMessage ? 401 : 200).type('html').send(` Allow access to your files?

    Allow ${esc(r.client.name)} to access your files?

    Device: ${esc(r.deviceName)}
    After approval you will be sent back to ${esc(host)}.

    This app asks for:

    The app can never see more than you can. You can revoke access at any time on the Connected apps page (${esc(publicBaseUrl(req))}/apps.html).

    ${errorMessage ? `

    ${esc(errorMessage)}

    ` : ''}
    ${hiddenHtml}
    `); } router.get('/.well-known/oauth-authorization-server', (req, res) => { const base = issuer(req); res.json({ issuer: base, authorization_endpoint: `${base}/oauth/authorize`, token_endpoint: `${base}/oauth/token`, revocation_endpoint: `${base}/oauth/revoke`, scopes_supported: store.SCOPES, response_types_supported: ['code'], grant_types_supported: ['authorization_code', 'refresh_token'], code_challenge_methods_supported: ['S256'], token_endpoint_auth_methods_supported: ['none'], authorization_response_iss_parameter_supported: true, service_documentation: `${base}/api/v1/openapi.json`, }); }); router.get('/oauth/authorize', (req, res) => { const parsed = parseAuthorizeRequest(req.query); if (parsed.fatal) return renderError(res, 400, parsed.fatal); if (parsed.redirectError) { const e = parsed.redirectError; return redirectWith(res, req, e.redirectUri, { error: e.error, error_description: e.description, state: e.state }); } return renderConsent(req, res, parsed.request, null, ''); }); router.post('/oauth/authorize', formParser, async (req, res, next) => { try { const body = req.body || {}; const parsed = parseAuthorizeRequest(body); if (parsed.fatal) return renderError(res, 400, parsed.fatal); if (parsed.redirectError) { const e = parsed.redirectError; return redirectWith(res, req, e.redirectUri, { error: e.error, error_description: e.description, state: e.state }); } const r = parsed.request; if (body.decision !== 'allow') { return redirectWith(res, req, r.redirectUri, { error: 'access_denied', error_description: 'The user denied access.', state: r.state }); } const username = String(body.username || '').trim(); const password = String(body.password || ''); const ip = getClientIp(req); const failKey = `${ip}|${username.toLowerCase()}`; if (tooManyFailures(failKey) || tooManyFailures(ip)) { return renderConsent(req, res, r, 'Too many failed attempts. Try again later.', username); } const row = username ? getDb().prepare('SELECT username, password_hash FROM users WHERE username = ?').get([username]) : null; const ok = row ? await bcrypt.compare(password, row.password_hash) : false; if (!ok) { recordFailure(failKey); recordFailure(ip); return renderConsent(req, res, r, 'Invalid username or password.', username); } const code = store.createAuthCode({ clientId: r.clientId, username: row.username, redirectUri: r.redirectUri, scopes: r.scopes, codeChallenge: r.codeChallenge, deviceName: r.deviceName, }); return redirectWith(res, req, r.redirectUri, { code, state: r.state }); } catch (err) { next(err); } }); function tokenError (res, status, error, description) { noStore(res); return res.status(status).json({ error, error_description: description }); } function cors (req, res, next) { res.set('Access-Control-Allow-Origin', '*'); res.set('Access-Control-Allow-Headers', 'Content-Type, Authorization'); res.set('Access-Control-Allow-Methods', 'POST, OPTIONS'); if (req.method === 'OPTIONS') return res.status(204).end(); next(); } router.options('/oauth/token', cors); router.options('/oauth/revoke', cors); router.post('/oauth/token', cors, formParser, jsonParser, (req, res) => { const body = req.body || {}; if (req.get('authorization')) return tokenError(res, 400, 'invalid_client', 'Clients are public; do not send client credentials.'); const clientId = String(body.client_id || ''); const client = store.getClient(clientId); if (!client || client.disabled) return tokenError(res, 401, 'invalid_client', 'Unknown client_id.'); if (body.grant_type === 'authorization_code') { const row = store.consumeAuthCode(String(body.code || '')); if (!row || row.client_id !== clientId) return tokenError(res, 400, 'invalid_grant', 'Invalid or expired code.'); if (String(body.redirect_uri || '') !== row.redirect_uri) return tokenError(res, 400, 'invalid_grant', 'redirect_uri mismatch.'); const verifier = String(body.code_verifier || ''); if (!/^[A-Za-z0-9._~-]{43,128}$/.test(verifier) || store.pkceS256(verifier) !== row.code_challenge) { return tokenError(res, 400, 'invalid_grant', 'PKCE verification failed.'); } if (!store.userExists(row.username)) return tokenError(res, 400, 'invalid_grant', 'User no longer exists.'); const scopes = row.scopes.split(' '); const grantId = store.createOAuthGrant({ username: row.username, clientId, name: row.device_name, scopes }); const t = store.issueTokensForGrant(grantId); noStore(res); return res.json({ access_token: t.accessToken, token_type: 'Bearer', expires_in: t.expiresIn, refresh_token: t.refreshToken, scope: scopes.join(' '), grant_id: grantId, }); } if (body.grant_type === 'refresh_token') { const result = store.refreshGrant(clientId, String(body.refresh_token || '')); if (result.error) return tokenError(res, 400, 'invalid_grant', 'Invalid, expired, reused or revoked refresh token.'); noStore(res); return res.json({ access_token: result.tokens.accessToken, token_type: 'Bearer', expires_in: result.tokens.expiresIn, refresh_token: result.tokens.refreshToken, scope: result.grant.scopes, grant_id: result.grant.id, }); } return tokenError(res, 400, 'unsupported_grant_type', 'Use authorization_code or refresh_token.'); }); router.post('/oauth/revoke', cors, formParser, jsonParser, (req, res) => { const token = String((req.body && req.body.token) || ''); if (token) store.revokeByToken(token); noStore(res); res.status(200).json({}); }); router.resetLoginFailures = resetLoginFailures; module.exports = router;