LibreChat/api/server/middleware/limiters/shareLimiters.js
Danny Avila 09da878a47
🚰 fix: Throttle Shared Link Reads and Aggregate Audit Findings (#15605)
* 🪵 fix: Aggregate Audit Findings and Rate Limit Shared Link Reads

Audit-mode content filter rules wrote one `logger.info` per matching
fragment, and inspection deliberately continues past every finding. A
shared conversation full of distinct matching strings therefore produced
one log write per fragment, regenerated on every retrieval of
`GET /api/share/:shareId` — a public, unauthenticated route with no
limiter. The 4,096-entry inspection dedupe set is a memory bound, not an
event budget: once full, further values are inspected and logged again.

Audit metadata carries no inspected text — only rule, source, field and
provenance — so thousands of those writes were byte-identical lines.
Findings are now counted inside an aggregation scope and reported once
per distinct key with an `occurrences` count when the scope ends:

- `assertModelBoundContent` opens a scope when audit rules are configured,
  bounding one inspection pass (a single message's fragments).
- `assertConversationImportContentAllowed` opens the outer scope for
  import and shared-link snapshots, so per-message inspections nest into
  one report instead of one per message.
- `createShareContentPreflight` spans the shared-file metadata pass too.

Nested scopes reuse the outermost aggregation, and outside any scope the
previous immediate write is kept.

`GET /api/share/:shareId` re-inspects the whole snapshot on every request,
so it now carries IP and user limiters like the neighbouring fork route
(`SHARE_IP_MAX`/`SHARE_IP_WINDOW`, `SHARE_USER_MAX`/`SHARE_USER_WINDOW`,
`SHARE_VIOLATION_SCORE`); the user limiter skips anonymous viewers.

* 🔒 fix: Address Codex Findings on Share Audit Aggregation

- The aggregation key joined rule fields with a space, but the filter
  schema allows spaces in custom pattern ids and labels, so
  `{id: 'a', label: 'b c'}` and `{id: 'a b', label: 'c'}` collided on the
  same source/field/provenance and merged two rules' counts under one
  identity. Serialize the tuple instead.
- `SHARE_VIOLATION_SCORE` left unset reached `logViolation` as
  `undefined`, which selects that function's default score of 1 rather
  than the documented zero. With default ban settings a viewer refreshing
  a rate-limited shared link would be banned after 20 rejections. Default
  the score to 0 in code, not only in `.env.example`.
- `removePorts` returns a full IPv6 address, so an attacker holding a
  prefix could rotate the host portion for a fresh bucket on every
  request — and for anonymous viewers the IP limiter is the only bound.
  Derive the key through `ipKeyGenerator` so IPv6 clients group by /56.
2026-09-04 12:38:34 -04:00

98 lines
3.1 KiB
JavaScript

const rateLimit = require('express-rate-limit');
const { ipKeyGenerator } = rateLimit;
const { ViolationTypes } = require('librechat-data-provider');
const { limiterCache, removePorts } = require('@librechat/api');
const logViolation = require('~/cache/logViolation');
const getEnvironmentVariables = () => {
const SHARE_IP_MAX = parseInt(process.env.SHARE_IP_MAX) || 100;
const SHARE_IP_WINDOW = parseInt(process.env.SHARE_IP_WINDOW) || 1;
const SHARE_USER_MAX = parseInt(process.env.SHARE_USER_MAX) || 60;
const SHARE_USER_WINDOW = parseInt(process.env.SHARE_USER_WINDOW) || 1;
const SHARE_VIOLATION_SCORE = process.env.SHARE_VIOLATION_SCORE ?? 0;
const shareIpWindowMs = SHARE_IP_WINDOW * 60 * 1000;
const shareIpMax = SHARE_IP_MAX;
const shareIpWindowInMinutes = shareIpWindowMs / 60000;
const shareUserWindowMs = SHARE_USER_WINDOW * 60 * 1000;
const shareUserMax = SHARE_USER_MAX;
const shareUserWindowInMinutes = shareUserWindowMs / 60000;
return {
shareIpWindowMs,
shareIpMax,
shareIpWindowInMinutes,
shareUserWindowMs,
shareUserMax,
shareUserWindowInMinutes,
shareViolationScore: SHARE_VIOLATION_SCORE,
};
};
/**
* Groups IPv6 clients by subnet so an address rotation cannot mint a fresh
* bucket; this limiter is the only bound on anonymous shared-link retrieval.
*/
const shareIpKey = (req) => {
const address = removePorts(req);
return address == null ? address : ipKeyGenerator(address);
};
const createShareHandler = (ip = true) => {
const {
shareIpMax,
shareUserMax,
shareViolationScore,
shareIpWindowInMinutes,
shareUserWindowInMinutes,
} = getEnvironmentVariables();
return async (req, res) => {
const type = ViolationTypes.SHARE_LIMIT;
const errorMessage = {
type,
max: ip ? shareIpMax : shareUserMax,
limiter: ip ? 'ip' : 'user',
windowInMinutes: ip ? shareIpWindowInMinutes : shareUserWindowInMinutes,
};
await logViolation(req, res, type, errorMessage, shareViolationScore);
res.status(429).json({ message: 'Too many shared link requests. Try again later' });
};
};
/**
* Bounds shared-link retrieval, which re-inspects the whole shared snapshot
* on every request and is reachable without authentication.
*/
const createShareLimiters = () => {
const { shareIpWindowMs, shareIpMax, shareUserWindowMs, shareUserMax } =
getEnvironmentVariables();
const ipLimiterOptions = {
windowMs: shareIpWindowMs,
max: shareIpMax,
handler: createShareHandler(),
keyGenerator: shareIpKey,
store: limiterCache('share_ip_limiter'),
};
const userLimiterOptions = {
windowMs: shareUserWindowMs,
max: shareUserMax,
handler: createShareHandler(false),
skip: function (req) {
return req.user?.id == null;
},
keyGenerator: function (req) {
return req.user.id;
},
store: limiterCache('share_user_limiter'),
};
const shareIpLimiter = rateLimit(ipLimiterOptions);
const shareUserLimiter = rateLimit(userLimiterOptions);
return { shareIpLimiter, shareUserLimiter };
};
module.exports = { createShareLimiters };