BlueGit

timfa filemanager

Files

filemanager / server / api / oauth.js

oauth.js

oauth.js 12.5 KiB Download Raw
1'use strict';
2
3// OAuth 2.0 authorization server for the public API.
4// Authorization code flow with mandatory PKCE (S256) for public clients
5// (mobile/desktop/sync services; no client secrets), refresh token rotation,
6// token revocation (RFC 7009) and server metadata (RFC 8414).
7
8const express = require('express');
9const bcrypt = require('bcrypt');
10const store = require('./store');
11const { getDb } = require('../db');
12const { getClientIp } = require('../auth');
13
14const router = express.Router();
15const formParser = express.urlencoded({ extended: false, limit: '32kb' });
16const jsonParser = express.json({ limit: '32kb' });
17
18const LOGIN_FAIL_WINDOW_MS = 15 * 60 * 1000;
19const LOGIN_FAIL_MAX = 10;
20const loginFailures = new Map();
21
22function issuer (req)
23{
24 return `${req.protocol}://${req.get('host')}`;
25}
26
27function esc (v)
28{
29 return String(v == null ? '' : v)
30 .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
31 .replace(/"/g, '&quot;').replace(/'/g, '&#39;');
32}
33
34function noStore (res)
35{
36 res.set('Cache-Control', 'no-store');
37 res.set('Pragma', 'no-cache');
38}
39
40function pageHeaders (res)
41{
42 noStore(res);
43 res.set('X-Frame-Options', 'DENY');
44 res.set('Content-Security-Policy', "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'");
45 res.set('Referrer-Policy', 'no-referrer');
46}
47
48function tooManyFailures (key)
49{
50 const t = Date.now();
51 const list = (loginFailures.get(key) || []).filter((x) => t - x < LOGIN_FAIL_WINDOW_MS);
52 loginFailures.set(key, list);
53 return list.length >= LOGIN_FAIL_MAX;
54}
55
56function recordFailure (key)
57{
58 const list = loginFailures.get(key) || [];
59 list.push(Date.now());
60 loginFailures.set(key, list);
61 if (loginFailures.size > 10000) loginFailures.clear();
62}
63
64function resetLoginFailures ()
65{
66 loginFailures.clear();
67}
68
69/**
70 * Validates an authorization request. Returns { fatal } when we must NOT
71 * redirect (unknown client or redirect URI), { redirectError } for errors
72 * that go back to the client, or { request } when valid.
73 */
74function parseAuthorizeRequest (params)
75{
76 const clientId = String(params.client_id || '');
77 const redirectUri = String(params.redirect_uri || '');
78 const client = store.getClient(clientId);
79 if (!client || client.disabled) return { fatal: 'Unknown or disabled client_id.' };
80 if (!redirectUri || !store.redirectUriAllowed(client, redirectUri)) return { fatal: 'redirect_uri is not registered for this client.' };
81
82 const state = params.state != null ? String(params.state) : undefined;
83 const fail = (error, description) => ({ redirectError: { redirectUri, error, description, state } });
84
85 if (params.response_type !== 'code') return fail('unsupported_response_type', 'Only response_type=code is supported.');
86 const challenge = String(params.code_challenge || '');
87 if (!challenge) return fail('invalid_request', 'PKCE code_challenge is required.');
88 if (params.code_challenge_method !== 'S256') return fail('invalid_request', 'code_challenge_method must be S256.');
89 if (!/^[A-Za-z0-9_-]{43}$/.test(challenge)) return fail('invalid_request', 'Malformed code_challenge.');
90 const scopes = store.normalizeScopes(params.scope || 'files:read');
91 if (!scopes || !scopes.length) return fail('invalid_scope', `Allowed scopes: ${store.SCOPES.join(' ')}`);
92 const deviceName = String(params.device_name || '').trim().slice(0, 80) || client.name;
93
94 return { request: { client, clientId, redirectUri, state, scopes, codeChallenge: challenge, deviceName } };
95}
96
97function redirectWith (res, req, redirectUri, params)
98{
99 const u = new URL(redirectUri);
100 for (const [k, v] of Object.entries(params))
101 {
102 if (v !== undefined && v !== null) u.searchParams.set(k, v);
103 }
104 u.searchParams.set('iss', issuer(req));
105 noStore(res);
106 return res.redirect(302, u.toString());
107}
108
109function renderError (res, status, message)
110{
111 pageHeaders(res);
112 res.status(status).type('html').send(`<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Authorization error</title></head>
113<body style="font-family:system-ui,sans-serif;max-width:32rem;margin:3rem auto;padding:0 1rem"><h1>Authorization error</h1><p>${esc(message)}</p></body></html>`);
114}
115
116function renderConsent (res, r, errorMessage, username)
117{
118 pageHeaders(res);
119 const hidden = {
120 response_type: 'code',
121 client_id: r.clientId,
122 redirect_uri: r.redirectUri,
123 scope: r.scopes.join(' '),
124 state: r.state,
125 code_challenge: r.codeChallenge,
126 code_challenge_method: 'S256',
127 device_name: r.deviceName,
128 };
129 const hiddenHtml = Object.entries(hidden)
130 .filter(([, v]) => v !== undefined)
131 .map(([k, v]) => `<input type="hidden" name="${esc(k)}" value="${esc(v)}">`).join('\n');
132 const scopeHtml = r.scopes.map((s) => `<li><strong>${esc(s)}</strong>: ${esc(store.SCOPE_DESCRIPTIONS[s])}</li>`).join('');
133 let host = r.redirectUri;
134 try { host = new URL(r.redirectUri).host || r.redirectUri; } catch { /* keep */ }
135 res.status(errorMessage ? 401 : 200).type('html').send(`<!doctype html>
136<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
137<title>Allow access to your files?</title>
138<style>
139body{font-family:system-ui,sans-serif;background:#f4f5f7;margin:0;padding:1rem}
140main{max-width:28rem;margin:2rem auto;background:#fff;border-radius:10px;padding:1.5rem;box-shadow:0 1px 4px #0002}
141label{display:block;margin:.6rem 0 .2rem}input[type=text],input[type=password]{width:100%;box-sizing:border-box;padding:.55rem;font-size:1rem}
142.err{background:#fdecea;color:#8a1c12;padding:.5rem .75rem;border-radius:6px}.btns{display:flex;gap:.5rem;margin-top:1rem}
143button{flex:1;padding:.65rem;font-size:1rem;border-radius:6px;border:1px solid #888;cursor:pointer}button.allow{background:#1f6feb;color:#fff;border-color:#1f6feb}
144small{color:#555}
145</style></head>
146<body><main>
147<h1 style="font-size:1.3rem">Allow <em>${esc(r.client.name)}</em> to access your files?</h1>
148<p>Device: <strong>${esc(r.deviceName)}</strong><br><small>After approval you will be sent back to ${esc(host)}.</small></p>
149<p>This app asks for:</p><ul>${scopeHtml}</ul>
150<p><small>The app can never see more than you can. You can revoke access at any time on the <em>Connected apps</em> page (/apps.html).</small></p>
151${errorMessage ? `<p class="err">${esc(errorMessage)}</p>` : ''}
152<form method="post" action="/oauth/authorize" autocomplete="on">
153${hiddenHtml}
154<label for="u">Username</label><input id="u" type="text" name="username" autocomplete="username" value="${esc(username || '')}">
155<label for="p">Password</label><input id="p" type="password" name="password" autocomplete="current-password">
156<div class="btns"><button type="submit" name="decision" value="deny">Deny</button><button class="allow" type="submit" name="decision" value="allow">Allow</button></div>
157</form></main></body></html>`);
158}
159
160router.get('/.well-known/oauth-authorization-server', (req, res) =>
161{
162 const base = issuer(req);
163 res.json({
164 issuer: base,
165 authorization_endpoint: `${base}/oauth/authorize`,
166 token_endpoint: `${base}/oauth/token`,
167 revocation_endpoint: `${base}/oauth/revoke`,
168 scopes_supported: store.SCOPES,
169 response_types_supported: ['code'],
170 grant_types_supported: ['authorization_code', 'refresh_token'],
171 code_challenge_methods_supported: ['S256'],
172 token_endpoint_auth_methods_supported: ['none'],
173 authorization_response_iss_parameter_supported: true,
174 service_documentation: `${base}/api/v1/openapi.json`,
175 });
176});
177
178router.get('/oauth/authorize', (req, res) =>
179{
180 const parsed = parseAuthorizeRequest(req.query);
181 if (parsed.fatal) return renderError(res, 400, parsed.fatal);
182 if (parsed.redirectError)
183 {
184 const e = parsed.redirectError;
185 return redirectWith(res, req, e.redirectUri, { error: e.error, error_description: e.description, state: e.state });
186 }
187 return renderConsent(res, parsed.request, null, '');
188});
189
190router.post('/oauth/authorize', formParser, async (req, res, next) =>
191{
192 try
193 {
194 const body = req.body || {};
195 const parsed = parseAuthorizeRequest(body);
196 if (parsed.fatal) return renderError(res, 400, parsed.fatal);
197 if (parsed.redirectError)
198 {
199 const e = parsed.redirectError;
200 return redirectWith(res, req, e.redirectUri, { error: e.error, error_description: e.description, state: e.state });
201 }
202 const r = parsed.request;
203 if (body.decision !== 'allow')
204 {
205 return redirectWith(res, req, r.redirectUri, { error: 'access_denied', error_description: 'The user denied access.', state: r.state });
206 }
207
208 const username = String(body.username || '').trim();
209 const password = String(body.password || '');
210 const ip = getClientIp(req);
211 const failKey = `${ip}|${username.toLowerCase()}`;
212 if (tooManyFailures(failKey) || tooManyFailures(ip))
213 {
214 return renderConsent(res, r, 'Too many failed attempts. Try again later.', username);
215 }
216
217 const row = username ? getDb().prepare('SELECT username, password_hash FROM users WHERE username = ?').get([username]) : null;
218 const ok = row ? await bcrypt.compare(password, row.password_hash) : false;
219 if (!ok)
220 {
221 recordFailure(failKey);
222 recordFailure(ip);
223 return renderConsent(res, r, 'Invalid username or password.', username);
224 }
225
226 const code = store.createAuthCode({
227 clientId: r.clientId,
228 username: row.username,
229 redirectUri: r.redirectUri,
230 scopes: r.scopes,
231 codeChallenge: r.codeChallenge,
232 deviceName: r.deviceName,
233 });
234 return redirectWith(res, req, r.redirectUri, { code, state: r.state });
235 } catch (err)
236 {
237 next(err);
238 }
239});
240
241function tokenError (res, status, error, description)
242{
243 noStore(res);
244 return res.status(status).json({ error, error_description: description });
245}
246
247function cors (req, res, next)
248{
249 res.set('Access-Control-Allow-Origin', '*');
250 res.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
251 res.set('Access-Control-Allow-Methods', 'POST, OPTIONS');
252 if (req.method === 'OPTIONS') return res.status(204).end();
253 next();
254}
255
256router.options('/oauth/token', cors);
257router.options('/oauth/revoke', cors);
258
259router.post('/oauth/token', cors, formParser, jsonParser, (req, res) =>
260{
261 const body = req.body || {};
262 if (req.get('authorization')) return tokenError(res, 400, 'invalid_client', 'Clients are public; do not send client credentials.');
263 const clientId = String(body.client_id || '');
264 const client = store.getClient(clientId);
265 if (!client || client.disabled) return tokenError(res, 401, 'invalid_client', 'Unknown client_id.');
266
267 if (body.grant_type === 'authorization_code')
268 {
269 const row = store.consumeAuthCode(String(body.code || ''));
270 if (!row || row.client_id !== clientId) return tokenError(res, 400, 'invalid_grant', 'Invalid or expired code.');
271 if (String(body.redirect_uri || '') !== row.redirect_uri) return tokenError(res, 400, 'invalid_grant', 'redirect_uri mismatch.');
272 const verifier = String(body.code_verifier || '');
273 if (!/^[A-Za-z0-9._~-]{43,128}$/.test(verifier) || store.pkceS256(verifier) !== row.code_challenge)
274 {
275 return tokenError(res, 400, 'invalid_grant', 'PKCE verification failed.');
276 }
277 if (!store.userExists(row.username)) return tokenError(res, 400, 'invalid_grant', 'User no longer exists.');
278 const scopes = row.scopes.split(' ');
279 const grantId = store.createOAuthGrant({ username: row.username, clientId, name: row.device_name, scopes });
280 const t = store.issueTokensForGrant(grantId);
281 noStore(res);
282 return res.json({
283 access_token: t.accessToken,
284 token_type: 'Bearer',
285 expires_in: t.expiresIn,
286 refresh_token: t.refreshToken,
287 scope: scopes.join(' '),
288 grant_id: grantId,
289 });
290 }
291
292 if (body.grant_type === 'refresh_token')
293 {
294 const result = store.refreshGrant(clientId, String(body.refresh_token || ''));
295 if (result.error) return tokenError(res, 400, 'invalid_grant', 'Invalid, expired, reused or revoked refresh token.');
296 noStore(res);
297 return res.json({
298 access_token: result.tokens.accessToken,
299 token_type: 'Bearer',
300 expires_in: result.tokens.expiresIn,
301 refresh_token: result.tokens.refreshToken,
302 scope: result.grant.scopes,
303 grant_id: result.grant.id,
304 });
305 }
306
307 return tokenError(res, 400, 'unsupported_grant_type', 'Use authorization_code or refresh_token.');
308});
309
310router.post('/oauth/revoke', cors, formParser, jsonParser, (req, res) =>
311{
312 const token = String((req.body && req.body.token) || '');
313 if (token) store.revokeByToken(token);
314 noStore(res);
315 res.status(200).json({});
316});
317
318router.resetLoginFailures = resetLoginFailures;
319module.exports = router;