From bc592ea43292684de24c4fd0b56a726e88936340 Mon Sep 17 00:00:00 2001 From: Nirmal Khedkar Date: Fri, 6 Nov 2026 14:37:32 -0800 Subject: [PATCH 1/2] fix: restrict carts and orders to account owners Require the signed-in account ID to match the cart or order owner before reads, cart mutations, and checkout. Reject API-key requests without a member identity and prevent cross-account access, including admin tokens. Cover all six mounted routes with real stores and authenticated HTTP requests. Verify denied calls preserve owner data and legitimate owner operations retain their existing behavior. Validation: 103 Node tests and 46 Jest tests pass. Full-repository Qlty scans add no findings relative to the baseline. Signed-off-by: Nirmal Khedkar --- .../__tests__/cart_order_ownership.test.js | 111 ++++++++++++++++++ backend/middleware/requireAccountOwner.js | 7 ++ backend/routes/cartRoutes.js | 4 + backend/routes/orderRoutes.js | 4 + 4 files changed, 126 insertions(+) create mode 100644 backend/__tests__/cart_order_ownership.test.js create mode 100644 backend/middleware/requireAccountOwner.js diff --git a/backend/__tests__/cart_order_ownership.test.js b/backend/__tests__/cart_order_ownership.test.js new file mode 100644 index 00000000..f769df15 --- /dev/null +++ b/backend/__tests__/cart_order_ownership.test.js @@ -0,0 +1,111 @@ +const { test, before, after } = require('node:test'); +const assert = require('node:assert/strict'); +const { randomUUID, randomBytes } = require('node:crypto'); +const express = require('express'); +const request = require('supertest'); +const jwt = require('../utils/jwt'); +const auth = require('../middleware/authMiddleware'); +const Cart = require('../models/cart'); +const Order = require('../models/order'); + +const app = express(); +app.use(express.json()); +app.use(auth); +app.use('/cart', require('../routes/cartRoutes')); +app.use('/orders', require('../routes/orderRoutes')); + +const originalSecret = process.env.JWT_SECRET; +const originalKey = process.env.API_KEY; +before(() => { + process.env.JWT_SECRET = randomBytes(32).toString('hex'); + process.env.API_KEY = randomUUID(); +}); +after(() => { + if (originalSecret === undefined) delete process.env.JWT_SECRET; + else process.env.JWT_SECRET = originalSecret; + if (originalKey === undefined) delete process.env.API_KEY; + else process.env.API_KEY = originalKey; +}); + +const operations = [ + { name: 'read cart', method: 'get', path: id => `/cart/${id}`, status: 200 }, + { name: 'add item', method: 'post', path: id => `/cart/${id}`, status: 201 }, + { name: 'remove item', method: 'delete', path: id => `/cart/${id}/apple`, status: 200 }, + { name: 'clear cart', method: 'delete', path: id => `/cart/${id}`, status: 200 }, + { name: 'checkout', method: 'post', path: id => `/orders/${id}/checkout`, status: 201 }, + { name: 'read orders', method: 'get', path: id => `/orders/${id}`, status: 200 }, +]; + +function seedOwner() { + const owner = randomUUID(); + Cart.addItem(owner, { id: 'apple', name: 'Apple' }); + Order.createOrder(owner, [{ id: 'pear', name: 'Pear' }], {}); + return owner; +} + +function bearer(payload) { + return { Authorization: `Bearer ${jwt.sign(payload, process.env.JWT_SECRET)}` }; +} + +const deniedCallers = [ + { name: 'another member', headers: () => bearer({ userId: randomUUID() }), status: 403 }, + { name: 'another member with admin role', headers: () => bearer({ userId: randomUUID(), role: 'admin' }), status: 403 }, + { name: 'API key without member identity', headers: () => ({ 'x-api-key': process.env.API_KEY }), status: 403 }, + { name: 'signed token without member identity', headers: () => bearer({ role: 'user' }), status: 403 }, + { name: 'anonymous caller', headers: () => ({}), status: 403 }, + { name: 'invalid token', headers: () => ({ Authorization: 'Bearer invalid' }), status: 401 }, +]; + +// Removing the owner check would expose data or mutate these real stores. +for (const operation of operations) { + for (const caller of deniedCallers) { + test(`${operation.name} denies ${caller.name} without changing owner data`, async () => { + const owner = seedOwner(); + const previousCart = structuredClone(Cart.getCart(owner)); + const previousOrders = structuredClone(Order.listOrders(owner)); + const response = await request(app)[operation.method](operation.path(owner)) + .set(caller.headers()) + .send({ id: 'banana', userId: owner, deliveryMethod: 'delivery' }); + assert.equal(response.status, caller.status); + assert.equal(typeof response.body.error, 'string'); + assert.deepEqual(Cart.getCart(owner), previousCart); + assert.deepEqual(Order.listOrders(owner), previousOrders); + }); + } +} + +// Rejecting everyone would break the same-owner paths as well. +for (const operation of operations) { + test(`${operation.name} preserves same-owner behavior`, async () => { + const owner = seedOwner(); + const response = await request(app)[operation.method](operation.path(owner)) + .set(bearer({ userId: owner })) + .send({ id: 'banana', deliveryMethod: 'delivery', deliveryAddress: 'Test address' }); + assert.equal(response.status, operation.status); + const cart = Cart.getCart(owner); + const orders = Order.listOrders(owner); + switch (operation.name) { + case 'read cart': + assert.deepEqual(response.body, [{ id: 'apple', name: 'Apple' }]); + break; + case 'add item': + assert.deepEqual(cart.map(item => item.id), ['apple', 'banana']); + break; + case 'read orders': + assert.equal(response.body.length, 1); + assert.equal(response.body[0].userId, owner); + assert.deepEqual(response.body[0].items, [{ id: 'pear', name: 'Pear' }]); + break; + case 'checkout': + assert.equal(response.body.userId, owner); + assert.deepEqual(response.body.items, [{ id: 'apple', name: 'Apple' }]); + assert.equal(response.body.deliveryMethod, 'delivery'); + assert.equal(response.body.deliveryAddress, 'Test address'); + assert.equal(orders.length, 2); + assert.deepEqual(cart, []); + break; + default: + assert.deepEqual(cart, []); + } + }); +} diff --git a/backend/middleware/requireAccountOwner.js b/backend/middleware/requireAccountOwner.js new file mode 100644 index 00000000..7b5a86a6 --- /dev/null +++ b/backend/middleware/requireAccountOwner.js @@ -0,0 +1,7 @@ +module.exports = (req, res, next) => { + const userId = req.user?.userId; + if (typeof userId !== 'string' || !userId || userId !== req.params.userId) { + return res.status(403).json({ error: 'Forbidden: Account ownership required' }); + } + next(); +}; diff --git a/backend/routes/cartRoutes.js b/backend/routes/cartRoutes.js index 3bb47262..6b28f311 100644 --- a/backend/routes/cartRoutes.js +++ b/backend/routes/cartRoutes.js @@ -2,6 +2,10 @@ const express = require('express'); const router = express.Router(); const cartController = require('../controllers/cart_controller'); +const requireAccountOwner = require('../middleware/requireAccountOwner'); + +router.use('/:userId', requireAccountOwner); + router.get('/:userId', cartController.getCart); router.post('/:userId', cartController.addItem); router.delete('/:userId/:itemId', cartController.removeItem); diff --git a/backend/routes/orderRoutes.js b/backend/routes/orderRoutes.js index a4d32700..73a782c1 100644 --- a/backend/routes/orderRoutes.js +++ b/backend/routes/orderRoutes.js @@ -2,6 +2,10 @@ const express = require('express'); const router = express.Router(); const orderController = require('../controllers/order_controller'); +const requireAccountOwner = require('../middleware/requireAccountOwner'); + +router.use('/:userId', requireAccountOwner); + router.post('/:userId/checkout', orderController.checkout); router.get('/:userId', orderController.listOrders); From 99079d7ba588082a1c832d70415b564cd555c5b2 Mon Sep 17 00:00:00 2001 From: Nirmal Khedkar Date: Mon, 16 Nov 2026 11:31:45 -0800 Subject: [PATCH 2/2] test: rate-limit cart and order ownership requests Mount the existing API limiter before JWT authentication in the HTTP test app. Verify exhausted requests return 429 without mutating the owner cart, while retaining all ownership regressions. Validation: 43 focused HTTP cases, 103 Node tests, and 65 Jest tests pass. Syntax, hardcoded-URL, and whitespace checks pass; full Qlty comparison adds no findings. Signed-off-by: Nirmal Khedkar --- .../__tests__/cart_order_ownership.test.js | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/backend/__tests__/cart_order_ownership.test.js b/backend/__tests__/cart_order_ownership.test.js index f769df15..58107ce9 100644 --- a/backend/__tests__/cart_order_ownership.test.js +++ b/backend/__tests__/cart_order_ownership.test.js @@ -5,11 +5,14 @@ const express = require('express'); const request = require('supertest'); const jwt = require('../utils/jwt'); const auth = require('../middleware/authMiddleware'); +const { apiRateLimit } = require('../middleware/rateLimit'); const Cart = require('../models/cart'); const Order = require('../models/order'); const app = express(); app.use(express.json()); +// Bound requests before JWT verification, including unauthenticated attempts. +app.use(apiRateLimit); app.use(auth); app.use('/cart', require('../routes/cartRoutes')); app.use('/orders', require('../routes/orderRoutes')); @@ -109,3 +112,22 @@ for (const operation of operations) { } }); } + +test('repeated requests are throttled before cart mutation', async () => { + const owner = seedOwner(); + const previousCart = structuredClone(Cart.getCart(owner)); + const headers = bearer({ userId: owner }); + let status; + // Earlier ownership cases may consume part of the shared IP quota. + for (let attempt = 0; attempt < 121; attempt += 1) { + const response = await request(app).get(`/cart/${owner}`).set(headers); + status = response.status; + if (status === 429) break; + assert.equal(status, 200); + } + assert.equal(status, 429); + const response = await request(app).post(`/cart/${owner}`) + .set(headers).send({ id: 'banana' }); + assert.equal(response.status, 429); + assert.deepEqual(Cart.getCart(owner), previousCart); +});