'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)}
` : ''}
`);
}
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;