Merge pull request #5705 from mikiher/fix-rate-limits

Rate-limit failed logins globally and password changes per user
This commit is contained in:
advplyr authored and GitHub committed 2026-11-18 17:32:34 -06:00
commit fc11bb4947
5 files changed
+400 -53

No files matched your search

+7
View File
@@ -0,0 +1,7 @@
# Security
Report security issues through GitHub private vulnerability reporting.
Failed logins (`POST /login`) share one server-wide limit. Failed password changes (`PATCH /api/me/password`) are limited per user. Neither limit uses the client IP. Set `RATE_LIMIT_AUTH_MAX=0` to disable both.
Anything beyond those two limits is the server operator's responsibility. Add a rate limiter in front of the server if you want one. A missing limiter on any other route is out of scope unless the report shows a guessable secret or a resource that grows without a bound.
+5 -5
View File
@@ -22,6 +22,7 @@ class Auth {
/** @type {import('express-rate-limit').RateLimitRequestHandler} */
this.authRateLimiter = RateLimiterFactory.getAuthRateLimiter()
this.passwordChangeRateLimiter = RateLimiterFactory.getPasswordChangeRateLimiter()
this.tokenManager = new TokenManager()
this.localAuthStrategy = new LocalAuthStrategy()
@@ -328,7 +329,7 @@ class Auth {
})
// Refresh token route
router.post('/auth/refresh', this.authRateLimiter, async (req, res) => {
router.post('/auth/refresh', async (req, res) => {
let refreshToken = req.cookies.refresh_token
// If x-refresh-token header is present, use it instead of the cookie
@@ -359,7 +360,7 @@ class Auth {
})
// openid strategy login route (this redirects to the configured openid login provider)
router.get('/auth/openid', this.authRateLimiter, (req, res) => {
router.get('/auth/openid', (req, res) => {
const authorizationUrlResponse = this.oidcAuthStrategy.getAuthorizationUrl(req)
if (authorizationUrlResponse.error) {
@@ -377,12 +378,11 @@ class Auth {
// This will be the oauth2 callback route for mobile clients
// It will redirect to an app-link like audiobookshelf://oauth
router.get('/auth/openid/mobile-redirect', this.authRateLimiter, (req, res) => this.oidcAuthStrategy.handleMobileRedirect(req, res))
router.get('/auth/openid/mobile-redirect', (req, res) => this.oidcAuthStrategy.handleMobileRedirect(req, res))
// openid strategy callback route (this receives the token from the configured openid login provider)
router.get(
'/auth/openid/callback',
this.authRateLimiter,
(req, res, next) => {
const sessionKey = this.oidcAuthStrategy.getStrategy()._key
@@ -461,7 +461,7 @@ class Auth {
*
* @example /auth/openid/config?issuer=http://192.168.1.66:9000/application/o/audiobookshelf/
*/
router.get('/auth/openid/config', this.authRateLimiter, this.isAuthenticated, async (req, res) => {
router.get('/auth/openid/config', this.isAuthenticated, async (req, res) => {
if (!req.user.isAdminOrUp) {
Logger.error(`[Auth] Non-admin user "${req.user.username}" attempted to get issuer config`)
return res.sendStatus(403)
+1 -1
View File
@@ -188,7 +188,7 @@ class ApiRouter {
this.router.post('/me/item/:id/bookmark', MeController.createBookmark.bind(this))
this.router.patch('/me/item/:id/bookmark', MeController.updateBookmark.bind(this))
this.router.delete('/me/item/:id/bookmark/:time', MeController.removeBookmark.bind(this))
this.router.patch('/me/password', this.auth.authRateLimiter, MeController.updatePassword.bind(this))
this.router.patch('/me/password', this.auth.passwordChangeRateLimiter, MeController.updatePassword.bind(this))
this.router.get('/me/items-in-progress', MeController.getAllLibraryItemsInProgress.bind(this))
this.router.get('/me/series/:id/remove-from-continue-listening', MeController.removeSeriesFromContinueListening.bind(this))
this.router.get('/me/series/:id/readd-to-continue-listening', MeController.readdSeriesFromContinueListening.bind(this))
+121 -47
View File
@@ -1,6 +1,5 @@
const { rateLimit, RateLimitRequestHandler } = require('express-rate-limit')
const Logger = require('../Logger')
const requestIp = require('../libs/requestIp')
/**
* Factory for creating authentication rate limiters
@@ -8,9 +7,96 @@ const requestIp = require('../libs/requestIp')
class RateLimiterFactory {
static DEFAULT_WINDOW_MS = 10 * 60 * 1000 // 10 minutes
static DEFAULT_MAX = 40 // 40 attempts
static LOCAL_LOGIN_KEY = 'local-login'
static UNKNOWN_USER_KEY = 'unknown-user'
constructor() {
this.authRateLimiter = null
this.passwordChangeRateLimiter = null
this.disabledLimiter = null
}
/**
* Shared window, max, and message. Null when rate limiting is disabled.
* @returns {{ windowMs: number, max: number, message: string } | null}
*/
getLimiterConfig() {
// Disable by setting max to 0
if (process.env.RATE_LIMIT_AUTH_MAX === '0') {
return null
}
let windowMs = RateLimiterFactory.DEFAULT_WINDOW_MS
if (parseInt(process.env.RATE_LIMIT_AUTH_WINDOW) > 0) {
windowMs = parseInt(process.env.RATE_LIMIT_AUTH_WINDOW)
}
let max = RateLimiterFactory.DEFAULT_MAX
if (parseInt(process.env.RATE_LIMIT_AUTH_MAX) > 0) {
max = parseInt(process.env.RATE_LIMIT_AUTH_MAX)
}
let message = 'Too many authentication requests'
if (process.env.RATE_LIMIT_AUTH_MESSAGE) {
message = process.env.RATE_LIMIT_AUTH_MESSAGE
}
return { windowMs, max, message }
}
/**
* Log non-default limiter settings once per process.
* @param {{ windowMs: number, max: number }} config
*/
logCustomLimiterConfig(config) {
if (this.loggedCustomConfig) return
this.loggedCustomConfig = true
if (config.windowMs !== RateLimiterFactory.DEFAULT_WINDOW_MS) {
Logger.info(`[RateLimiterFactory] Authentication rate limiting window set to ${config.windowMs}ms by ENV variable`)
}
if (config.max !== RateLimiterFactory.DEFAULT_MAX) {
Logger.info(`[RateLimiterFactory] Authentication rate limiting max set to ${config.max} by ENV variable`)
}
}
/**
* @returns {RateLimitRequestHandler}
*/
getDisabledLimiter() {
if (!this.disabledLimiter) {
this.disabledLimiter = (req, res, next) => next()
}
return this.disabledLimiter
}
/**
* @param {{ windowMs: number, max: number, message: string }} config
* @param {(req: import('express').Request) => string} keyGenerator
* @returns {RateLimitRequestHandler}
*/
createLimiter(config, keyGenerator) {
return rateLimit({
windowMs: config.windowMs,
max: config.max,
standardHeaders: true,
legacyHeaders: false,
keyGenerator,
skipSuccessfulRequests: true,
handler: (req, res) => {
const userAgent = req.get('User-Agent') || 'Unknown'
const endpoint = req.path
const method = req.method
const userId = req.user?.id
const userLabel = userId ? `, User: ${userId}` : ''
Logger.warn(`[RateLimiter] Rate limit exceeded - Endpoint: ${method} ${endpoint}${userLabel}, User-Agent: ${userAgent}`)
res.status(429).json({
error: config.message
})
}
})
}
/**
@@ -22,61 +108,49 @@ class RateLimiterFactory {
return this.authRateLimiter
}
// Disable by setting max to 0
if (process.env.RATE_LIMIT_AUTH_MAX === '0') {
this.authRateLimiter = (req, res, next) => next()
const config = this.getLimiterConfig()
if (!config) {
Logger.info(`[RateLimiterFactory] Authentication rate limiting disabled by ENV variable`)
this.authRateLimiter = this.getDisabledLimiter()
return this.authRateLimiter
}
let windowMs = RateLimiterFactory.DEFAULT_WINDOW_MS
if (parseInt(process.env.RATE_LIMIT_AUTH_WINDOW) > 0) {
windowMs = parseInt(process.env.RATE_LIMIT_AUTH_WINDOW)
if (windowMs !== RateLimiterFactory.DEFAULT_WINDOW_MS) {
Logger.info(`[RateLimiterFactory] Authentication rate limiting window set to ${windowMs}ms by ENV variable`)
}
}
this.logCustomLimiterConfig(config)
let max = RateLimiterFactory.DEFAULT_MAX
if (parseInt(process.env.RATE_LIMIT_AUTH_MAX) > 0) {
max = parseInt(process.env.RATE_LIMIT_AUTH_MAX)
if (max !== RateLimiterFactory.DEFAULT_MAX) {
Logger.info(`[RateLimiterFactory] Authentication rate limiting max set to ${max} by ENV variable`)
}
}
// One process-wide bucket of failed local logins. Do not key on client IP headers.
this.authRateLimiter = this.createLimiter(config, () => RateLimiterFactory.LOCAL_LOGIN_KEY)
let message = 'Too many authentication requests'
if (process.env.RATE_LIMIT_AUTH_MESSAGE) {
message = process.env.RATE_LIMIT_AUTH_MESSAGE
}
this.authRateLimiter = rateLimit({
windowMs,
max,
standardHeaders: true,
legacyHeaders: false,
keyGenerator: (req) => {
// Override keyGenerator to handle proxy IPs
return requestIp.getClientIp(req) || req.ip
},
handler: (req, res) => {
const userAgent = req.get('User-Agent') || 'Unknown'
const endpoint = req.path
const method = req.method
const ip = requestIp.getClientIp(req) || req.ip
Logger.warn(`[RateLimiter] Rate limit exceeded - IP: ${ip}, Endpoint: ${method} ${endpoint}, User-Agent: ${userAgent}`)
res.status(429).json({
error: message
})
}
})
Logger.debug(`[RateLimiterFactory] Created auth rate limiter: ${max} attempts per ${windowMs / 1000 / 60} minutes`)
Logger.debug(`[RateLimiterFactory] Created auth rate limiter: ${config.max} failed attempts per ${config.windowMs / 1000 / 60} minutes`)
return this.authRateLimiter
}
/**
* Failed current-password checks on PATCH /me/password, keyed by the authenticated user.
* @returns {RateLimitRequestHandler}
*/
getPasswordChangeRateLimiter() {
if (this.passwordChangeRateLimiter) {
return this.passwordChangeRateLimiter
}
const config = this.getLimiterConfig()
if (!config) {
this.passwordChangeRateLimiter = this.getDisabledLimiter()
return this.passwordChangeRateLimiter
}
this.logCustomLimiterConfig(config)
this.passwordChangeRateLimiter = this.createLimiter(config, (req) => {
const userId = req.user?.id
return userId ? String(userId) : RateLimiterFactory.UNKNOWN_USER_KEY
})
Logger.debug(`[RateLimiterFactory] Created password change rate limiter: ${config.max} failed attempts per ${config.windowMs / 1000 / 60} minutes`)
return this.passwordChangeRateLimiter
}
}
module.exports = new RateLimiterFactory()
@@ -0,0 +1,266 @@
const { expect } = require('chai')
const express = require('express')
const http = require('http')
const sinon = require('sinon')
const Logger = require('../../../server/Logger')
const RateLimiterFactory = require('../../../server/utils/rateLimiterFactory')
function listen(app) {
const server = http.createServer(app)
return new Promise((resolve) => {
server.listen(0, '127.0.0.1', () => {
resolve({ server, port: server.address().port })
})
})
}
function closeServer(server) {
return new Promise((resolve, reject) => {
server.close((err) => (err ? reject(err) : resolve()))
})
}
function patchPassword(port, { userId, headers = {} } = {}) {
return new Promise((resolve, reject) => {
const body = JSON.stringify({ password: 'current', newPassword: 'next' })
const req = http.request(
{
hostname: '127.0.0.1',
port,
path: '/me/password',
method: 'PATCH',
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(body),
'User-Agent': 'rate-limiter-test',
'x-user-id': userId,
...headers
}
},
(res) => {
res.resume()
res.on('end', () => resolve({ status: res.statusCode }))
}
)
req.on('error', reject)
req.write(body)
req.end()
})
}
function passwordChangeApp(limiter) {
const app = express()
app.patch(
'/me/password',
(req, res, next) => {
const userId = req.get('x-user-id')
if (userId) req.user = { id: userId }
next()
},
limiter,
(req, res) => {
res.status(400).send('Invalid password')
}
)
return app
}
function postLogin(port, { headers = {} } = {}) {
return new Promise((resolve, reject) => {
const body = JSON.stringify({ username: 'alice', password: 'guess' })
const req = http.request(
{
hostname: '127.0.0.1',
port,
path: '/login',
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(body),
'User-Agent': 'rate-limiter-test',
...headers
}
},
(res) => {
let data = ''
res.on('data', (chunk) => {
data += chunk
})
res.on('end', () => {
resolve({ status: res.statusCode, body: data, headers: res.headers })
})
}
)
req.on('error', reject)
req.write(body)
req.end()
})
}
describe('rateLimiterFactory', () => {
const previousMax = process.env.RATE_LIMIT_AUTH_MAX
const previousWindow = process.env.RATE_LIMIT_AUTH_WINDOW
const previousMessage = process.env.RATE_LIMIT_AUTH_MESSAGE
beforeEach(() => {
RateLimiterFactory.authRateLimiter = null
RateLimiterFactory.passwordChangeRateLimiter = null
process.env.RATE_LIMIT_AUTH_MAX = '3'
process.env.RATE_LIMIT_AUTH_WINDOW = '60000'
delete process.env.RATE_LIMIT_AUTH_MESSAGE
sinon.stub(Logger, 'info')
sinon.stub(Logger, 'warn')
sinon.stub(Logger, 'debug')
})
afterEach(() => {
RateLimiterFactory.authRateLimiter = null
RateLimiterFactory.passwordChangeRateLimiter = null
if (previousMax === undefined) delete process.env.RATE_LIMIT_AUTH_MAX
else process.env.RATE_LIMIT_AUTH_MAX = previousMax
if (previousWindow === undefined) delete process.env.RATE_LIMIT_AUTH_WINDOW
else process.env.RATE_LIMIT_AUTH_WINDOW = previousWindow
if (previousMessage === undefined) delete process.env.RATE_LIMIT_AUTH_MESSAGE
else process.env.RATE_LIMIT_AUTH_MESSAGE = previousMessage
sinon.restore()
})
it('shares one bucket across rotating client IP headers and returns 429 after max failures', async () => {
const app = express()
const limiter = RateLimiterFactory.getAuthRateLimiter()
app.post('/login', limiter, (req, res) => {
res.status(401).json({ error: 'Unauthorized' })
})
const { server, port } = await listen(app)
try {
const statuses = []
for (let i = 0; i < 4; i++) {
const result = await postLogin(port, {
headers: {
'X-Client-IP': `10.0.0.${i}`,
'X-Forwarded-For': `203.0.113.${i}`
}
})
statuses.push(result.status)
}
expect(statuses).to.deep.equal([401, 401, 401, 429])
} finally {
await closeServer(server)
}
})
it('does not consume a slot for successful logins', async () => {
const app = express()
const limiter = RateLimiterFactory.getAuthRateLimiter()
let attempt = 0
app.post('/login', limiter, (req, res) => {
attempt += 1
if (attempt === 1) {
return res.status(200).json({ ok: true })
}
res.status(401).json({ error: 'Unauthorized' })
})
const { server, port } = await listen(app)
try {
const success = await postLogin(port)
expect(success.status).to.equal(200)
const statuses = []
for (let i = 0; i < 4; i++) {
const result = await postLogin(port, {
headers: {
'X-Client-IP': `10.1.0.${i}`
}
})
statuses.push(result.status)
}
expect(statuses).to.deep.equal([401, 401, 401, 429])
} finally {
await closeServer(server)
}
})
it('limits password changes per user and ignores client IP headers', async () => {
const app = passwordChangeApp(RateLimiterFactory.getPasswordChangeRateLimiter())
const { server, port } = await listen(app)
try {
const alice = []
for (let i = 0; i < 4; i++) {
const result = await patchPassword(port, {
userId: 'alice',
headers: {
'X-Client-IP': `10.2.0.${i}`,
'X-Forwarded-For': `198.51.100.${i}`
}
})
alice.push(result.status)
}
const bob = await patchPassword(port, { userId: 'bob' })
expect(alice).to.deep.equal([400, 400, 400, 429])
expect(bob.status).to.equal(400)
expect(Logger.warn.calledWithMatch(/User: alice/)).to.equal(true)
} finally {
await closeServer(server)
}
})
it('does not consume a password-change slot for a successful update', async () => {
let attempt = 0
const app = express()
const limiter = RateLimiterFactory.getPasswordChangeRateLimiter()
app.patch(
'/me/password',
(req, res, next) => {
req.user = { id: 'alice' }
next()
},
limiter,
(req, res) => {
attempt += 1
res.status(attempt === 1 ? 200 : 400).send(attempt === 1 ? 'ok' : 'Invalid password')
}
)
const { server, port } = await listen(app)
try {
const success = await patchPassword(port, { userId: 'alice' })
expect(success.status).to.equal(200)
const statuses = []
for (let i = 0; i < 4; i++) {
const result = await patchPassword(port, { userId: 'alice' })
statuses.push(result.status)
}
expect(statuses).to.deep.equal([400, 400, 400, 429])
} finally {
await closeServer(server)
}
})
it('can be disabled with RATE_LIMIT_AUTH_MAX=0', async () => {
RateLimiterFactory.authRateLimiter = null
process.env.RATE_LIMIT_AUTH_MAX = '0'
const app = express()
const limiter = RateLimiterFactory.getAuthRateLimiter()
app.post('/login', limiter, (req, res) => {
res.status(401).json({ error: 'Unauthorized' })
})
const { server, port } = await listen(app)
try {
for (let i = 0; i < 5; i++) {
const result = await postLogin(port)
expect(result.status).to.equal(401)
}
} finally {
await closeServer(server)
}
})
})