dangkhoa2016's picture
feat: add runtime configuration for rate limiting and Redis
e9d5bbe
Raw History Blame
10.4 kB
'use strict';
const DEFAULT_WINDOW_MS = 60 * 1000;
const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
const BLOCK_DURATIONS_SEC = [300, 1200, 3600]; // seconds (5m, 20m, 1h)
const BLOCK_TRACKING_KEY_PREFIX = 'rl:block:';
const MAX_MEM_ENTRIES = 10000;
// Circuit breaker for Redis
const circuitBreaker = {
isOpen: false,
failureCount: 0,
lastFailure: 0,
resetTimeout: 30000 // 30 seconds
};
// Trusted proxies for secure IP extraction (supports CIDR)
const TRUSTED_PROXIES = ['127.0.0.1', '::1', '10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16'];
// Request cost multiplier (GET=1, POST=2, DELETE=3)
const REQUEST_COST = {
GET: 1,
HEAD: 1,
POST: 2,
PUT: 2,
PATCH: 2,
DELETE: 3
};
function cidrToRegex(cidr) {
const [ip, bits] = cidr.split('/');
/* v8 ignore next */
const maskBits = bits ? parseInt(bits, 10) : 32;
const mask = ~(2 ** (32 - maskBits) - 1);
const ipParts = ip.split('.').map(Number);
const networkInt = (ipParts[0] << 24 | ipParts[1] << 16 | ipParts[2] << 8 | ipParts[3]) & mask;
return (testIp) => {
const testParts = testIp.split('.').map(Number);
const testInt = testParts[0] << 24 | testParts[1] << 16 | testParts[2] << 8 | testParts[3];
return (testInt & mask) === networkInt;
};
}
// Check if an IP is in a trusted CIDR range
function isTrustedProxy(ip) {
if (!ip || ip === 'unknown') return false;
return TRUSTED_PROXIES.some(cidr => {
try {
if (!cidr.includes('/')) {
return ip === cidr;
}
const matcher = cidrToRegex(cidr);
return matcher(ip);
} catch { /* v8 ignore next */
return false;
}
});
}
// Lua script for atomic rate limiting operations
const RATE_LIMIT_LUA_SCRIPT = `
local countKey = KEYS[1]
local blockKey = KEYS[2]
local maxRequests = tonumber(ARGV[1])
local windowSec = tonumber(ARGV[2])
local blockDurations = {${BLOCK_DURATIONS_SEC.join(',')}}
-- Increment request count
local count = redis.call('INCR', countKey)
-- Set expiry for countKey if this is the first request in the window
if count == 1 then
redis.call('EXPIRE', countKey, windowSec)
end
-- Check if rate limit is exceeded
if count > maxRequests then
-- Increment violation count
local violationCount = redis.call('INCR', blockKey)
-- Determine block duration (escalating)
local idx = math.min(violationCount - 1, #blockDurations - 1)
local blockSec = blockDurations[idx + 1]
-- Set expiry for blockKey
redis.call('EXPIRE', blockKey, blockSec)
-- Return rate limit info (limited = true)
return {count, 0, blockSec, blockSec, 1}
else
-- Get TTL for countKey
local ttl = redis.call('TTL', countKey)
if ttl < 0 then
ttl = windowSec
end
-- Return rate limit info (limited = false)
return {count, math.max(0, maxRequests - count), ttl, 0, 0}
end`;
function createInMemoryStore() {
const mem = new Map();
// simple LRU helper
function touch(key) {
const v = mem.get(key);
if (!v) return;
mem.delete(key);
mem.set(key, v);
}
function ensureLimit() {
while (mem.size > MAX_MEM_ENTRIES) {
const firstKey = mem.keys().next().value;
mem.delete(firstKey);
}
}
return {
get: (k) => {
touch(k);
return mem.get(k);
},
set: (k, v) => {
mem.set(k, v);
ensureLimit();
},
delete: (k) => mem.delete(k),
entries: () => mem.entries(),
size: () => mem.size
};
}
const memStore = createInMemoryStore();
function triggerCleanup() {
const now = Date.now();
for (const [ip, entry] of memStore.entries()) {
if (entry.resetAt <= now) memStore.delete(ip);
}
}
/* v8 ignore start */
setInterval(() => {
triggerCleanup();
}, CLEANUP_INTERVAL_MS);
/* v8 ignore stop */
function memFallback(ip, max, windowMs) {
const now = Date.now();
let entry = memStore.get(ip) || null;
if (!entry || entry.resetAt <= now) {
// new window or expired
const prevViolation = entry ? (entry.violationCount || 0) : 0;
entry = {
count: 0,
resetAt: now + windowMs,
violationCount: prevViolation
};
}
entry.count = (entry.count || 0) + 1;
// if exceeded, increment violationCount and set block expiry
let limited = false;
let resetSeconds;
if (entry.count > max) {
entry.violationCount = (entry.violationCount || 0) + 1;
const idx = Math.min(entry.violationCount - 1, BLOCK_DURATIONS_SEC.length - 1);
const blockSec = BLOCK_DURATIONS_SEC[idx];
// set reset to now + blockSec
entry.resetAt = now + blockSec * 1000;
limited = true;
resetSeconds = Math.ceil(blockSec);
} else {
resetSeconds = Math.ceil((entry.resetAt - now) / 1000);
}
memStore.set(ip, entry);
return {
count: entry.count,
remaining: Math.max(0, max - entry.count),
reset: Math.floor((entry.resetAt) / 1000), // epoch seconds
retryAfter: limited ? resetSeconds : 0,
limited,
violationCount: entry.violationCount
};
}
// Normalize IP address (IPv4-mapped IPv6, lowercase, etc.)
function normalizeIp(ip) {
if (!ip || ip === 'unknown') return 'unknown';
// Handle IPv6-mapped IPv4 addresses (::ffff:192.168.1.1)
if (ip.startsWith('::ffff:')) {
return ip.substring(7); // Convert to IPv4
}
// Lowercase for consistency
return ip.toLowerCase();
}
// Secure IP extraction with proxy awareness
function getClientIp(req) {
const xff = req.headers['x-forwarded-for'] || '';
const ips = xff.split(',').map(ip => normalizeIp(ip.trim())).filter(ip => ip && ip !== 'unknown');
// If request comes from a trusted proxy, use the first IP in XFF
if (isTrustedProxy(normalizeIp(req.socket.remoteAddress))) {
return ips[0] || normalizeIp(req.socket.remoteAddress);
}
// Otherwise, use the direct connection IP
/* v8 ignore next */
return normalizeIp(req.socket.remoteAddress) || 'unknown';
}
// Request cost multiplier (GET=1, POST=2, DELETE=3)
function getRequestCost(req) {
return REQUEST_COST[req.method] || 1;
}
async function checkRedis(redis, ip, max, windowSec, retryDelayMs = null) {
// Circuit breaker check
if (circuitBreaker.isOpen) {
if (Date.now() - circuitBreaker.lastFailure > circuitBreaker.resetTimeout) {
circuitBreaker.isOpen = false;
circuitBreaker.failureCount = 0;
} else {
throw new Error('Circuit breaker open - Redis unavailable');
}
}
let retries = 0;
const maxRetries = 3;
while (retries < maxRetries) {
try {
const countKey = `rl:${ip}`;
const blockKey = `${BLOCK_TRACKING_KEY_PREFIX}${ip}`;
// Execute Lua script for atomic operations
const result = await redis.eval(
RATE_LIMIT_LUA_SCRIPT,
2, // Number of keys
countKey,
blockKey,
max,
windowSec
);
// Reset failure count on success
circuitBreaker.failureCount = 0;
// Parse the result (Lua returns a table with 1-based array indices)
return {
count: result[0],
remaining: result[1],
reset: result[2],
retryAfter: result[3],
limited: result[4]
};
} catch (err) {
retries++;
circuitBreaker.failureCount++;
circuitBreaker.lastFailure = Date.now();
if (circuitBreaker.failureCount >= 3) {
circuitBreaker.isOpen = true;
}
if (retries >= maxRetries) {
throw new Error('Max retries exceeded');
}
// Exponential backoff for retries - use provided delay or default
/* v8 ignore next */
const delay = retryDelayMs !== null ? retryDelayMs : 100 * Math.pow(2, retries);
await new Promise(resolve => setTimeout(resolve, delay));
}
}
}
function isExemptRoute(path, exemptRoutes = ['/health', '/status', '/favicon.ico']) {
return exemptRoutes.includes(path);
}
function createRateLimiter(redis, options = {}) {
const config = {
enabled: true,
max: 100,
windowMs: DEFAULT_WINDOW_MS,
exemptRoutes: ['/health', '/status', '/favicon.ico'],
logger: console,
retryDelayMs: null,
};
Object.assign(config, options);
const middleware = async function rateLimiter(req, res, next) {
if (!config.enabled) return next();
const { max, windowMs, exemptRoutes, logger, retryDelayMs } = config;
const windowSec = Math.floor(windowMs / 1000);
const path = req.url ? req.url.split('?')[0] : (req.path || '/');
if (isExemptRoute(path, exemptRoutes)) return next();
const ip = getClientIp(req);
const cost = getRequestCost(req);
const effectiveMax = Math.max(1, Math.floor(max / cost)); // Adjust max based on request cost
if (!ip || ip === 'unknown') {
logger.warn('Invalid IP detected', { ip, path });
return next();
}
let info;
let usingRedis = false;
try {
if (redis && redis.connected) {
info = await checkRedis(redis, ip, effectiveMax, windowSec, retryDelayMs);
usingRedis = true;
} else {
info = memFallback(ip, effectiveMax, windowMs);
}
} catch (err) {
logger.error('Redis error, falling back to memory', err.message);
info = memFallback(ip, effectiveMax, windowMs);
}
// Standard headers
res.setHeader('X-RateLimit-Limit', String(effectiveMax));
res.setHeader('X-RateLimit-Remaining', String(info.remaining));
res.setHeader('X-RateLimit-Reset', String(info.reset)); // epoch seconds
res.setHeader('X-RateLimit-Store', usingRedis ? 'redis' : 'memory');
if (info.limited) {
logger.warn('Rate limit exceeded', { ip, path, retryAfter: info.retryAfter });
res.setHeader('Retry-After', String(info.retryAfter));
res.writeHead(429, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({
error: 'Too Many Requests',
message: `Rate limit exceeded. Max ${max} requests per ${windowSec}s window.`,
retryAfter: info.retryAfter
}));
return;
}
next();
};
middleware.updateConfig = (updates) => {
Object.assign(config, updates);
};
return middleware;
}
module.exports = {
createRateLimiter,
memFallback,
checkRedis,
getClientIp,
isTrustedProxy,
getRequestCost,
getCircuitBreaker: () => circuitBreaker,
resetCircuitBreaker: () => {
circuitBreaker.isOpen = false;
circuitBreaker.failureCount = 0;
circuitBreaker.lastFailure = 0;
},
getMemStore: () => memStore,
resetMemStore: () => memStore.entries().forEach(([k]) => memStore.delete(k)),
triggerCleanup
};