BlueGit

timfa filemanager

Files

filemanager / server / auth.js

auth.js

Add scheduled restart backend
timfa Tim Falken · pushed by timfa · 5 months ago
9e526bef History
auth.js 9.2 KiB Download Raw
1'use strict';
2
3const jwt = require('jsonwebtoken');
4const crypto = require('crypto');
5const geoip = require('geoip-lite');
6const { getDb } = require('./db');
7
8const SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
9const AUTH_SESSION_PURGE_INTERVAL_MS = 15 * 60 * 1000; // 15 minutes
10const AUTH_SESSION_REVOKED_RETENTION_MS = 24 * 60 * 60 * 1000; // 24 hours
11const AUTH_SESSION_IDLE_RETENTION_MS = 24 * 60 * 60 * 1000; // 24 hours beyond idle timeout
12
13let authSessionPurgeTimer = null;
14const authSessionCleanupState = {
15 lastRunAt: null,
16 lastPurgedCount: 0,
17 lastDurationMs: 0,
18 lastError: null,
19};
20
21// Secret used to sign JWTs — generated fresh each server boot.
22// Tokens from a previous boot are automatically invalid.
23const JWT_SECRET = crypto.randomBytes(64).toString('hex');
24
25// ---------------------------------------------------------------------------
26// Helpers
27// ---------------------------------------------------------------------------
28
29function getClientIp (req)
30{
31 // Respect X-Forwarded-For only if you trust a reverse proxy in front.
32 // For a direct Pi deployment, req.ip is sufficient.
33 let ip = req.ip || req.connection.remoteAddress || '';
34 // Normalize IPv4-mapped IPv6 (::ffff:127.0.0.1) and IPv6 loopback (::1)
35 // to plain IPv4 so token binding is stable across request variations.
36 ip = ip.replace(/^::ffff:/, '');
37 if (ip === '::1') ip = '127.0.0.1';
38 return ip;
39}
40
41function getRegion (ip)
42{
43 // ip is already normalized by getClientIp (no ::ffff: prefix, no ::1)
44 const geo = geoip.lookup(ip);
45 // Private / RFC1918 addresses won't resolve — use ip itself as region.
46 return geo ? `${geo.country}:${geo.region}` : `local:${ip}`;
47}
48
49function fingerprintHash (fingerprint)
50{
51 return crypto.createHash('sha256').update(fingerprint || '').digest('hex');
52}
53
54function nowMs ()
55{
56 return Date.now();
57}
58
59function createSession (username, req, fingerprint)
60{
61 const db = getDb();
62 const ip = getClientIp(req);
63 const region = getRegion(ip);
64 const fpHash = fingerprintHash(fingerprint);
65 const createdAt = nowMs();
66 const sessionId = crypto.randomUUID();
67
68 db.prepare(`
69 INSERT INTO auth_sessions (session_id, username, ip, region, fp_hash, created_at, last_seen_at, revoked_at)
70 VALUES (?, ?, ?, ?, ?, ?, ?, NULL)
71 `).run([sessionId, username, ip, region, fpHash, createdAt, createdAt]);
72
73 return { sessionId, ip, region, fpHash };
74}
75
76function revokeSession (sessionId)
77{
78 if (!sessionId) return;
79 const db = getDb();
80 db.prepare('UPDATE auth_sessions SET revoked_at = ? WHERE session_id = ? AND revoked_at IS NULL')
81 .run([nowMs(), sessionId]);
82}
83
84function purgeStaleSessions (opts = {})
85{
86 const now = Number.isFinite(Number(opts.nowMs)) ? Number(opts.nowMs) : nowMs();
87 const revokedCutoffMs = now - AUTH_SESSION_REVOKED_RETENTION_MS;
88 const idleCutoffMs = now - SESSION_IDLE_TIMEOUT_MS - AUTH_SESSION_IDLE_RETENTION_MS;
89 const db = getDb();
90
91 const result = db.prepare(`
92 DELETE FROM auth_sessions
93 WHERE (revoked_at IS NOT NULL AND revoked_at <= ?)
94 OR (last_seen_at <= ?)
95 `).run([revokedCutoffMs, idleCutoffMs]);
96
97 return Number(result && result.changes || 0);
98}
99
100function runAuthSessionCleanupOnce ()
101{
102 const startedAt = nowMs();
103 try
104 {
105 const purged = purgeStaleSessions();
106 authSessionCleanupState.lastRunAt = nowMs();
107 authSessionCleanupState.lastPurgedCount = Number(purged || 0);
108 authSessionCleanupState.lastDurationMs = Math.max(0, authSessionCleanupState.lastRunAt - startedAt);
109 authSessionCleanupState.lastError = null;
110 return purged;
111 } catch (err)
112 {
113 authSessionCleanupState.lastRunAt = nowMs();
114 authSessionCleanupState.lastPurgedCount = 0;
115 authSessionCleanupState.lastDurationMs = Math.max(0, authSessionCleanupState.lastRunAt - startedAt);
116 authSessionCleanupState.lastError = err && err.message ? String(err.message) : String(err);
117 throw err;
118 }
119}
120
121function startAuthSessionCleanupLoop ()
122{
123 if (authSessionPurgeTimer) return;
124
125 // Run once immediately at startup to trim stale rows from earlier uptime.
126 try
127 {
128 runAuthSessionCleanupOnce();
129 } catch
130 {
131 // Ignore purge failures and retry on the next interval.
132 }
133
134 authSessionPurgeTimer = setInterval(() =>
135 {
136 try
137 {
138 runAuthSessionCleanupOnce();
139 } catch
140 {
141 // Keep server healthy even if cleanup temporarily fails.
142 }
143 }, AUTH_SESSION_PURGE_INTERVAL_MS);
144
145 if (authSessionPurgeTimer && typeof authSessionPurgeTimer.unref === 'function')
146 {
147 authSessionPurgeTimer.unref();
148 }
149}
150
151function stopAuthSessionCleanupLoop ()
152{
153 if (!authSessionPurgeTimer) return;
154 clearInterval(authSessionPurgeTimer);
155 authSessionPurgeTimer = null;
156}
157
158function getAuthSessionCleanupSnapshot ()
159{
160 return {
161 running: !!authSessionPurgeTimer,
162 intervalMs: AUTH_SESSION_PURGE_INTERVAL_MS,
163 lastRunAt: authSessionCleanupState.lastRunAt,
164 lastPurgedCount: authSessionCleanupState.lastPurgedCount,
165 lastDurationMs: authSessionCleanupState.lastDurationMs,
166 lastError: authSessionCleanupState.lastError,
167 revokedRetentionMs: AUTH_SESSION_REVOKED_RETENTION_MS,
168 idleRetentionMs: AUTH_SESSION_IDLE_RETENTION_MS,
169 };
170}
171
172// ---------------------------------------------------------------------------
173// Token creation
174// ---------------------------------------------------------------------------
175
176/**
177 * Returns a signed JWT that expires at end of the current calendar day (UTC).
178 */
179function createToken (username, req, fingerprint)
180{
181 const session = createSession(username, req, fingerprint);
182
183 const payload = {
184 u: username,
185 ip: session.ip,
186 r: session.region,
187 fp: session.fpHash,
188 sid: session.sessionId,
189 };
190
191 // Keep JWT short-lived; server-side idle checks are the primary control.
192 return jwt.sign(payload, JWT_SECRET, { expiresIn: '12h' });
193}
194
195// ---------------------------------------------------------------------------
196// Middleware
197// ---------------------------------------------------------------------------
198
199/**
200 * Verifies the Bearer token in the Authorization header.
201 * On success attaches `req.user = { username, isAdmin }`.
202 * On failure sends 401 with a generic "session invalid" message.
203 */
204function requireAuth (req, res, next)
205{
206 const header = req.headers['authorization'] || '';
207 const token = header.startsWith('Bearer ') ? header.slice(7) : null;
208
209 if (!token)
210 {
211 return res.status(401).json({ error: 'Session invalid or expired.' });
212 }
213
214 let payload;
215 try
216 {
217 payload = jwt.verify(token, JWT_SECRET);
218 } catch
219 {
220 return res.status(401).json({ error: 'Session invalid or expired.' });
221 }
222
223 // Verify IP binding
224 const currentIp = getClientIp(req);
225 if (payload.ip !== currentIp)
226 {
227 // Intentionally identical error — do not reveal reason
228 return res.status(401).json({ error: 'Session invalid or expired.' });
229 }
230
231 // Verify region binding
232 const currentRegion = getRegion(currentIp);
233 if (payload.r !== currentRegion)
234 {
235 return res.status(401).json({ error: 'Session invalid or expired.' });
236 }
237
238 // Verify fingerprint (sent on every request as X-Fp header)
239 const fp = req.headers['x-fp'] || '';
240 if (payload.fp !== fingerprintHash(fp))
241 {
242 return res.status(401).json({ error: 'Session invalid or expired.' });
243 }
244
245 if (!payload.sid)
246 {
247 return res.status(401).json({ error: 'Session invalid or expired.' });
248 }
249
250 const db = getDb();
251 const session = db.prepare(`
252 SELECT session_id, username, ip, region, fp_hash, last_seen_at, revoked_at
253 FROM auth_sessions
254 WHERE session_id = ?
255 `).get([payload.sid]);
256
257 if (!session || session.revoked_at)
258 {
259 return res.status(401).json({ error: 'Session invalid or expired.' });
260 }
261
262 if (session.username !== payload.u || session.ip !== currentIp || session.region !== currentRegion)
263 {
264 return res.status(401).json({ error: 'Session invalid or expired.' });
265 }
266
267 if (session.fp_hash !== payload.fp)
268 {
269 return res.status(401).json({ error: 'Session invalid or expired.' });
270 }
271
272 if (nowMs() - Number(session.last_seen_at || 0) > SESSION_IDLE_TIMEOUT_MS)
273 {
274 revokeSession(payload.sid);
275 return res.status(401).json({ error: 'Session invalid or expired.' });
276 }
277
278 db.prepare('UPDATE auth_sessions SET last_seen_at = ? WHERE session_id = ?').run([nowMs(), payload.sid]);
279
280 // Load user from DB
281 const user = db.prepare('SELECT id, username, is_admin, permissions FROM users WHERE username = ?')
282 .get([payload.u]);
283
284 if (!user)
285 {
286 return res.status(401).json({ error: 'Session invalid or expired.' });
287 }
288
289 req.user = {
290 id: user.id,
291 username: user.username,
292 isAdmin: user.is_admin === 1,
293 permissions: JSON.parse(user.permissions || '{}'),
294 };
295 req.authSessionId = payload.sid;
296
297 next();
298}
299
300/**
301 * Middleware that additionally requires admin privileges.
302 */
303function requireAdmin (req, res, next)
304{
305 if (!req.user || !req.user.isAdmin)
306 {
307 return res.status(403).json({ error: 'Admin access required.' });
308 }
309 next();
310}
311
312module.exports = {
313 createToken,
314 requireAuth,
315 requireAdmin,
316 getClientIp,
317 getRegion,
318 revokeSession,
319 purgeStaleSessions,
320 getAuthSessionCleanupSnapshot,
321 startAuthSessionCleanupLoop,
322 stopAuthSessionCleanupLoop,
323 SESSION_IDLE_TIMEOUT_MS,
324 AUTH_SESSION_PURGE_INTERVAL_MS,
325 AUTH_SESSION_REVOKED_RETENTION_MS,
326 AUTH_SESSION_IDLE_RETENTION_MS,
327};