feat(backend): add an application-layer gate to the admin API (#63)

Authorization for the admin panel and the admin API has lived entirely in one auth_request regex in an Nginx Proxy Manager config outside this repository. That control is real and it works — nothing is publicly exposed today — but it is invisible from the code, untested here, and not reviewed when this code changes. Three things follow from that, and the first is the one worth the change.

An admin route added at a path the regex does not match is unprotected the moment it is written, and nothing in Express indicates that. Anything reaching the published container port directly bypasses authentik entirely. And locally there is no gate at all, so no developer ever sees the boundary being enforced.

requireAdminGate is attached to each admin router rather than to a path prefix, which is what makes it useful rather than merely redundant with the proxy. An admin router added later at some other path inherits the gate; because the proxy only injects the header on paths its regex matches, that router refuses on its first request instead of being quietly public. A 403 in that situation is the boundary reporting that it has drifted.

The gate is optional, and unset means exactly today's behaviour. That keeps local development and all 113 existing admin test call sites working untouched, and means shipping the image before configuring the proxy cannot take the admin panel down. What it does not do is stay silent about it: the server warns at boot when the gate is inactive, naming what is unprotected. This project has been bitten repeatedly by controls that report success while doing nothing, and an unconfigured gate should be a visible choice rather than an invisible one.

An empty value is treated as unset rather than as a secret, because enforcing an empty secret would admit any caller sending an empty header. Comparison is timing-safe over SHA-256 digests of both sides: timingSafeEqual throws on buffers of unequal length, so comparing raw values would turn a short header into a 500 rather than a 403, and a length check first would leak the secret's length.

Turning it on requires the secret in two places at once — the stack environment and a proxy_set_header line on the gated location in NPM. Setting only one gives 403s until the other catches up. That coupling, and the three consequences above, are now written into the README beside the deployment section, since none of it is visible from the code.

Verified over real HTTP as well as in tests. Booting without the secret logs the warning and serves admin normally; booting with it returns 403 for a missing header, 403 for a wrong one, 200 for the right one, and leaves the public storefront at 200 throughout, with each refusal logged distinguishably and without echoing the value it was sent. 8 new unit tests, 9 new integration tests covering every admin router separately — a correct middleware nobody mounted would pass the unit tests and protect nothing. 106 unit and 153 integration passing, lint 0 errors and 8 warnings unchanged.

Refs #63
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/src/app.ts

@@ -15,6 +15,7 @@ import cartRouter from './routes/cart';
 import shippingAddressesRouter from './routes/shippingAddresses';
 import clientErrorsRouter from './routes/clientErrors';
 import { attachCustomer } from './middleware/customerAuth';
+import { requireAdminGate } from './middleware/adminGate';
 import { asyncRoute } from './asyncRoute';
 
 const app = express();
@@ -46,11 +47,16 @@ app.use('/api/items', itemsRouter);
 app.use('/api/filters', filtersRouter);
 app.use('/api/cart', cartRouter);
 app.use('/api/checkout/cart', cartCheckoutRouter);
-app.use('/api/admin/customers', adminCustomersRouter);
-app.use('/api/admin/settings', adminSettingsRouter);
-app.use('/api/admin/categories', adminCategoriesRouter);
-app.use('/api/admin/tags', adminTagsRouter);
-app.use('/api/admin', adminRouter);
+// requireAdminGate is attached to each admin router rather than to a path
+// prefix. Attached to the router, an admin router added later at some other
+// path still inherits it — and since the proxy only injects the header on the
+// paths its regex matches, that router refuses loudly on its first request
+// instead of being quietly public. See middleware/adminGate.ts and #63.
+app.use('/api/admin/customers', requireAdminGate, adminCustomersRouter);
+app.use('/api/admin/settings', requireAdminGate, adminSettingsRouter);
+app.use('/api/admin/categories', requireAdminGate, adminCategoriesRouter);
+app.use('/api/admin/tags', requireAdminGate, adminTagsRouter);
+app.use('/api/admin', requireAdminGate, adminRouter);
 app.use('/api/customers/me/addresses', shippingAddressesRouter);
 app.use('/api/customers', customersRouter);
 app.use('/api/client-errors', clientErrorsRouter);

backend/src/middleware/adminGate.ts

@@ -0,0 +1,61 @@
+import { Request, Response, NextFunction } from 'express';
+import crypto from 'crypto';
+
+// The header Nginx Proxy Manager injects on the authentik-gated location. The
+// name is not a secret and does not need to be — the value is.
+export const ADMIN_GATE_HEADER = 'x-admin-gate';
+
+// Hashed before comparing for two reasons. timingSafeEqual throws on buffers of
+// unequal length, so comparing raw values would turn a short header into a 500
+// instead of a 403; and a length check before comparing would leak the secret's
+// length. Digests are always 32 bytes, so neither problem arises.
+function digest(value: string): Buffer {
+  return crypto.createHash('sha256').update(value, 'utf8').digest();
+}
+
+/**
+ * Defence in depth for the admin API.
+ *
+ * Authorization for `/admin` and `/api/admin` lives entirely in one
+ * `auth_request` regex in an Nginx Proxy Manager config outside this
+ * repository. That control is real and it works, but it is invisible from the
+ * code, untested here, and bypassed completely by anything that reaches the
+ * published container port directly. See #63.
+ *
+ * With `ADMIN_GATE_SECRET` set, the proxy injects the matching header and this
+ * refuses anything that arrives without it.
+ *
+ * Unset — or empty, which cannot mean "enforce" without letting an empty header
+ * through — this is a no-op and the API is proxy-protected exactly as before.
+ * That keeps local development and the existing admin tests working untouched,
+ * and means shipping the image before configuring the proxy cannot take the
+ * admin panel down. `server.ts` warns at boot when it is inactive, so the
+ * inactive state is visible rather than silent.
+ *
+ * Mounted on the admin routers rather than on a path prefix, deliberately. An
+ * admin router added later at a path the proxy regex does not match will
+ * receive no header and refuse loudly on the first request, instead of being
+ * quietly public — which is the failure #63 was most concerned about.
+ */
+export function requireAdminGate(req: Request, res: Response, next: NextFunction): void {
+  const secret = process.env.ADMIN_GATE_SECRET;
+  if (!secret) {
+    next();
+    return;
+  }
+
+  const provided = req.get(ADMIN_GATE_HEADER);
+  if (typeof provided !== 'string' || !crypto.timingSafeEqual(digest(provided), digest(secret))) {
+    // Logged because a 403 from behind a proxy is otherwise very hard to
+    // diagnose — most often it means the proxy config and the stack's secret
+    // have drifted apart. The value sent is deliberately not echoed.
+    console.warn(
+      `[admin-gate] refused ${req.method} ${req.originalUrl} — ` +
+        `${provided === undefined ? 'no' : 'incorrect'} ${ADMIN_GATE_HEADER} header`
+    );
+    res.status(403).json({ error: 'forbidden' });
+    return;
+  }
+
+  next();
+}

backend/src/server.ts

@@ -65,4 +65,17 @@ setInterval(() => void sweepExpiredCarts(), 5 * 60 * 1000);
 cron.schedule('0 9 * * *', () => void sendCartReminders());
 
 const PORT = parseInt(process.env.PORT || '3000', 10);
+// Said at boot rather than left to be discovered. Without the secret the admin
+// API is protected only by the reverse proxy's auth_request regex, which lives
+// outside this repository and is bypassed entirely by anything reaching this
+// container's published port directly. That is a defensible way to run — it is
+// how this app has always run — but it should be a visible choice rather than a
+// silent one. See middleware/adminGate.ts and #63.
+if (!process.env.ADMIN_GATE_SECRET) {
+  console.warn(
+    '[admin-gate] ADMIN_GATE_SECRET is not set — /api/admin is protected only by the reverse ' +
+      'proxy. Anything able to reach this container directly can administer the store.'
+  );
+}
+
 app.listen(PORT, () => console.log(`redefined-designs listening on ${PORT}`));

backend/tests/integration/adminGate.integration.test.ts

@@ -0,0 +1,94 @@
+import request from 'supertest';
+import app from '../../src/app';
+import { pool } from '../../src/db';
+import { resetDb, closeDb } from './setup/testDb';
+
+// The unit tests prove the middleware decides correctly. This proves it is
+// actually attached to the admin routers — a correct function nobody mounted
+// would pass every unit test and protect nothing.
+//
+// ADMIN_GATE_SECRET is read per request rather than at import, so it can be set
+// here without reloading the app. It is restored after each test so this file
+// cannot change how anything running later in the same process behaves.
+
+const SECRET = 'integration-gate-secret';
+const original = process.env.ADMIN_GATE_SECRET;
+let warn: jest.SpyInstance;
+
+beforeEach(async () => {
+  await resetDb();
+  warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+});
+
+afterEach(() => {
+  warn.mockRestore();
+  if (original === undefined) {
+    delete process.env.ADMIN_GATE_SECRET;
+  } else {
+    process.env.ADMIN_GATE_SECRET = original;
+  }
+});
+
+afterAll(async () => {
+  await pool.end();
+  await closeDb();
+});
+
+describe('the admin gate, mounted on the real routers', () => {
+  it('refuses an admin request with no gate header once a secret is configured', async () => {
+    process.env.ADMIN_GATE_SECRET = SECRET;
+
+    const res = await request(app).get('/api/admin/items');
+
+    expect(res.status).toBe(403);
+    expect(res.body.error).toBe('forbidden');
+  });
+
+  it('serves the same request when it carries the gate header', async () => {
+    process.env.ADMIN_GATE_SECRET = SECRET;
+
+    const res = await request(app).get('/api/admin/items').set('X-Admin-Gate', SECRET);
+
+    expect(res.status).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+  });
+
+  // Every admin router has to be covered, not just the one mounted last. These
+  // are separate app.use calls, so one of them missing the middleware is an
+  // easy and completely silent mistake.
+  it.each([
+    ['/api/admin/customers', 'customers'],
+    ['/api/admin/categories', 'categories'],
+    ['/api/admin/tags', 'tags'],
+    ['/api/admin/settings', 'settings'],
+    ['/api/admin/items', 'inventory']
+  ])('gates %s', async (path) => {
+    process.env.ADMIN_GATE_SECRET = SECRET;
+
+    const refused = await request(app).get(path);
+    expect(refused.status).toBe(403);
+
+    const allowed = await request(app).get(path).set('X-Admin-Gate', SECRET);
+    expect(allowed.status).not.toBe(403);
+  });
+
+  // The state every existing admin test relies on, and the state production
+  // runs in until the proxy is configured.
+  it('leaves admin reachable when no secret is configured', async () => {
+    delete process.env.ADMIN_GATE_SECRET;
+
+    const res = await request(app).get('/api/admin/items');
+
+    expect(res.status).toBe(200);
+  });
+
+  // The storefront must not be caught by the gate — it is public by design and
+  // the proxy does not add the header to it in production.
+  it('does not gate the public storefront', async () => {
+    process.env.ADMIN_GATE_SECRET = SECRET;
+
+    const res = await request(app).get('/api/items');
+
+    expect(res.status).toBe(200);
+  });
+});

backend/tests/unit/adminGate.test.ts

@@ -0,0 +1,140 @@
+import { Request, Response, NextFunction } from 'express';
+import { requireAdminGate } from '../../src/middleware/adminGate';
+
+// The gate is the whole point of #63, so both directions are tested: it must
+// let the right request through, and it must refuse the wrong one. A gate that
+// only ever refuses is as broken as one that only ever allows — it would take
+// the admin panel down rather than protect it.
+
+interface Harness {
+  req: Request;
+  res: Response;
+  next: NextFunction;
+  status: jest.Mock;
+  json: jest.Mock;
+}
+
+function harness(header?: string): Harness {
+  const status = jest.fn().mockReturnThis();
+  const json = jest.fn().mockReturnThis();
+  const req = {
+    method: 'POST',
+    originalUrl: '/api/admin/items',
+    get: (name: string) => (name.toLowerCase() === 'x-admin-gate' ? header : undefined)
+  } as unknown as Request;
+  const res = { status, json } as unknown as Response;
+  return { req, res, next: jest.fn() as unknown as NextFunction, status, json };
+}
+
+describe('requireAdminGate', () => {
+  const original = process.env.ADMIN_GATE_SECRET;
+  let warn: jest.SpyInstance;
+
+  beforeEach(() => {
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+    // Restored rather than deleted unconditionally, so this file cannot change
+    // the behaviour of anything that runs after it in the same process.
+    if (original === undefined) {
+      delete process.env.ADMIN_GATE_SECRET;
+    } else {
+      process.env.ADMIN_GATE_SECRET = original;
+    }
+  });
+
+  describe('when no secret is configured', () => {
+    // Today's behaviour, and local dev and every admin test depend on it.
+    it('lets the request through', () => {
+      delete process.env.ADMIN_GATE_SECRET;
+      const h = harness();
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(h.next).toHaveBeenCalledTimes(1);
+      expect(h.status).not.toHaveBeenCalled();
+    });
+
+    // An empty value cannot mean "enforce", because then any caller sending an
+    // empty header would pass. It has to mean the same as unset.
+    it('treats an empty secret as unconfigured rather than as a secret', () => {
+      process.env.ADMIN_GATE_SECRET = '';
+      const h = harness('');
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(h.next).toHaveBeenCalledTimes(1);
+      expect(h.status).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when a secret is configured', () => {
+    const SECRET = 'a-real-gate-secret';
+
+    beforeEach(() => {
+      process.env.ADMIN_GATE_SECRET = SECRET;
+    });
+
+    it('lets a request carrying the right header through', () => {
+      const h = harness(SECRET);
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(h.next).toHaveBeenCalledTimes(1);
+      expect(h.status).not.toHaveBeenCalled();
+    });
+
+    it('refuses a request with no header at all', () => {
+      const h = harness();
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(h.next).not.toHaveBeenCalled();
+      expect(h.status).toHaveBeenCalledWith(403);
+      expect(h.json).toHaveBeenCalledWith({ error: 'forbidden' });
+    });
+
+    it('refuses a request with the wrong header', () => {
+      const h = harness('not-the-secret-but-same-length');
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(h.next).not.toHaveBeenCalled();
+      expect(h.status).toHaveBeenCalledWith(403);
+    });
+
+    // The trap in timingSafeEqual: it throws on buffers of unequal length, so
+    // comparing raw values would turn a short header into a 500 instead of a
+    // 403. Hashing both sides first is what makes the lengths always equal.
+    it('refuses a header of a different length without throwing', () => {
+      const h = harness('short');
+
+      expect(() => requireAdminGate(h.req, h.res, h.next)).not.toThrow();
+      expect(h.next).not.toHaveBeenCalled();
+      expect(h.status).toHaveBeenCalledWith(403);
+    });
+
+    it('refuses a header that merely starts with the secret', () => {
+      const h = harness(`${SECRET}-extra`);
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(h.status).toHaveBeenCalledWith(403);
+    });
+
+    // A silent 403 is very hard to diagnose from the other side of a proxy.
+    it('logs the refusal without echoing the value it was sent', () => {
+      const h = harness('some-guessed-value');
+
+      requireAdminGate(h.req, h.res, h.next);
+
+      expect(warn).toHaveBeenCalledTimes(1);
+      const logged = warn.mock.calls[0][0] as string;
+      expect(logged).toContain('[admin-gate]');
+      expect(logged).toContain('/api/admin/items');
+      expect(logged).not.toContain('some-guessed-value');
+    });
+  });
+});