From e37b284b9174968134e5fe3d7290e398b6781715 Mon Sep 17 00:00:00 2001 From: ABHAY PANDEY Date: Thu, 5 Nov 2026 09:42:59 +0530 Subject: [PATCH 1/3] feat(peering): rate-limit on-demand requests from peers --- .changeset/peering-on-demand.md | 17 +++++ CONFIGURATION.md | 2 + docs/PEERING.md | 19 +++++ resources/default-settings.yaml | 8 +++ src/@types/settings.ts | 6 ++ src/factories/message-handler-factory.ts | 8 +-- src/handlers/count-message-handler.ts | 29 ++++++-- src/handlers/neg-open-message-handler.ts | 30 +++++--- src/handlers/subscribe-message-handler.ts | 16 ++++- src/utils/peer-requests.ts | 49 +++++++++++++ src/utils/settings-config.ts | 1 + .../handlers/count-message-handler.spec.ts | 32 ++++++++- .../handlers/neg-open-message-handler.spec.ts | 30 +++++++- .../subscribe-message-handler.spec.ts | 54 ++++++++++++++ test/unit/utils/peer-requests.spec.ts | 72 +++++++++++++++++++ test/unit/utils/settings-config.spec.ts | 4 ++ 16 files changed, 351 insertions(+), 26 deletions(-) create mode 100644 .changeset/peering-on-demand.md create mode 100644 src/utils/peer-requests.ts create mode 100644 test/unit/utils/peer-requests.spec.ts diff --git a/.changeset/peering-on-demand.md b/.changeset/peering-on-demand.md new file mode 100644 index 000000000..7e4e56d35 --- /dev/null +++ b/.changeset/peering-on-demand.md @@ -0,0 +1,17 @@ +--- +"nostream": minor +--- + +feat(peering): rate-limit on-demand requests from authenticated peers + +Authenticated peers can request events outside their standing feed with a +normal `REQ`, `COUNT`, or ad-hoc `NEG-OPEN` session. Those requests continue to +use peer subscription and NIP-77 limits instead of client limits, and are now +bounded per peer pubkey by `limits.peer.request.rateLimits` (default 300 +requests/minute across `REQ`, `COUNT`, and `NEG-OPEN`). + +Refused `REQ`/`COUNT` calls receive `CLOSED` with a `rate-limited:` reason and +retry hint; refused `NEG-OPEN` sessions receive `NEG-ERR`. The limiter fails +closed when its store is unavailable, and unidentified clients are unaffected. +Per-peer request/event accounting and admin-console visibility are left to the +dedicated admin-console follow-up. diff --git a/CONFIGURATION.md b/CONFIGURATION.md index 132daea27..cd405d227 100644 --- a/CONFIGURATION.md +++ b/CONFIGURATION.md @@ -197,6 +197,8 @@ The settings below are listed in alphabetical order by name. Please keep this ta | limits.message.rateLimits[].rate | Maximum number of messages during period. | | limits.peer.message.rateLimits[].period | Rate limit period in milliseconds for authenticated peering peers. Separate from `limits.message`, so a peer feed never spends client message budget. | | limits.peer.message.rateLimits[].rate | Maximum peer messages during period. Defaults to 6000/min. | +| limits.peer.request.rateLimits[].period | Rate limit period in milliseconds for on-demand peer `REQ`, `COUNT`, and `NEG-OPEN` requests. Counted per peer pubkey. | +| limits.peer.request.rateLimits[].rate | Maximum on-demand peer requests during period. Defaults to 300/min. | | limits.peer.subscription.maxFilters | Maximum number of filters per peer subscription. Defaults to 100. Disabled when set to zero. | | limits.peer.subscription.maxFilterValues | Maximum number of values allowed in each peer filter. Defaults to 10000. Disabled when set to zero. | | limits.peer.subscription.maxLimit | Maximum REQ `limit` for peers. Defaults to 0 (no cap), so a peer can request a full feed. | diff --git a/docs/PEERING.md b/docs/PEERING.md index 1d242a75e..d5aa328f4 100644 --- a/docs/PEERING.md +++ b/docs/PEERING.md @@ -160,6 +160,25 @@ outbound sync path: the sync worker reconciles only the peer's advertised scopes and drops fetched events that fall outside them. Inbound feed scope enforcement remains part of the sync work that is still in progress. +## On-demand requests + +Beyond the standing feed and periodic reconciliation, an authenticated peer may +ask for specific events with an ordinary `REQ`, `COUNT`, or an ad-hoc `NEG-OPEN` +session. This covers an event outside the advertised scope — for example the +root of a thread, or a deeper backfill — without changing either relay's feed +configuration. + +These requests are served under the peer's normal subscription and NIP-77 +limits, not client limits, and are additionally throttled per peer pubkey by +`limits.peer.request.rateLimits`. The default budget is 300 requests per minute +across `REQ`, `COUNT`, and `NEG-OPEN`; a refused `REQ`/`COUNT` receives +`CLOSED` with a `rate-limited:` reason and a retry hint, and a refused +`NEG-OPEN` receives `NEG-ERR`. The limiter fails closed if its store is +unavailable. + +The same request pattern from a non-peer connection is handled as ordinary +client traffic and is not given the peer budget. + Only the public half of the keypair is ever visible on the wire. Inbound AUTH is verified by `AuthMessageHandler`: event id, signature, timestamp, challenge, and relay host. Outbound AUTH proves this relay's identity to the peer; it does not diff --git a/resources/default-settings.yaml b/resources/default-settings.yaml index 888b28737..12dc90b75 100755 --- a/resources/default-settings.yaml +++ b/resources/default-settings.yaml @@ -430,6 +430,14 @@ limits: - description: 6000 peer messages/min period: 60000 rate: 6000 + request: + # On-demand REQ/COUNT/NEG-OPEN requests, counted per peer pubkey rather + # than per IP. Separate from the generic message bucket so a feed's raw + # traffic does not consume the on-demand budget. + rateLimits: + - description: 300 peer on-demand requests/min + period: 60000 + rate: 300 message: # period is milliseconds (60000 = one minute) rateLimits: diff --git a/src/@types/settings.ts b/src/@types/settings.ts index 1788dd13c..871cd8f17 100644 --- a/src/@types/settings.ts +++ b/src/@types/settings.ts @@ -170,6 +170,7 @@ export interface ClientLimits { export interface PeerLimits { subscription?: ClientSubscriptionLimits message?: MessageLimits + request?: PeerRequestLimits } export interface MessageRateLimit extends RateLimit { @@ -181,6 +182,11 @@ export interface MessageLimits { ipWhitelist?: string[] } +/** Bounds on on-demand peer requests (REQ, COUNT, NEG-OPEN). */ +export interface PeerRequestLimits { + rateLimits?: RateLimit[] +} + export interface ConnectionLimits { rateLimits: RateLimit[] ipWhitelist?: string[] diff --git a/src/factories/message-handler-factory.ts b/src/factories/message-handler-factory.ts index 964460b0b..eb41efbd0 100644 --- a/src/factories/message-handler-factory.ts +++ b/src/factories/message-handler-factory.ts @@ -10,6 +10,7 @@ import { } from '../@types/repositories' import { RedisAdapter } from '../adapters/redis-adapter' import { getCacheClient } from '../cache/client' +import { getMasterDbClient } from '../database/client' import { AuthMessageHandler } from '../handlers/auth-message-handler' import { CountMessageHandler } from '../handlers/count-message-handler' import { EventMessageHandler } from '../handlers/event-message-handler' @@ -18,9 +19,8 @@ import { NegMsgMessageHandler } from '../handlers/neg-msg-message-handler' import { NegOpenMessageHandler } from '../handlers/neg-open-message-handler' import { SubscribeMessageHandler } from '../handlers/subscribe-message-handler' import { UnsubscribeMessageHandler } from '../handlers/unsubscribe-message-handler' -import { eventStrategyFactory } from './event-strategy-factory' -import { getMasterDbClient } from '../database/client' import { UserSubscriptionRepository } from '../repositories/user-subscription-repository' +import { eventStrategyFactory } from './event-strategy-factory' import { rateLimiterFactory } from './rate-limiter-factory' import { createSettings } from './settings-factory' import { wotGraphServiceFactory } from './wot-graph-service-factory' @@ -85,11 +85,11 @@ export const messageHandlerFactory = case MessageType.CLOSE: return new UnsubscribeMessageHandler(adapter) case MessageType.COUNT: - return new CountMessageHandler(adapter, eventRepository, createSettings) + return new CountMessageHandler(adapter, eventRepository, createSettings, rateLimiterFactory) case MessageType.AUTH: return new AuthMessageHandler(adapter, createSettings) case MessageType.NEG_OPEN: - return new NegOpenMessageHandler(adapter, eventRepository, createSettings) + return new NegOpenMessageHandler(adapter, eventRepository, createSettings, rateLimiterFactory) case MessageType.NEG_MSG: return new NegMsgMessageHandler(adapter, createSettings) case MessageType.NEG_CLOSE: diff --git a/src/handlers/count-message-handler.ts b/src/handlers/count-message-handler.ts index a1db59215..a08dfbe07 100644 --- a/src/handlers/count-message-handler.ts +++ b/src/handlers/count-message-handler.ts @@ -1,17 +1,20 @@ import { equals, uniqWith } from 'ramda' import { IWebSocketAdapter } from '../@types/adapters' +import { Factory } from '../@types/base' import { IMessageHandler } from '../@types/message-handlers' import { CountMessage } from '../@types/messages' import { IEventRepository } from '../@types/repositories' import { Settings } from '../@types/settings' import { SubscriptionFilter, SubscriptionId } from '../@types/subscription' +import { IRateLimiter } from '../@types/utils' import { WebSocketAdapterEvent } from '../constants/adapter' import { createLogger } from '../factories/logger-factory' import { countFilterValues } from '../utils/filter' import { createClosedMessage, createCountResultMessage } from '../utils/messages' import { isCountAuthorized } from '../utils/nip42' import { subscriptionLimitsFor } from '../utils/peer-limits' +import { getPeerRequestRetryAfterMs } from '../utils/peer-requests' const debug = createLogger('count-message-handler') @@ -20,22 +23,37 @@ export class CountMessageHandler implements IMessageHandler { private readonly webSocket: IWebSocketAdapter, private readonly eventRepository: IEventRepository, private readonly settings: () => Settings, + private readonly rateLimiter?: Factory, ) {} public async handleMessage(message: CountMessage): Promise { const queryId = message[1] const countEnabled = this.settings().nip45?.enabled ?? true if (!countEnabled) { - this.webSocket.emit(WebSocketAdapterEvent.Message, createClosedMessage(queryId, 'COUNT is disabled by relay configuration')) + this.webSocket.emit( + WebSocketAdapterEvent.Message, + createClosedMessage(queryId, 'COUNT is disabled by relay configuration'), + ) return } + const peerPubkey = this.webSocket.getPeerPubkey() + if (peerPubkey && this.rateLimiter) { + const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, this.settings(), peerPubkey, 'COUNT') + if (retryAfterMs !== undefined) { + this.webSocket.emit( + WebSocketAdapterEvent.Message, + createClosedMessage(queryId, 'rate-limited: peer request limit exceeded', String(retryAfterMs)), + ) + return + } + } + // Some clients send the same filter more than once. Bound the raw list // before deduplicating it, since uniqWith() is O(n^2) and the schema no // longer caps filter counts so peer limits can be larger. const incomingFilters = message.slice(2) as SubscriptionFilter[] - const maxFilters = - subscriptionLimitsFor(this.settings(), this.webSocket.getPeerPubkey() !== undefined)?.maxFilters ?? 0 + const maxFilters = subscriptionLimitsFor(this.settings(), peerPubkey !== undefined)?.maxFilters ?? 0 if (maxFilters > 0 && incomingFilters.length > maxFilters) { this.webSocket.emit( WebSocketAdapterEvent.Message, @@ -68,10 +86,7 @@ export class CountMessageHandler implements IMessageHandler { } private canCount(queryId: SubscriptionId, filters: SubscriptionFilter[]): string | undefined { - const subscriptionLimits = subscriptionLimitsFor( - this.settings(), - this.webSocket.getPeerPubkey() !== undefined, - ) + const subscriptionLimits = subscriptionLimitsFor(this.settings(), this.webSocket.getPeerPubkey() !== undefined) const maxFilters = subscriptionLimits?.maxFilters ?? 0 if (maxFilters > 0 && filters.length > maxFilters) { diff --git a/src/handlers/neg-open-message-handler.ts b/src/handlers/neg-open-message-handler.ts index eef934bf4..7b46af5c9 100644 --- a/src/handlers/neg-open-message-handler.ts +++ b/src/handlers/neg-open-message-handler.ts @@ -1,18 +1,21 @@ import { IWebSocketAdapter } from '../@types/adapters' -import { createNegErrMessage, createNegMsgMessage } from '../utils/messages' -import { getNip77Limits, isNip77Active, NEGENTROPY_FRAME_SIZE_LIMIT } from '../utils/nip77' -import { INegentropySessions } from '../@types/negentropy' -import { Negentropy, NegentropyStorageVector } from '../utils/negentropy' -import { IEventRepository, ReconciliationItem } from '../@types/repositories' +import { Factory } from '../@types/base' import { IMessageHandler } from '../@types/message-handlers' import { NegOpenMessage, OutgoingMessage } from '../@types/messages' +import { INegentropySessions } from '../@types/negentropy' +import { IEventRepository, ReconciliationItem } from '../@types/repositories' import { Settings } from '../@types/settings' import { SubscriptionFilter, SubscriptionId } from '../@types/subscription' +import { IRateLimiter } from '../@types/utils' import { WebSocketAdapterEvent } from '../constants/adapter' -import { countFilterValues } from '../utils/filter' import { createLogger } from '../factories/logger-factory' +import { countFilterValues } from '../utils/filter' +import { createNegErrMessage, createNegMsgMessage } from '../utils/messages' +import { Negentropy, NegentropyStorageVector } from '../utils/negentropy' import { isReconciliationAuthorized } from '../utils/nip42' +import { getNip77Limits, isNip77Active, NEGENTROPY_FRAME_SIZE_LIMIT } from '../utils/nip77' import { subscriptionLimitsFor } from '../utils/peer-limits' +import { getPeerRequestRetryAfterMs } from '../utils/peer-requests' const logger = createLogger('neg-open-message-handler') @@ -25,6 +28,7 @@ export class NegOpenMessageHandler implements IMessageHandler { private readonly webSocket: IWebSocketAdapter, private readonly eventRepository: IEventRepository, private readonly settings: () => Settings, + private readonly rateLimiter?: Factory, ) {} public async handleMessage(message: NegOpenMessage): Promise { @@ -40,6 +44,15 @@ export class NegOpenMessageHandler implements IMessageHandler { return } + const peerPubkey = this.webSocket.getPeerPubkey() + if (peerPubkey && this.rateLimiter) { + const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, settings, peerPubkey, 'NEG-OPEN') + if (retryAfterMs !== undefined) { + this.reject(sessions, subscriptionId, `rate-limited: retry after ${retryAfterMs} ms`) + return + } + } + const rejection = this.getRejection(subscriptionId, filter, initialMessage) if (rejection) { logger('NEG-OPEN %s with %o rejected: %s', subscriptionId, filter, rejection) @@ -123,10 +136,7 @@ export class NegOpenMessageHandler implements IMessageHandler { initialMessage: Buffer, ): string | undefined { const settings = this.settings() - const subscriptionLimits = subscriptionLimitsFor( - settings, - this.webSocket.getPeerPubkey() !== undefined, - ) + const subscriptionLimits = subscriptionLimitsFor(settings, this.webSocket.getPeerPubkey() !== undefined) const maxFilterValues = subscriptionLimits?.maxFilterValues ?? 0 if (maxFilterValues > 0 && countFilterValues(filter) > maxFilterValues) { diff --git a/src/handlers/subscribe-message-handler.ts b/src/handlers/subscribe-message-handler.ts index a71a503bf..31ae10b0c 100644 --- a/src/handlers/subscribe-message-handler.ts +++ b/src/handlers/subscribe-message-handler.ts @@ -26,6 +26,7 @@ import { Settings } from '../@types/settings' import { SubscribeMessage } from '../@types/messages' import { WebSocketAdapterEvent } from '../constants/adapter' import { subscriptionLimitsFor } from '../utils/peer-limits' +import { getPeerRequestRetryAfterMs } from '../utils/peer-requests' const logger = createLogger('subscribe-message-handler') @@ -53,11 +54,22 @@ export class SubscribeMessageHandler implements IMessageHandler, IAbortable { const subscriptionId = message[1] this.activeSubscriptionId = subscriptionId const incomingFilters = message.slice(2) as SubscriptionFilter[] + const peerPubkey = this.webSocket.getPeerPubkey() + + if (peerPubkey) { + const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, this.settings(), peerPubkey, 'REQ') + if (retryAfterMs !== undefined) { + this.webSocket.emit( + WebSocketAdapterEvent.Message, + createClosedMessage(subscriptionId, 'rate-limited: peer request limit exceeded', String(retryAfterMs)), + ) + return + } + } // Bound before uniqWith(): deduplicating an unbounded list is O(n^2). The // schema no longer caps filter counts so peer limits can be larger. - const maxFilters = - subscriptionLimitsFor(this.settings(), this.webSocket.getPeerPubkey() !== undefined)?.maxFilters ?? 0 + const maxFilters = subscriptionLimitsFor(this.settings(), peerPubkey !== undefined)?.maxFilters ?? 0 if (maxFilters > 0 && incomingFilters.length > maxFilters) { const reason = `Too many filters: Number of filters per susbscription must be less then or equal to ${maxFilters}` logger('subscription %s with %o rejected: %s', subscriptionId, incomingFilters, reason) diff --git a/src/utils/peer-requests.ts b/src/utils/peer-requests.ts new file mode 100644 index 000000000..ada591378 --- /dev/null +++ b/src/utils/peer-requests.ts @@ -0,0 +1,49 @@ +import { Factory } from '../@types/base' +import { Settings } from '../@types/settings' +import { IRateLimiter } from '../@types/utils' +import { createLogger } from '../factories/logger-factory' + +const logger = createLogger('peer-requests') + +/** Request kinds that consume the on-demand peer budget. */ +export type PeerRequestType = 'REQ' | 'COUNT' | 'NEG-OPEN' + +const FALLBACK_RETRY_AFTER_MS = 60_000 + +/** + * Per-peer-pubkey on-demand request limit. Returns a retry-after in ms when the + * request is refused, or undefined when allowed. The limiter is fail-closed: + * an unavailable store must not turn a peer credential into unbounded egress. + */ +export const getPeerRequestRetryAfterMs = async ( + rateLimiter: Factory, + settings: Settings, + peerPubkey: string, + type: PeerRequestType, +): Promise => { + const rateLimits = settings.limits?.peer?.request?.rateLimits + if (!Array.isArray(rateLimits) || rateLimits.length === 0) { + return undefined + } + + const limiter = rateLimiter() + + for (const { period, rate } of rateLimits) { + try { + const result = await limiter.hit(`${peerPubkey}:peer-request:${period}`, 1, { period, rate }) + if (!result.limited) { + continue + } + + logger('rate limited peer %s (%s): %d requests / %d ms exceeded', peerPubkey, type, rate, period) + + return result.retryAfterMs ?? Math.max(1, Math.ceil(period)) + } catch (error) { + logger.error('peer request rate limiter unavailable for %s (%s): %o', peerPubkey, type, error) + + return FALLBACK_RETRY_AFTER_MS + } + } + + return undefined +} diff --git a/src/utils/settings-config.ts b/src/utils/settings-config.ts index 8274d0ee3..7f326f4e4 100644 --- a/src/utils/settings-config.ts +++ b/src/utils/settings-config.ts @@ -1215,6 +1215,7 @@ export const validateSettings = (settings: Settings): ValidationIssue[] => { if (limits) { validateRateLimitPeriods(limits.event?.rateLimits, 'limits.event.rateLimits', issues) validateRateLimitPeriods(limits.peer?.message?.rateLimits, 'limits.peer.message.rateLimits', issues) + validateRateLimitPeriods(limits.peer?.request?.rateLimits, 'limits.peer.request.rateLimits', issues) validateRateLimitPeriods(limits.message?.rateLimits, 'limits.message.rateLimits', issues) validateRateLimitPeriods(limits.connection?.rateLimits, 'limits.connection.rateLimits', issues) validateRateLimitPeriods(limits.invoice?.rateLimits, 'limits.invoice.rateLimits', issues) diff --git a/test/unit/handlers/count-message-handler.spec.ts b/test/unit/handlers/count-message-handler.spec.ts index 367ba39c2..9d930dcae 100644 --- a/test/unit/handlers/count-message-handler.spec.ts +++ b/test/unit/handlers/count-message-handler.spec.ts @@ -18,6 +18,8 @@ describe('CountMessageHandler', () => { let handler: CountMessageHandler let eventRepository: IEventRepository let sandbox: Sinon.SinonSandbox + let rateLimiterHitStub: Sinon.SinonStub + let rateLimiterFactory: Sinon.SinonStub beforeEach(() => { sandbox = Sinon.createSandbox() @@ -26,6 +28,9 @@ describe('CountMessageHandler', () => { countByFilters: sandbox.stub().resolves(7), } as any + rateLimiterHitStub = sandbox.stub().resolves({ limited: false }) + rateLimiterFactory = sandbox.stub().returns({ hit: rateLimiterHitStub }) + webSocket = new EventEmitter() as any webSocket.getPeerPubkey = sandbox.stub().returns(undefined) @@ -38,7 +43,7 @@ describe('CountMessageHandler', () => { }, }, }, - }) as Settings) + }) as Settings, rateLimiterFactory) }) afterEach(() => { @@ -101,7 +106,7 @@ describe('CountMessageHandler', () => { client: { subscription: { maxFilters: 1, maxSubscriptionIdLength: 256 } }, peer: { subscription: { maxFilters: 5, maxSubscriptionIdLength: 256 } }, }, - }) as Settings) + }) as Settings, rateLimiterFactory) ;(webSocket.getPeerPubkey as Sinon.SinonStub).returns('a'.repeat(64)) const message = [MessageType.COUNT, 'q1', { kinds: [1] }, { kinds: [2] }] as any @@ -112,6 +117,29 @@ describe('CountMessageHandler', () => { expect(webSocketOnMessageStub).to.have.been.calledOnceWithExactly([MessageType.COUNT, 'q1', { count: 7 }]) }) + it('closes a peer count when the on-demand request limit is exceeded', async () => { + const peer = 'a'.repeat(64) + ;(webSocket.getPeerPubkey as Sinon.SinonStub).returns(peer) + rateLimiterHitStub.resolves({ limited: true, retryAfterMs: 321 }) + handler = new CountMessageHandler(webSocket, eventRepository, () => ({ + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + }) as Settings, rateLimiterFactory) + + await handler.handleMessage([MessageType.COUNT, 'q1', { kinds: [1] }] as any) + + expect(rateLimiterHitStub).to.have.been.calledOnceWithExactly(`${peer}:peer-request:60000`, 1, { + period: 60_000, + rate: 1, + }) + expect(eventRepository.countByFilters).not.to.have.been.called + expect(webSocketOnMessageStub).to.have.been.calledOnceWithExactly([ + MessageType.CLOSED, + 'q1', + 'rate-limited: peer request limit exceeded', + '321', + ]) + }) + it('bounds raw filters before deduplicating them', async () => { handler = new CountMessageHandler(webSocket, eventRepository, () => ({ limits: { client: { subscription: { maxFilters: 10, maxSubscriptionIdLength: 256 } } }, diff --git a/test/unit/handlers/neg-open-message-handler.spec.ts b/test/unit/handlers/neg-open-message-handler.spec.ts index f91e4ad52..8fc4765ec 100644 --- a/test/unit/handlers/neg-open-message-handler.spec.ts +++ b/test/unit/handlers/neg-open-message-handler.spec.ts @@ -51,6 +51,8 @@ describe('NegOpenMessageHandler', () => { let settings: Settings let emitted: Sinon.SinonStub let handler: NegOpenMessageHandler + let rateLimiterHitStub: Sinon.SinonStub + let rateLimiterFactory: Sinon.SinonStub const open = (id = 'sync1', filter: any = { kinds: [1] }, hex = emptyClientMessageHex) => handler.handleMessage([MessageType.NEG_OPEN, id, filter, hex] as any) @@ -70,7 +72,10 @@ describe('NegOpenMessageHandler', () => { emitted = sandbox.stub() webSocket.on(WebSocketAdapterEvent.Message, emitted) - handler = new NegOpenMessageHandler(webSocket, eventRepository, () => settings) + rateLimiterHitStub = sandbox.stub().resolves({ limited: false }) + rateLimiterFactory = sandbox.stub().returns({ hit: rateLimiterHitStub }) + + handler = new NegOpenMessageHandler(webSocket, eventRepository, () => settings, rateLimiterFactory) }) afterEach(() => { @@ -231,6 +236,29 @@ describe('NegOpenMessageHandler', () => { expect(emitted.firstCall.args[0][0]).to.equal(MessageType.NEG_MSG) expect(findReconciliationItems).to.have.been.called }) + + it('replies NEG-ERR when the peer on-demand request limit is exceeded', async () => { + const peer = 'a'.repeat(64) + settings = { + nip77: { enabled: true }, + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + } as Settings + webSocket.getPeerPubkey = () => peer + rateLimiterHitStub.resolves({ limited: true, retryAfterMs: 456 }) + + await open() + + expect(rateLimiterHitStub).to.have.been.calledOnceWithExactly(`${peer}:peer-request:60000`, 1, { + period: 60_000, + rate: 1, + }) + expect(findReconciliationItems).not.to.have.been.called + expect(emitted).to.have.been.calledOnceWithExactly([ + MessageType.NEG_ERR, + 'sync1', + 'rate-limited: retry after 456 ms', + ]) + }) }) describe('NIP-42', () => { diff --git a/test/unit/handlers/subscribe-message-handler.spec.ts b/test/unit/handlers/subscribe-message-handler.spec.ts index af767f411..36af248f3 100644 --- a/test/unit/handlers/subscribe-message-handler.spec.ts +++ b/test/unit/handlers/subscribe-message-handler.spec.ts @@ -139,6 +139,41 @@ describe('SubscribeMessageHandler', () => { expect(webSocketOnSubscribeStub).not.to.have.been.called }) + it('closes a peer subscription when the on-demand request limit is exceeded', async () => { + const peer = 'a'.repeat(64) + ;(webSocket.getPeerPubkey as Sinon.SinonStub).returns(peer) + settingsFactory.returns({ + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + }) + rateLimiterHitStub.resolves({ limited: true, retryAfterMs: 123 }) + message = [MessageType.REQ, subscriptionId, ...filters] as any + + await handler.handleMessage(message) + + expect(rateLimiterHitStub).to.have.been.calledOnceWithExactly(`${peer}:peer-request:60000`, 1, { + period: 60_000, + rate: 1, + }) + expect(webSocketOnMessageStub).to.have.been.calledOnceWithExactly([ + 'CLOSED', + subscriptionId, + 'rate-limited: peer request limit exceeded', + '123', + ]) + expect(fetchAndSendStub).not.to.have.been.called + }) + + it('does not apply peer request limits to ordinary clients', async () => { + settingsFactory.returns({ + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + }) + message = [MessageType.REQ, subscriptionId, ...filters] as any + + await handler.handleMessage(message) + + expect(rateLimiterHitStub).not.to.have.been.called + }) + it('emits subscribe event if subscription is accepted', async () => { canSubscribeStub.returns(undefined) message = [MessageType.REQ, subscriptionId, ...filters] as any @@ -578,6 +613,25 @@ describe('SubscribeMessageHandler', () => { }) }) + it('serves an out-of-scope event to a peer by id', async () => { + isClientSubscribedToEventStub.returns(always(true)) + ;(webSocket.getPeerPubkey as Sinon.SinonStub).returns('a'.repeat(64)) + settingsFactory.returns({ + peering: { enabled: true, scopes: [{ kinds: [7] }] }, + limits: { peer: { subscription: { maxLimit: 0 } } }, + }) + const idFilter = [{ ids: [event.id] }] + + const promise = (handler as any).fetchAndSend(subscriptionId, idFilter) + + stream.write(toDbEvent(event)) + stream.end() + + await promise + + expect(webSocketOnMessageStub).to.have.been.calledWith([MessageType.EVENT, subscriptionId, event]) + }) + it('sends event if client is subscribed', async () => { isClientSubscribedToEventStub.returns(always(true)) diff --git a/test/unit/utils/peer-requests.spec.ts b/test/unit/utils/peer-requests.spec.ts new file mode 100644 index 000000000..2a4b38197 --- /dev/null +++ b/test/unit/utils/peer-requests.spec.ts @@ -0,0 +1,72 @@ +import chai from 'chai' +import Sinon from 'sinon' +import sinonChai from 'sinon-chai' + +import { Settings } from '../../../src/@types/settings' +import { getPeerRequestRetryAfterMs } from '../../../src/utils/peer-requests' + +chai.use(sinonChai) +const { expect } = chai + +describe('peer on-demand request limits', () => { + let sandbox: Sinon.SinonSandbox + let hit: Sinon.SinonStub + const factory = () => ({ hit }) + + beforeEach(() => { + sandbox = Sinon.createSandbox() + hit = sandbox.stub().resolves({ limited: false }) + }) + + afterEach(() => { + sandbox.restore() + }) + + it('does nothing when no peer request limits are configured', async () => { + const retryAfter = await getPeerRequestRetryAfterMs(factory, {} as Settings, 'a'.repeat(64), 'REQ') + + expect(retryAfter).to.equal(undefined) + expect(hit).not.to.have.been.called + }) + + it('allows a request under the limit', async () => { + const retryAfter = await getPeerRequestRetryAfterMs( + factory, + { limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 2 }] } } } } as Settings, + 'a'.repeat(64), + 'REQ', + ) + + expect(retryAfter).to.equal(undefined) + expect(hit).to.have.been.calledOnceWithExactly('a'.repeat(64) + ':peer-request:60000', 1, { + period: 60_000, + rate: 2, + }) + }) + + it('returns the limiter retry-after when refused', async () => { + hit.resolves({ limited: true, retryAfterMs: 250 }) + + const retryAfter = await getPeerRequestRetryAfterMs( + factory, + { limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } } } as Settings, + 'a'.repeat(64), + 'NEG-OPEN', + ) + + expect(retryAfter).to.equal(250) + }) + + it('fails closed when the limiter is unavailable', async () => { + hit.rejects(new Error('redis down')) + + const retryAfter = await getPeerRequestRetryAfterMs( + factory, + { limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } } } as Settings, + 'a'.repeat(64), + 'COUNT', + ) + + expect(retryAfter).to.equal(60_000) + }) +}) diff --git a/test/unit/utils/settings-config.spec.ts b/test/unit/utils/settings-config.spec.ts index 3c723f05c..8bd0cf5e3 100644 --- a/test/unit/utils/settings-config.spec.ts +++ b/test/unit/utils/settings-config.spec.ts @@ -404,6 +404,10 @@ describe('settings-config', () => { issuePath: 'limits.peer.message.rateLimits[0].period', limits: { peer: { message: { rateLimits: [{ period: 0, rate: 1 }] } } }, }, + { + issuePath: 'limits.peer.request.rateLimits[0].period', + limits: { peer: { request: { rateLimits: [{ period: 0, rate: 1 }] } } }, + }, { issuePath: 'limits.connection.rateLimits[0].period', limits: { connection: { rateLimits: [{ period: -1, rate: 1 }] } }, From e16324f76db66d30d40604a50e9aa274946ae844 Mon Sep 17 00:00:00 2001 From: ABHAY PANDEY Date: Thu, 5 Nov 2026 18:46:00 +0530 Subject: [PATCH 2/3] fix(peering): close subscriptions and NIP-77 sessions during limiter waits --- src/@types/adapters.ts | 2 + src/adapters/web-socket-adapter.ts | 2 +- src/handlers/neg-open-message-handler.ts | 29 ++++++++---- src/handlers/subscribe-message-handler.ts | 9 ++++ src/handlers/unsubscribe-message-handler.ts | 5 +-- .../handlers/neg-open-message-handler.spec.ts | 24 ++++++++++ .../subscribe-message-handler.spec.ts | 44 +++++++++++++++---- .../unsubscribe-message-handler.spec.ts | 17 ++++--- 8 files changed, 101 insertions(+), 31 deletions(-) diff --git a/src/@types/adapters.ts b/src/@types/adapters.ts index 9e44c6b0f..36c8005b0 100644 --- a/src/@types/adapters.ts +++ b/src/@types/adapters.ts @@ -37,6 +37,8 @@ export type IWebSocketAdapter = EventEmitter & { drainAndClose(reason?: string): void /** NIP-77 sessions of this connection. */ getNegentropySessions(): INegentropySessions + /** Removes a subscription and aborts any in-flight read still serving it. */ + endSubscription(subscriptionId: string): void } export interface ICacheAdapter { diff --git a/src/adapters/web-socket-adapter.ts b/src/adapters/web-socket-adapter.ts index f4de701c2..2299b9745 100644 --- a/src/adapters/web-socket-adapter.ts +++ b/src/adapters/web-socket-adapter.ts @@ -417,7 +417,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter return createNoticeMessage('rate limited') } - private endSubscription(subscriptionId: SubscriptionId): void { + public endSubscription(subscriptionId: SubscriptionId): void { this.abortInFlightSubscriptionReads(subscriptionId) if (this.subscriptions.has(subscriptionId)) { this.onUnsubscribed(subscriptionId) diff --git a/src/handlers/neg-open-message-handler.ts b/src/handlers/neg-open-message-handler.ts index 7b46af5c9..b56890493 100644 --- a/src/handlers/neg-open-message-handler.ts +++ b/src/handlers/neg-open-message-handler.ts @@ -44,15 +44,6 @@ export class NegOpenMessageHandler implements IMessageHandler { return } - const peerPubkey = this.webSocket.getPeerPubkey() - if (peerPubkey && this.rateLimiter) { - const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, settings, peerPubkey, 'NEG-OPEN') - if (retryAfterMs !== undefined) { - this.reject(sessions, subscriptionId, `rate-limited: retry after ${retryAfterMs} ms`) - return - } - } - const rejection = this.getRejection(subscriptionId, filter, initialMessage) if (rejection) { logger('NEG-OPEN %s with %o rejected: %s', subscriptionId, filter, rejection) @@ -62,6 +53,9 @@ export class NegOpenMessageHandler implements IMessageHandler { const { maxEventsPerSession, maxSessionsPerConnection, sessionIdleTimeoutMs } = getNip77Limits(settings) + // Claim the id before the first await. A NEG-CLOSE (or a replacement + // NEG-OPEN) that arrives while the limiter is pending then owns the id, + // and this handler must not open a session after it. const token = sessions.reserve(subscriptionId, maxSessionsPerConnection) if (!token) { this.reject( @@ -72,6 +66,23 @@ export class NegOpenMessageHandler implements IMessageHandler { return } + const peerPubkey = this.webSocket.getPeerPubkey() + if (peerPubkey && this.rateLimiter) { + const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, settings, peerPubkey, 'NEG-OPEN') + if (retryAfterMs !== undefined) { + sessions.endRead(token) + if (sessions.isCurrent(subscriptionId, token)) { + this.reject(sessions, subscriptionId, `rate-limited: retry after ${retryAfterMs} ms`) + } + return + } + } + + if (!sessions.isCurrent(subscriptionId, token)) { + sessions.endRead(token) + return + } + let items: ReconciliationItem[] try { // One row past the limit tells us the set is too big without loading all of it. diff --git a/src/handlers/subscribe-message-handler.ts b/src/handlers/subscribe-message-handler.ts index 31ae10b0c..8c36bbe0d 100644 --- a/src/handlers/subscribe-message-handler.ts +++ b/src/handlers/subscribe-message-handler.ts @@ -59,12 +59,21 @@ export class SubscribeMessageHandler implements IMessageHandler, IAbortable { if (peerPubkey) { const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, this.settings(), peerPubkey, 'REQ') if (retryAfterMs !== undefined) { + // A reused subscription id must not keep its old filters/read alive + // after we tell the peer this request was refused. + this.webSocket.endSubscription(subscriptionId) this.webSocket.emit( WebSocketAdapterEvent.Message, createClosedMessage(subscriptionId, 'rate-limited: peer request limit exceeded', String(retryAfterMs)), ) return } + + // CLOSE may have arrived while the limiter was pending. endSubscription + // aborted this handler's read; do not register the subscription again. + if (this.abortController.signal.aborted) { + return + } } // Bound before uniqWith(): deduplicating an unbounded list is O(n^2). The diff --git a/src/handlers/unsubscribe-message-handler.ts b/src/handlers/unsubscribe-message-handler.ts index 82f2b18ce..18e2e5f01 100644 --- a/src/handlers/unsubscribe-message-handler.ts +++ b/src/handlers/unsubscribe-message-handler.ts @@ -1,12 +1,11 @@ -import { IMessageHandler } from '../@types/message-handlers' import { IWebSocketAdapter } from '../@types/adapters' +import { IMessageHandler } from '../@types/message-handlers' import { UnsubscribeMessage } from '../@types/messages' -import { WebSocketAdapterEvent } from '../constants/adapter' export class UnsubscribeMessageHandler implements IMessageHandler { public constructor(private readonly webSocket: IWebSocketAdapter) {} public async handleMessage(message: UnsubscribeMessage): Promise { - this.webSocket.emit(WebSocketAdapterEvent.Unsubscribe, message[1]) + this.webSocket.endSubscription(message[1]) } } diff --git a/test/unit/handlers/neg-open-message-handler.spec.ts b/test/unit/handlers/neg-open-message-handler.spec.ts index 8fc4765ec..00fd94e32 100644 --- a/test/unit/handlers/neg-open-message-handler.spec.ts +++ b/test/unit/handlers/neg-open-message-handler.spec.ts @@ -259,6 +259,30 @@ describe('NegOpenMessageHandler', () => { 'rate-limited: retry after 456 ms', ]) }) + + it('does not open a session closed while the limiter is pending', async () => { + const peer = 'a'.repeat(64) + let releaseLimit: ((result: { limited: boolean }) => void) | undefined + settings = { + nip77: { enabled: true }, + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + } as Settings + webSocket.getPeerPubkey = () => peer + rateLimiterHitStub.returns( + new Promise((resolve) => { + releaseLimit = resolve + }), + ) + + const pending = open() + sessions.close('sync1') + releaseLimit?.({ limited: false }) + await pending + + expect(findReconciliationItems).not.to.have.been.called + expect(emitted).not.to.have.been.called + expect(sessions.getSessionIds()).to.deep.equal([]) + }) }) describe('NIP-42', () => { diff --git a/test/unit/handlers/subscribe-message-handler.spec.ts b/test/unit/handlers/subscribe-message-handler.spec.ts index 36af248f3..554478386 100644 --- a/test/unit/handlers/subscribe-message-handler.spec.ts +++ b/test/unit/handlers/subscribe-message-handler.spec.ts @@ -1,22 +1,21 @@ -import { always } from 'ramda' import chai from 'chai' import chaiAsPromised from 'chai-as-promised' import EventEmitter from 'events' +import { always } from 'ramda' import Sinon from 'sinon' import sinonChai from 'sinon-chai' - +import { PassThrough } from 'stream' +import { IWebSocketAdapter } from '../../../src/@types/adapters' +import { Event } from '../../../src/@types/event' import { IAbortable, IMessageHandler } from '../../../src/@types/message-handlers' import { MessageType, SubscribeMessage } from '../../../src/@types/messages' -import { SubscriptionFilter, SubscriptionId } from '../../../src/@types/subscription' -import * as eventUtils from '../../../src/utils/event' -import { Event } from '../../../src/@types/event' -import { EventTags } from '../../../src/constants/base' import { IEventRepository, IInviteCodeRepository } from '../../../src/@types/repositories' +import { SubscriptionFilter, SubscriptionId } from '../../../src/@types/subscription' import { IRateLimiter } from '../../../src/@types/utils' -import { IWebSocketAdapter } from '../../../src/@types/adapters' -import { PassThrough } from 'stream' -import { SubscribeMessageHandler } from '../../../src/handlers/subscribe-message-handler' import { WebSocketAdapterEvent } from '../../../src/constants/adapter' +import { EventTags } from '../../../src/constants/base' +import { SubscribeMessageHandler } from '../../../src/handlers/subscribe-message-handler' +import * as eventUtils from '../../../src/utils/event' chai.use(sinonChai) chai.use(chaiAsPromised) @@ -50,6 +49,7 @@ describe('SubscribeMessageHandler', () => { let rateLimiter: IRateLimiter let rateLimiterHitStub: Sinon.SinonStub let rateLimiterFactory: Sinon.SinonStub + let endSubscriptionStub: Sinon.SinonStub let sandbox: Sinon.SinonSandbox @@ -62,6 +62,8 @@ describe('SubscribeMessageHandler', () => { webSocket.getSubscriptions = webSocketGetSubscriptionsStub webSocket.getPeerPubkey = sandbox.stub().returns(undefined) webSocket.waitForWritable = sandbox.stub().resolves() + endSubscriptionStub = sandbox.stub() + webSocket.endSubscription = endSubscriptionStub settingsFactory = sandbox.stub() stream = new PassThrough({ objectMode: true, @@ -161,6 +163,30 @@ describe('SubscribeMessageHandler', () => { '123', ]) expect(fetchAndSendStub).not.to.have.been.called + expect(endSubscriptionStub).to.have.been.calledOnceWithExactly(subscriptionId) + }) + + it('does not register a subscription closed while the limiter is pending', async () => { + const peer = 'a'.repeat(64) + let releaseLimit: ((result: { limited: boolean }) => void) | undefined + ;(webSocket.getPeerPubkey as Sinon.SinonStub).returns(peer) + settingsFactory.returns({ + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + }) + rateLimiterHitStub.returns( + new Promise((resolve) => { + releaseLimit = resolve + }), + ) + message = [MessageType.REQ, subscriptionId, ...filters] as any + + const pending = handler.handleMessage(message) + ;(handler as any).abort() + releaseLimit?.({ limited: false }) + await pending + + expect(webSocketOnSubscribeStub).not.to.have.been.called + expect(fetchAndSendStub).not.to.have.been.called }) it('does not apply peer request limits to ordinary clients', async () => { diff --git a/test/unit/handlers/unsubscribe-message-handler.spec.ts b/test/unit/handlers/unsubscribe-message-handler.spec.ts index d8b3cbbb6..3889454bb 100644 --- a/test/unit/handlers/unsubscribe-message-handler.spec.ts +++ b/test/unit/handlers/unsubscribe-message-handler.spec.ts @@ -1,30 +1,29 @@ import { expect } from 'chai' import Sinon from 'sinon' - -import { MessageType, UnsubscribeMessage } from '../../../src/@types/messages' -import { IMessageHandler } from '../../../src/@types/message-handlers' import { IWebSocketAdapter } from '../../../src/@types/adapters' +import { IMessageHandler } from '../../../src/@types/message-handlers' +import { MessageType, UnsubscribeMessage } from '../../../src/@types/messages' import { UnsubscribeMessageHandler } from '../../../src/handlers/unsubscribe-message-handler' -import { WebSocketAdapterEvent } from '../../../src/constants/adapter' describe('UnsubscribeMessageHandler', () => { let handler: IMessageHandler let websocketAdapter: IWebSocketAdapter - let emitStub: Sinon.SinonStub + let endSubscriptionStub: Sinon.SinonStub + beforeEach(() => { - emitStub = Sinon.stub() + endSubscriptionStub = Sinon.stub() websocketAdapter = { - emit: emitStub, + endSubscription: endSubscriptionStub, } as any handler = new UnsubscribeMessageHandler(websocketAdapter) }) describe('handleMessage()', () => { - it('emits unsubscribe event with subscription Id', async () => { + it('ends the subscription and aborts its in-flight read', async () => { const message: UnsubscribeMessage = [MessageType.CLOSE, 'subscriptionId'] await handler.handleMessage(message) - expect(emitStub).to.have.been.calledOnceWithExactly(WebSocketAdapterEvent.Unsubscribe, 'subscriptionId') + expect(endSubscriptionStub).to.have.been.calledOnceWithExactly('subscriptionId') }) }) }) From 1ded94d847445a4d7804676e01471c30091e04f6 Mon Sep 17 00:00:00 2001 From: ABHAY PANDEY Date: Thu, 5 Nov 2026 19:09:16 +0530 Subject: [PATCH 3/3] fix(peering): ignore stale limiter results after subscription close --- src/handlers/subscribe-message-handler.ts | 13 +++++----- .../subscribe-message-handler.spec.ts | 24 +++++++++++++++++++ 2 files changed, 31 insertions(+), 6 deletions(-) diff --git a/src/handlers/subscribe-message-handler.ts b/src/handlers/subscribe-message-handler.ts index 8c36bbe0d..fd0ace6f6 100644 --- a/src/handlers/subscribe-message-handler.ts +++ b/src/handlers/subscribe-message-handler.ts @@ -58,6 +58,13 @@ export class SubscribeMessageHandler implements IMessageHandler, IAbortable { if (peerPubkey) { const retryAfterMs = await getPeerRequestRetryAfterMs(this.rateLimiter, this.settings(), peerPubkey, 'REQ') + + // CLOSE aborted this handler while the limiter was pending. A newer REQ + // may already own the id; this stale result must not touch it. + if (this.abortController.signal.aborted) { + return + } + if (retryAfterMs !== undefined) { // A reused subscription id must not keep its old filters/read alive // after we tell the peer this request was refused. @@ -68,12 +75,6 @@ export class SubscribeMessageHandler implements IMessageHandler, IAbortable { ) return } - - // CLOSE may have arrived while the limiter was pending. endSubscription - // aborted this handler's read; do not register the subscription again. - if (this.abortController.signal.aborted) { - return - } } // Bound before uniqWith(): deduplicating an unbounded list is O(n^2). The diff --git a/test/unit/handlers/subscribe-message-handler.spec.ts b/test/unit/handlers/subscribe-message-handler.spec.ts index 554478386..7fbdaa340 100644 --- a/test/unit/handlers/subscribe-message-handler.spec.ts +++ b/test/unit/handlers/subscribe-message-handler.spec.ts @@ -189,6 +189,30 @@ describe('SubscribeMessageHandler', () => { expect(fetchAndSendStub).not.to.have.been.called }) + it('does not end a newer request when an aborted handler is refused', async () => { + const peer = 'a'.repeat(64) + let releaseLimit: ((result: { limited: boolean; retryAfterMs?: number }) => void) | undefined + ;(webSocket.getPeerPubkey as Sinon.SinonStub).returns(peer) + settingsFactory.returns({ + limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } }, + }) + rateLimiterHitStub.returns( + new Promise((resolve) => { + releaseLimit = resolve + }), + ) + message = [MessageType.REQ, subscriptionId, ...filters] as any + + const pending = handler.handleMessage(message) + ;(handler as any).abort() + releaseLimit?.({ limited: true, retryAfterMs: 123 }) + await pending + + expect(endSubscriptionStub).not.to.have.been.called + expect(webSocketOnMessageStub).not.to.have.been.called + expect(webSocketOnSubscribeStub).not.to.have.been.called + }) + it('does not apply peer request limits to ordinary clients', async () => { settingsFactory.returns({ limits: { peer: { request: { rateLimits: [{ period: 60_000, rate: 1 }] } } },