From f35f40929df0c96fc188c3a3ddcda96500b154f2 Mon Sep 17 00:00:00 2001 From: mikiher Date: Sat, 7 Nov 2026 18:24:06 +0200 Subject: [PATCH 1/3] Rate-limit failed local logins in one shared bucket --- server/Auth.js | 9 +- server/routers/ApiRouter.js | 2 +- server/utils/rateLimiterFactory.js | 14 +- test/server/utils/rateLimiterFactory.test.js | 161 +++++++++++++++++++ 4 files changed, 172 insertions(+), 14 deletions(-) create mode 100644 test/server/utils/rateLimiterFactory.test.js diff --git a/server/Auth.js b/server/Auth.js index de4fbb73b..fedf2dccf 100644 --- a/server/Auth.js +++ b/server/Auth.js @@ -328,7 +328,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 +359,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 +377,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 +460,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) diff --git a/server/routers/ApiRouter.js b/server/routers/ApiRouter.js index 9a184aa62..2d57fa43a 100644 --- a/server/routers/ApiRouter.js +++ b/server/routers/ApiRouter.js @@ -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', 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)) diff --git a/server/utils/rateLimiterFactory.js b/server/utils/rateLimiterFactory.js index e639c51c9..7b3e05ff3 100644 --- a/server/utils/rateLimiterFactory.js +++ b/server/utils/rateLimiterFactory.js @@ -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,6 +7,7 @@ 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' constructor() { this.authRateLimiter = null @@ -55,17 +55,15 @@ class RateLimiterFactory { max, standardHeaders: true, legacyHeaders: false, - keyGenerator: (req) => { - // Override keyGenerator to handle proxy IPs - return requestIp.getClientIp(req) || req.ip - }, + // One process-wide bucket of failed local logins. Do not key on client IP headers. + keyGenerator: () => RateLimiterFactory.LOCAL_LOGIN_KEY, + skipSuccessfulRequests: true, 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}`) + Logger.warn(`[RateLimiter] Rate limit exceeded - Endpoint: ${method} ${endpoint}, User-Agent: ${userAgent}`) res.status(429).json({ error: message @@ -73,7 +71,7 @@ class RateLimiterFactory { } }) - Logger.debug(`[RateLimiterFactory] Created auth rate limiter: ${max} attempts per ${windowMs / 1000 / 60} minutes`) + Logger.debug(`[RateLimiterFactory] Created auth rate limiter: ${max} failed attempts per ${windowMs / 1000 / 60} minutes`) return this.authRateLimiter } diff --git a/test/server/utils/rateLimiterFactory.test.js b/test/server/utils/rateLimiterFactory.test.js new file mode 100644 index 000000000..7f15129e3 --- /dev/null +++ b/test/server/utils/rateLimiterFactory.test.js @@ -0,0 +1,161 @@ +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 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 + 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 + 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('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) + } + }) +}) From 420c2b28ed0cc79c6fa2175c01316b1511911c8a Mon Sep 17 00:00:00 2001 From: mikiher Date: Sat, 7 Nov 2026 18:48:05 +0200 Subject: [PATCH 2/3] Rate-limit failed password changes per user --- server/Auth.js | 1 + server/routers/ApiRouter.js | 2 +- server/utils/rateLimiterFactory.js | 164 ++++++++++++++----- test/server/utils/rateLimiterFactory.test.js | 105 ++++++++++++ 4 files changed, 227 insertions(+), 45 deletions(-) diff --git a/server/Auth.js b/server/Auth.js index fedf2dccf..a6f24b815 100644 --- a/server/Auth.js +++ b/server/Auth.js @@ -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() diff --git a/server/routers/ApiRouter.js b/server/routers/ApiRouter.js index 2d57fa43a..392465ea8 100644 --- a/server/routers/ApiRouter.js +++ b/server/routers/ApiRouter.js @@ -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', 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)) diff --git a/server/utils/rateLimiterFactory.js b/server/utils/rateLimiterFactory.js index 7b3e05ff3..577936d01 100644 --- a/server/utils/rateLimiterFactory.js +++ b/server/utils/rateLimiterFactory.js @@ -8,9 +8,95 @@ 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,59 +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, - // One process-wide bucket of failed local logins. Do not key on client IP headers. - keyGenerator: () => RateLimiterFactory.LOCAL_LOGIN_KEY, - skipSuccessfulRequests: true, - handler: (req, res) => { - const userAgent = req.get('User-Agent') || 'Unknown' - const endpoint = req.path - const method = req.method - - Logger.warn(`[RateLimiter] Rate limit exceeded - Endpoint: ${method} ${endpoint}, User-Agent: ${userAgent}`) - - res.status(429).json({ - error: message - }) - } - }) - - Logger.debug(`[RateLimiterFactory] Created auth rate limiter: ${max} failed 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() diff --git a/test/server/utils/rateLimiterFactory.test.js b/test/server/utils/rateLimiterFactory.test.js index 7f15129e3..1577efb41 100644 --- a/test/server/utils/rateLimiterFactory.test.js +++ b/test/server/utils/rateLimiterFactory.test.js @@ -21,6 +21,51 @@ function closeServer(server) { }) } +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' }) @@ -60,6 +105,7 @@ describe('rateLimiterFactory', () => { 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 @@ -70,6 +116,7 @@ describe('rateLimiterFactory', () => { 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 @@ -138,6 +185,64 @@ describe('rateLimiterFactory', () => { } }) + 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' From 0776e8079e5f4a52aaedc07b5a94e34eede196ec Mon Sep 17 00:00:00 2001 From: advplyr Date: Wed, 18 Nov 2026 17:28:55 -0600 Subject: [PATCH 3/3] Add SECURITY.md --- SECURITY.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 SECURITY.md diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 000000000..dae970279 --- /dev/null +++ b/SECURITY.md @@ -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.