diff --git a/packages/web/src/middleware/rateLimiter.js b/packages/web/src/middleware/rateLimiter.js index a70d78c5..045566c9 100644 --- a/packages/web/src/middleware/rateLimiter.js +++ b/packages/web/src/middleware/rateLimiter.js @@ -18,10 +18,34 @@ export function rateLimiter(req, res, next) { return next(); } - // Identity: prefer API key, fall back to IP - const identity = req.headers.authorization?.slice(7)?.trim() - || req.ip - || "unknown"; + // Identity: a properly formed Bearer token, else the request IP. The + // recognition is EXACTLY apiKeyAuth's ("Bearer " prefix, case-sensitive, + // single space): anything looser re-opens the rotation bypass (e.g. + // "Bearer\t" or "bearer " are NOT Bearer for auth, + // so they must not mint limiter buckets either). Reproduced end-to-end + // in rate-limiter-behavior.test.js; remediation pinned in + // rate-limiter-identity.test.js. + // + // PRE-AUTHENTICATION ENDPOINTS are the exception: the limiter runs before + // authentication, so a syntactically valid Bearer token has NOT been + // validated at this point. On endpoints that authenticate by OTHER means + // (the login route validates the request-body password), an + // unauthenticated caller can rotate random Bearer values to mint a fresh + // bucket per password-guess. Those endpoints always key on the request + // IP — an unverified token must never become their throttle identity. + // The match tolerates trailing slashes and case because Express's default + // non-strict, case-insensitive-to-route routing serves those variants to + // the same handler; an exact-equality list would re-open the mint on + // '/api/auth/login/'. + const isPreAuthPath = (path) => + typeof path === "string" && /^\/api\/auth\/login\/?$/i.test(path); + const useIpIdentity = isPreAuthPath(req.path); + + const authHeader = req.headers.authorization; + const bearerToken = !useIpIdentity && typeof authHeader === "string" && authHeader.startsWith("Bearer ") + ? authHeader.slice(7).trim() + : ""; + const identity = bearerToken || req.ip || "unknown"; const key = `ratelimit:${identity}`; diff --git a/packages/web/tests/unit/rate-limiter-behavior.test.js b/packages/web/tests/unit/rate-limiter-behavior.test.js index e58d76bb..51d96167 100644 --- a/packages/web/tests/unit/rate-limiter-behavior.test.js +++ b/packages/web/tests/unit/rate-limiter-behavior.test.js @@ -157,67 +157,33 @@ describe("rate limiter behavior (Unit C — existing semantics pinned)", () => { }); }); -describe("REPRODUCER (known defect, recorded not fixed): non-Bearer Authorization headers split rate buckets under session auth", () => { - // The limiter identity is `req.headers.authorization?.slice(7)?.trim() || req.ip` - // — the scheme is never checked. apiKeyAuth accepts a VALID SESSION COOKIE - // when the Authorization header is absent or not Bearer. Chained as in - // production (limiter before auth), a session-authenticated caller rotates - // arbitrary non-Bearer Authorization values to get a fresh bucket per - // request. This documents the bypass end-to-end with the REAL apiKeyAuth; - // the fix is a separate production decision per the #425 review. - +describe('REPRODUCER HISTORY (bypass FIXED by rate-limiter-identity remediation on this branch)', () => { + // The original end-to-end reproducer (130 rotating Basic headers from one + // session, all passing, 130 distinct buckets) documented the identity + // defect that the Bearer-only derivation now closes. Full fixed-scenario + // coverage lives in rate-limiter-identity.test.js; here we assert the + // original attack no longer reproduces against the CURRENT middleware. function buildApp() { const app = express(); app.use(rateLimiter); app.use(apiKeyAuth); - app.get("/api/anything", (req, res) => res.json({ ok: true })); + app.get('/api/anything', (req, res) => res.json({ ok: true })); return app; } - it("END-TO-END: 130 requests from ONE session, rotating Basic headers, all pass — the per-IP fallback they should have shared never applies", async () => { + it('the original rotation attack now throttles: 121st request is 429 on ONE shared bucket', async () => { const app = buildApp(); - const sessionCookie = "gitwire-session=valid-session"; + const sessionCookie = 'gitwire-session=valid-session'; + let last = 200; for (let i = 0; i < 130; i += 1) { const res = await supertest(app) - .get("/api/anything") - .set("Authorization", `Basic rotating-value-${i}`) // arbitrary non-Bearer - .set("Cookie", sessionCookie); - expect(res.status).toBe(200); + .get('/api/anything') + .set('Authorization', "Basic rotating-value-" + i) + .set('Cookie', sessionCookie); + last = res.status; + if (res.status === 429) break; } - // 130 DISTINCT buckets were created — one per rotated header value — - // while the SAME session authenticated every request. Without the - // rotating header, all 130 would share the IP bucket and the last 10 - // would have been 429'd. - expect(redisState.counts.size).toBe(130); - expect([...redisState.counts.values()].every((n) => n === 1)).toBe(true); - }); - - it("CONTROL: the SAME session WITHOUT the header trick throttles at 120/min on the shared IP bucket", async () => { - const app = buildApp(); - const sessionCookie = "gitwire-session=valid-session"; - for (let i = 0; i < 120; i += 1) { - const res = await supertest(app) - .get("/api/anything") - .set("Cookie", sessionCookie); - expect(res.status).toBe(200); - } - // The 121st request on the shared IP bucket is the exact boundary the - // rotation bypasses — pinned, not "somewhere within 130". - const boundary = await supertest(app) - .get("/api/anything") - .set("Cookie", sessionCookie); - expect(boundary.status).toBe(429); - }); - - it("MECHANISM: the limiter bucket key derives from the raw sliced header, scheme unchecked", async () => { - const a = await runMiddleware({ headers: { authorization: "Basic value-1" }, ip: "10.9.9.9" }); - const b = await runMiddleware({ headers: { authorization: "Basic value-2" }, ip: "10.9.9.9" }); - expect(a.passed).toBe(true); - expect(b.passed).toBe(true); - // Two buckets for one IP — the sliced values differ even though neither - // is a credential. - expect(redisState.counts.size).toBe(2); - expect([...redisState.counts.keys()].join("|")).toContain("alue-1"); // slice(7) of "Basic value-1" - expect([...redisState.counts.keys()].join("|")).toContain("alue-2"); + expect(last).toBe(429); + expect(redisState.counts.size).toBe(1); // the IP bucket, not per-header buckets }); }); diff --git a/packages/web/tests/unit/rate-limiter-identity.test.js b/packages/web/tests/unit/rate-limiter-identity.test.js new file mode 100644 index 00000000..c696c99d --- /dev/null +++ b/packages/web/tests/unit/rate-limiter-identity.test.js @@ -0,0 +1,230 @@ +// tests/unit/rate-limiter-identity.test.js +// Production remediation for the identity bypass reproduced in +// rate-limiter-behavior.test.js: limiter identity now recognizes ONLY a +// properly formed Bearer scheme; every other Authorization form (and its +// absence) falls back to the request IP — so rotating non-Bearer headers can +// no longer mint fresh buckets for a session-authenticated caller. +// +// The behavior pins (threshold, exclusions, fail-open) live in the behavior +// suite against the same middleware; this suite proves the identity contract +// change end-to-end and in the middleware directly. + +import { jest } from "@jest/globals"; + +const redisState = { counts: new Map(), failWith: null }; + +jest.unstable_mockModule("../../src/lib/queue.js", () => ({ + redis: { + incr: jest.fn(async (key) => { + if (redisState.failWith) throw redisState.failWith; + const next = (redisState.counts.get(key) ?? 0) + 1; + redisState.counts.set(key, next); + return next; + }), + pexpire: jest.fn(async () => 1), + get: jest.fn(async (key) => { + if (key.startsWith("gitwire:session:")) { + return key.endsWith(":valid-session") ? JSON.stringify({ principal: "session-user" }) : null; + } + return null; + }), + expire: jest.fn(async () => 1), + }, +})); +jest.unstable_mockModule("../../src/lib/logger.js", () => ({ + logger: { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() }, +})); +jest.unstable_mockModule("../../config/index.js", () => ({ + config: { anthropic: { apiKey: "test" }, github: { appId: "1", privateKey: "k", clientId: "x", clientSecret: "x", webhookSecret: "s" }, server: { baseUrl: "x" } }, +})); + +process.env.API_KEY = "unit-test-api-key"; + +const { rateLimiter } = await import("../../src/middleware/rateLimiter.js"); +const { apiKeyAuth } = await import("../../src/middleware/auth.js"); + +const express = (await import("express")).default; +const supertest = (await import("supertest")).default; + +function buildApp() { + // Production mount order: limiter BEFORE authentication. + const app = express(); + app.use(rateLimiter); + app.use(apiKeyAuth); + app.get("/api/anything", (req, res) => res.json({ ok: true })); + return app; +} + +beforeEach(() => { + redisState.counts.clear(); + redisState.failWith = null; + jest.clearAllMocks(); +}); + +describe("REMEDIATION: rotating non-Bearer headers can no longer split buckets", () => { + it("THE REPRODUCER SCENARIO, FIXED: 130 requests from one session with rotating Basic headers hit 429 at request 121", async () => { + const app = buildApp(); + const sessionCookie = "gitwire-session=valid-session"; + let last = 200; + for (let i = 0; i < 130; i += 1) { + const res = await supertest(app) + .get("/api/anything") + .set("Authorization", `Basic rotating-value-${i}`) + .set("Cookie", sessionCookie); + if (i < 120) { + expect(res.status).toBe(200); + } + last = res.status; + if (res.status === 429) break; + } + expect(last).toBe(429); + // ONE shared bucket (the request IP), not 130. + expect(redisState.counts.size).toBe(1); + expect([...redisState.counts.values()][0]).toBe(121); + }); + + it("header-absent session traffic shares the same IP bucket (unchanged semantics)", async () => { + const app = buildApp(); + const sessionCookie = "gitwire-session=valid-session"; + let saw429 = false; + for (let i = 0; i < 121; i += 1) { + const res = await supertest(app).get("/api/anything").set("Cookie", sessionCookie); + if (res.status === 429) { saw429 = true; break; } + expect(res.status).toBe(200); + } + expect(saw429).toBe(true); + expect(redisState.counts.size).toBe(1); + }); +}); + +describe('PRE-AUTH FIX: rotating invalid Bearer tokens on /api/auth/login shares ONE IP bucket', () => { + // The limiter runs before authentication, so it cannot know a Bearer token + // is invalid. The login route authenticates by request-body password — an + // unauthenticated caller rotating syntactically-valid-but-random Bearer + // values would otherwise mint a fresh bucket per password guess. + function buildLoginApp() { + const app = express(); + app.use(rateLimiter); + app.use(express.json()); + // Minimal login route mirroring auth.js: 401 on wrong password. + app.post('/api/auth/login', (req, res) => res.status(401).json({ error: 'Invalid password' })); + return app; + } + + it('END-TO-END: 130 login attempts with ROTATING random Bearer tokens hit 429 at request 121 on ONE shared bucket', async () => { + const app = buildLoginApp(); + let last = 200; + for (let i = 0; i < 130; i += 1) { + const res = await supertest(app) + .post('/api/auth/login') + .set('Authorization', "Bearer random-guess-token-" + i) + .send({ password: 'wrong-' + i }); + if (i < 120) { + expect(res.status).toBe(401); // still reaches the route and fails auth + } + last = res.status; + if (res.status === 429) break; + } + expect(last).toBe(429); + expect(redisState.counts.size).toBe(1); // ONE shared IP bucket + expect([...redisState.counts.values()][0]).toBe(121); + }); + + it('login attempts WITHOUT Bearer headers share the same single bucket (unchanged semantics)', async () => { + const app = buildLoginApp(); + let saw429 = false; + for (let i = 0; i < 121; i += 1) { + const res = await supertest(app) + .post('/api/auth/login') + .send({ password: 'wrong' }); + if (res.status === 429) { saw429 = true; break; } + expect(res.status).toBe(401); + } + expect(saw429).toBe(true); + expect(redisState.counts.size).toBe(1); + }); + + it('TRAILING-SLASH and case variants of the login path are ALSO IP-keyed (no mint on /api/auth/login/)', async () => { + const app = buildLoginApp(); + const variants = ["/api/auth/login/", "/API/AUTH/LOGIN", "/api/auth/Login/"]; + for (const path of variants) { + redisState.counts.clear(); + await supertest(app) + .post(path) + .set("Authorization", "Bearer slash-variant-token") + .send({ password: "wrong" }); + // Whatever the route did with the variant (401 or 404), the limiter + // bucket must be the IP — never the token. + const keys = [...redisState.counts.keys()]; + expect(keys.length).toBe(1); + expect(keys[0]).not.toContain("slash-variant-token"); + } + }); + + it('NON-login /api paths still derive identity from a well-formed Bearer token', async () => { + const app = buildLoginApp(); + app.get('/api/anything', (req, res) => res.json({ ok: true })); + const res = await supertest(app) + .get('/api/anything') + .set('Authorization', 'Bearer some-token'); + expect(res.status).toBe(200); + expect([...redisState.counts.keys()].join('|')).toContain('some-token'); + }); +}); + +describe("identity derivation contract (middleware-level)", () => { + function runMiddleware({ headers = {}, ip } = {}) { + return new Promise((resolve) => { + const req = { path: "/api/anything", headers, ip, get: (h) => headers[h.toLowerCase()] }; + const res = { + statusCode: 200, + headers: {}, + setHeader(k, v) { this.headers[k] = v; }, + status(code) { this.statusCode = code; return this; }, + json(body) { this.body = body; resolve({ res, passed: false }); return this; }, + }; + rateLimiter(req, res, () => resolve({ res, passed: true })); + }); + } + + it('a well-formed case-sensitive "Bearer " scheme token IS the identity (exactly apiKeyAuth recognition)', async () => { + await runMiddleware({ headers: { authorization: "Bearer key-one" }, ip: "10.0.0.1" }); + await runMiddleware({ headers: { authorization: "Bearer key-two" }, ip: "10.0.0.1" }); + // Two distinct buckets for two distinct tokens from one IP. + expect(redisState.counts.size).toBe(2); + expect([...redisState.counts.keys()].join("|")).toContain("key-one"); + expect([...redisState.counts.keys()].join("|")).toContain("key-two"); + // A LOWERCASE scheme is not Bearer for apiKeyAuth (starts-with "Bearer "), + // so it must not be Bearer for the limiter either — it falls to the IP. + redisState.counts.clear(); + await runMiddleware({ headers: { authorization: "bearer key-lower" }, ip: "10.0.0.2" }); + expect([...redisState.counts.keys()]).toEqual(["ratelimit:10.0.0.2"]); + }); + + it.each([ + ["Basic value-1"], + ["basic value-2"], + ["Bearer"], // malformed: no token after scheme + ["Bearer "], // malformed: whitespace only + ["Bearer\tgap-token"], // malformed: tab not matched by \\s+? (regex ^Bearer\\s+ — tab IS \\s; assert below) + [""], // empty header value + ])("non-Bearer or malformed header %j falls back to the IP bucket", async (authorization) => { + redisState.counts.clear(); + const first = await runMiddleware({ headers: { authorization }, ip: "10.1.1.1" }); + expect(first.passed).toBe(true); + // Whatever the header said, the bucket is the IP. + expect([...redisState.counts.keys()]).toEqual(["ratelimit:10.1.1.1"]); + }); + + it("Bearer-key separation still works at the threshold: key A saturates, key B unaffected, IP unaffected", async () => { + for (let i = 0; i < 120; i += 1) { + await runMiddleware({ headers: { authorization: "Bearer key-sat" }, ip: "10.2.2.2" }); + } + const saturated = await runMiddleware({ headers: { authorization: "Bearer key-sat" }, ip: "10.2.2.2" }); + expect(saturated.passed).toBe(false); + const otherKey = await runMiddleware({ headers: { authorization: "Bearer key-other" }, ip: "10.2.2.2" }); + expect(otherKey.passed).toBe(true); + const plainIp = await runMiddleware({ ip: "10.2.2.2" }); + expect(plainIp.passed).toBe(true); + }); +});