// /api/cctv/media is the live-feed relay. A still camera used to be relayed // through it as well, by an ordinary redirect-following fetch with no content // type check and no body cap, which side-stepped everything /api/cctv/frame // enforces for the same URL. These pin that a still is refused there and only // reachable through /frame, while live feeds keep their relay. // // Run with: npm test (node --test) import { test } from 'node:test'; import assert from 'node:assert/strict'; import { Readable } from 'node:stream'; import { mountCctvProvider } from '../testSupport/cctvProviderHarness.mjs'; const STILL = { id: 'still-fixture', name: 'Still fixture', lat: 30.27, lon: -97.74, feedType: 'image', url: 'https://cams.upstream.invalid/still.jpg', }; // 'jpg' normalizes to 'image'; the alias must not reopen the relay. const STILL_ALIAS = { ...STILL, id: 'still-alias', feedType: 'jpg', url: 'https://cams.upstream.invalid/alias.jpg', }; const VIDEO = { id: 'video-fixture', name: 'Video fixture', lat: 30.27, lon: -97.74, feedType: 'video', url: 'https://cams.upstream.invalid/live.mp4', }; const WEBM = { id: 'webm-fixture', name: 'WebM fixture', lat: 30.27, lon: -97.74, feedType: 'webm', url: 'https://cams.upstream.invalid/live.webm', }; const MJPEG = { id: 'mjpeg-fixture', name: 'MJPEG fixture', lat: 30.27, lon: -97.74, feedType: 'mjpeg', url: 'https://cams.upstream.invalid/live.mjpg', }; /** A minimal upstream Response with a streaming body. */ function upstreamResponse({ status = 200, headers = {}, body = 'payload' }) { const store = new Map( Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]), ); return { ok: status >= 200 && status < 300, status, headers: { get: (name) => store.get(String(name).toLowerCase()) ?? null }, body: Readable.toWeb(Readable.from([Buffer.from(String(body))])), }; } /** Mount the real provider over the fixture cameras, recording upstream requests. */ function mount(t, respond) { const requests = []; const app = mountCctvProvider(t, { cameras: [STILL, STILL_ALIAS, VIDEO, WEBM, MJPEG], fetch: async (url, init = {}) => { requests.push({ url: String(url), redirect: init.redirect }); return respond({ url: String(url), init }); }, }); return { ...app, requests }; } test('a still camera is refused by /media without any upstream request', async (t) => { // Everything the old relay would have done with this camera: redirect to a // private address, then answer with HTML. const app = mount(t, ({ url }) => url.includes('169.254.169.254') ? upstreamResponse({ headers: { 'content-type': 'text/html' }, body: 'metadata', }) : upstreamResponse({ status: 302, headers: { location: 'http://169.254.169.254/latest/meta-data/' }, body: '', }), ); for (const camera of [STILL, STILL_ALIAS]) { const res = await app.call(`/media/${camera.id}`); assert.equal(res.statusCode, 404, camera.id); assert.equal(res.headers['Content-Type'], 'application/json'); assert.deepEqual(JSON.parse(res.body), { error: 'No live media for this camera; use the frame endpoint', }); assert.doesNotMatch(res.body, /metadata/); // Being asked on the wrong route is not a camera fault. assert.equal(await app.health(camera.id), undefined); } assert.deepEqual(app.requests, [], 'a still camera reached its upstream'); }); test('an unregistered camera id is refused by /media the same way', async (t) => { const app = mount(t, () => { throw new Error('an unknown camera must not fetch'); }); const res = await app.call('/media/not-a-camera'); assert.equal(res.statusCode, 404); assert.equal(app.requests.length, 0); }); test('a video camera is still relayed by /media', async (t) => { const app = mount(t, () => upstreamResponse({ headers: { 'content-type': 'video/mp4', 'content-length': '5' }, body: 'video', }), ); const res = await app.call(`/media/${VIDEO.id}`); assert.equal(res.statusCode, 200); assert.equal(res.headers['Content-Type'], 'video/mp4'); assert.equal(res.headers['X-CCTV-Source'], 'live-media'); assert.equal(res.body, 'video'); assert.deepEqual( app.requests.map(({ url }) => url), [VIDEO.url], ); assert.equal((await app.health(VIDEO.id)).status, 'ok'); }); test('an MJPEG camera is still relayed by /media', async (t) => { const app = mount(t, () => upstreamResponse({ headers: { 'content-type': 'multipart/x-mixed-replace; boundary=frame' }, body: '--frame', }), ); const res = await app.call(`/media/${MJPEG.id}`); assert.equal(res.statusCode, 200); assert.match(res.headers['Content-Type'], /^multipart\/x-mixed-replace/); assert.equal(res.body, '--frame'); assert.deepEqual( app.requests.map(({ url }) => url), [MJPEG.url], ); }); test('a still camera is still served through /frame with its bounded fetch', async (t) => { const app = mount(t, () => upstreamResponse({ headers: { 'content-type': 'image/jpeg' }, body: 'jpeg-bytes', }), ); const res = await app.call(`/frame/${STILL.id}`); assert.equal(res.statusCode, 200); assert.equal(res.headers['Content-Type'], 'image/jpeg'); assert.equal(res.headers['X-CCTV-Source'], 'upstream-image'); assert.equal(res.body, 'jpeg-bytes'); assert.deepEqual(app.requests, [{ url: STILL.url, redirect: 'manual' }]); }); test('/frame does not follow a still camera off its origin', async (t) => { // The protection /media used to bypass, shown on the route that keeps it. const app = mount(t, ({ url }) => url === STILL.url ? upstreamResponse({ status: 302, headers: { location: 'http://169.254.169.254/latest/meta-data/' }, body: '', }) : upstreamResponse({ headers: { 'content-type': 'image/jpeg' }, body: 'private', }), ); const res = await app.call(`/frame/${STILL.id}`); assert.equal(res.statusCode, 200); assert.equal(res.headers['X-CCTV-Source'], 'synthetic'); assert.doesNotMatch(res.body, /private/); assert.deepEqual( app.requests.map(({ url }) => url), [STILL.url], ); }); /** An upstream Response whose body records whether it was cancelled. */ function trackedUpstream({ status = 200, headers = {}, body = 'payload' }) { const state = { cancelled: false }; const response = new Response( new ReadableStream( { pull(controller) { controller.enqueue(new TextEncoder().encode(body)); controller.close(); }, cancel() { state.cancelled = true; }, }, { highWaterMark: 0 }, ), { status, headers }, ); return { response, state }; } test('/media refuses an upstream type that does not match the feed kind', async (t) => { let current; const app = mount(t, () => current.response); for (const [camera, contentType, body] of [ [VIDEO, 'text/html', '
x
'], [VIDEO, 'image/svg+xml', ''], [VIDEO, 'application/vnd.apple.mpegurl', '#EXTM3U'], [VIDEO, 'video/webm', 'video'], [VIDEO, undefined, 'video'], [WEBM, 'video/mp4', 'video'], [MJPEG, 'multipart/x-mixed-replace', '--frame'], [MJPEG, 'multipart/x-mixed-replace; boundary=', '--frame'], [MJPEG, 'image/jpeg', 'jpeg'], [MJPEG, 'text/html; boundary=frame', 'x
'], ]) { current = trackedUpstream({ headers: contentType === undefined ? {} : { 'content-type': contentType }, body, }); const label = `${camera.id}: ${contentType}`; const res = await app.call(`/media/${camera.id}`); assert.equal(res.statusCode, 502, label); assert.equal(res.headers['Content-Type'], 'application/json', label); assert.deepEqual(JSON.parse(res.body), { error: 'Media proxy failed' }); assert.equal(current.state.cancelled, true, `${label}: upstream cancelled`); const health = await app.health(camera.id); assert.equal(health.status, 'degraded', label); assert.equal(health.message, 'Unexpected media type', label); } }); test('/media relays each feed kind under its canonical type, including a partial response', async (t) => { let current; const app = mount(t, () => current); for (const [camera, upstream, expected] of [ [VIDEO, { 'content-type': 'Video/MP4; codecs="avc1.42E01E"' }, 'video/mp4'], [ VIDEO, { 'content-type': 'video/mp4', 'content-range': 'bytes 0-4/100', 'content-length': '5', 'accept-ranges': 'bytes', }, 'video/mp4', ], [WEBM, { 'content-type': 'video/webm' }, 'video/webm'], [ MJPEG, { 'content-type': 'multipart/x-mixed-replace;boundary="frame"' }, 'multipart/x-mixed-replace; boundary=frame', ], [ MJPEG, { 'content-type': 'multipart/x-mixed-replace; boundary="a b"' }, 'multipart/x-mixed-replace; boundary="a b"', ], ]) { const status = upstream['content-range'] ? 206 : 200; current = upstreamResponse({ status, headers: upstream, body: 'bytes' }); const res = await app.call(`/media/${camera.id}`); assert.equal(res.statusCode, status, camera.id); assert.equal(res.headers['Content-Type'], expected); assert.equal(res.body, 'bytes'); if (status === 206) assert.equal(res.headers['Content-Range'], 'bytes 0-4/100'); assert.equal((await app.health(camera.id)).status, 'ok'); } }); test('/media does not follow a live camera off its origin', async (t) => { const app = mount(t, ({ url }) => url === VIDEO.url ? upstreamResponse({ status: 302, headers: { location: 'https://elsewhere.invalid/live.mp4' }, body: '', }) : upstreamResponse({ headers: { 'content-type': 'video/mp4' }, body: 'elsewhere', }), ); const res = await app.call(`/media/${VIDEO.id}`); assert.equal(res.statusCode, 502); assert.doesNotMatch(res.body, /elsewhere/); assert.deepEqual(app.requests, [{ url: VIDEO.url, redirect: 'manual' }]); }); test('every CCTV route refuses cross-site requests and admits the app itself', async (t) => { const app = mount(t, ({ url }) => upstreamResponse({ headers: { 'content-type': url === VIDEO.url ? 'video/mp4' : 'image/jpeg', }, body: 'bytes', }), ); const host = 'localhost:5173'; const lease = '00000000-0000-4000-8000-000000000000'; const routes = [ ['GET', '/sources'], ['GET', '/health'], ['GET', `/stream/${STILL.id}`], ['GET', `/frame/${STILL.id}`], ['GET', `/media/${VIDEO.id}`], ['GET', `/media/${VIDEO.id}/seg_0.ts?lease=${lease}`], ['DELETE', `/media/${VIDEO.id}?lease=${lease}`], ]; // A catalog refresh would fetch the live packs: a refused request must not // start one. process.env.CCTV_FORCE_AUSTIN = '1'; for (const headers of [ { host, 'sec-fetch-site': 'cross-site' }, { host, 'sec-fetch-site': 'same-site' }, { host, origin: 'https://elsewhere.example' }, { host, origin: 'null' }, ]) for (const [method, path] of routes) { const res = await app.call(path, headers, method); assert.equal( res.statusCode, 403, `${method} ${path} ${JSON.stringify(headers)}`, ); } assert.deepEqual(app.requests, [], 'a refused request reached an upstream'); process.env.CCTV_FORCE_AUSTIN = '0'; for (const headers of [ { host, 'sec-fetch-site': 'same-origin' }, { host, origin: `http://${host}` }, {}, ]) { const frame = await app.call(`/frame/${STILL.id}`, headers); assert.equal(frame.statusCode, 200); assert.equal(frame.headers['X-CCTV-Source'], 'upstream-image'); const media = await app.call(`/media/${VIDEO.id}`, headers); assert.equal(media.statusCode, 200); assert.equal(media.headers['Content-Type'], 'video/mp4'); } }); test('/frame falls back past a non-raster upstream and Street View frame', async (t) => { let streetViewType; const app = mount(t, ({ url }) => url.startsWith('https://maps.googleapis.com/') ? trackedUpstream({ headers: streetViewType === undefined ? {} : { 'content-type': streetViewType }, body: 'street-view', }).response : upstreamResponse({ headers: { 'content-type': 'image/svg+xml' }, body: '', }), ); process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key'; for (const type of [ 'image/svg+xml', 'text/html', 'application/xml', undefined, ]) { streetViewType = type; const res = await app.call(`/frame/${STILL.id}`); assert.equal(res.statusCode, 200); assert.equal(res.headers['X-CCTV-Source'], 'synthetic', String(type)); assert.doesNotMatch(res.body, /street-view/); } streetViewType = 'image/JPEG; charset=x'; const res = await app.call(`/frame/${STILL.id}`); assert.equal(res.headers['X-CCTV-Source'], 'streetview'); assert.equal(res.headers['Content-Type'], 'image/jpeg'); assert.equal(res.body, 'street-view'); }); test('a forwarded same-origin request reaches every CCTV route but not the Street View fallback', async (t) => { const app = mount(t, ({ url }) => { if (url.startsWith('https://maps.googleapis.com/')) return trackedUpstream({ headers: { 'content-type': 'image/jpeg' }, body: 'street-view', }).response; return url === VIDEO.url ? upstreamResponse({ headers: { 'content-type': 'video/mp4' } }) : upstreamResponse({ status: 503, body: '' }); }); process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key'; const host = 'localhost:5173'; const streetViewCalls = () => app.requests.filter(({ url }) => url.startsWith('https://maps.googleapis.com/'), ).length; for (const forwarded of [ { 'x-forwarded-for': '203.0.113.9' }, { via: '1.1 proxy' }, { forwarded: 'for=203.0.113.9' }, { 'x-real-ip': '203.0.113.9' }, { 'x-forwarded-for': '' }, { 'x-forwarded-for': ' ' }, { 'cf-connecting-ip': '' }, ]) { const headers = { host, 'sec-fetch-site': 'same-origin', ...forwarded }; const label = JSON.stringify(forwarded); assert.equal((await app.call('/sources', headers)).statusCode, 200, label); const media = await app.call(`/media/${VIDEO.id}`, headers); assert.equal(media.statusCode, 200, label); assert.equal(media.headers['Content-Type'], 'video/mp4', label); const frame = await app.call(`/frame/${STILL.id}`, headers); assert.equal(frame.statusCode, 200, label); assert.equal(frame.headers['X-CCTV-Source'], 'synthetic', label); assert.equal(frame.headers['Content-Type'], 'image/svg+xml', label); // Cross-site stays refused whatever the forwarding headers say. for (const path of ['/sources', `/frame/${STILL.id}`, `/media/${VIDEO.id}`]) assert.equal( ( await app.call(path, { ...forwarded, host, 'sec-fetch-site': 'cross-site', }) ).statusCode, 403, `${label} ${path}`, ); } assert.equal(streetViewCalls(), 0, 'a forwarded request spent the key'); const direct = await app.call(`/frame/${STILL.id}`, { host, 'sec-fetch-site': 'same-origin', }); assert.equal(direct.headers['X-CCTV-Source'], 'streetview'); assert.equal(direct.body, 'street-view'); assert.equal(streetViewCalls(), 1); }); test('the Street View fallback frames catalog cameras only, from the catalog position', async (t) => { const app = mount(t, ({ url }) => url.startsWith('https://maps.googleapis.com/') ? trackedUpstream({ headers: { 'content-type': 'image/jpeg' }, body: 'street-view', }).response : upstreamResponse({ status: 503 }), ); process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key'; const streetView = () => app.requests.filter(({ url }) => url.startsWith('https://maps.googleapis.com/'), ); const unknown = await app.call('/frame/not-a-camera?lat=48.85&lon=2.29'); assert.equal(unknown.headers['X-CCTV-Source'], 'synthetic'); assert.deepEqual(streetView(), [], 'no Google call for an unknown id'); const steered = await app.call( `/frame/${STILL.id}?lat=48.85&lon=2.29&heading=90&fov=74&pitch=-17`, ); assert.equal(steered.headers['X-CCTV-Source'], 'streetview'); const sv = new URL(streetView()[0].url).searchParams; assert.equal(sv.get('location'), `${STILL.lat},${STILL.lon}`); assert.equal(sv.get('heading'), '90'); assert.equal(sv.get('fov'), '74'); assert.equal(sv.get('pitch'), '-17'); }); test('the Street View fallback spends a per-IP Google budget, and only with a key', async (t) => { const app = mount(t, ({ url }) => url.startsWith('https://maps.googleapis.com/') ? trackedUpstream({ headers: { 'content-type': 'image/jpeg' }, body: 'street-view', }).response : upstreamResponse({ status: 503 }), ); // Read when the first keyed fallback builds the limiter, so after mount(). process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '2'; const streetViewCalls = () => app.requests.filter(({ url }) => url.startsWith('https://maps.googleapis.com/'), ).length; const first = '203.0.113.7'; const frameSource = async (address) => (await app.call(`/frame/${STILL.id}`, {}, 'GET', address)).headers[ 'X-CCTV-Source' ]; // Without a key nothing is spent. for (let i = 0; i < 3; i++) assert.equal(await frameSource(first), 'synthetic'); assert.equal(streetViewCalls(), 0); process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key'; // Neither an unknown id nor a forwarded request spends the window. assert.equal( (await app.call('/frame/not-a-camera', {}, 'GET', first)).headers[ 'X-CCTV-Source' ], 'synthetic', ); assert.equal( ( await app.call( `/frame/${STILL.id}`, { 'x-forwarded-for': '203.0.113.9' }, 'GET', first, ) ).headers['X-CCTV-Source'], 'synthetic', ); assert.deepEqual( [ await frameSource(first), await frameSource(first), await frameSource(first), ], ['streetview', 'streetview', 'synthetic'], ); assert.equal(streetViewCalls(), 2, 'no Google call over the budget'); // Another address has a budget of its own. assert.equal(await frameSource('203.0.113.8'), 'streetview'); assert.equal(streetViewCalls(), 3); // Addresses within one IPv6 /64 share a budget. const v6 = frameSource; assert.deepEqual( [await v6('2001:db8::1'), await v6('2001:db8::2'), await v6('2001:db8::3')], ['streetview', 'streetview', 'synthetic'], ); assert.equal(await v6('2001:db8:0:1::1'), 'streetview', 'another /64'); assert.equal(streetViewCalls(), 6); });