BlueGit

timfa filemanager

Files

filemanager / server / auth.js

auth.js

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