From 14913e71ab86393073469f07add35aa25e021b60 Mon Sep 17 00:00:00 2001 From: 0libote <79215282+0libote@users.noreply.github.com> Date: Sat, 14 Nov 2026 11:00:41 +0000 Subject: [PATCH 1/3] fix(gateways): refuse metadata addresses and escape Codex TOML values Metadata ranges (169.254.0.0/16, fd00:ec2::254) are now refused with a distinct metadata-host code even with private-host consent, so no gateway or management key is ever sent there. parseAddress also rejects quote, backslash and backtick, and Codex launch arguments TOML-escape values. --- docker/setup/gateways.mjs | 1 + docker/setup/gateways/adapters.mjs | 4 +- docker/setup/gateways/address.mjs | 19 +++++++++ docker/setup/gateways/hub.mjs | 3 +- docker/setup/gateways/probe.mjs | 2 + docker/setup/gateways/transport.mjs | 4 +- tests/gateways-address.test.mjs | 10 ++++- tests/gateways-metadata-codex.test.mjs | 54 ++++++++++++++++++++++++++ tests/gateways-probe.test.mjs | 13 +++++-- 9 files changed, 102 insertions(+), 8 deletions(-) create mode 100644 tests/gateways-metadata-codex.test.mjs diff --git a/docker/setup/gateways.mjs b/docker/setup/gateways.mjs index d2824de..a15c775 100644 --- a/docker/setup/gateways.mjs +++ b/docker/setup/gateways.mjs @@ -73,6 +73,7 @@ const cleanManagementKey = value => { }; const allowPrivate = input => (input?.allowPrivateHost ?? input?.gateway?.allowPrivateHost) === true; const requireHostConsent = result => { + if (result?.code === 'metadata-host') throw new GatewayError(result.message, 409, 'metadata-host', { field: 'url', hint: result.hint }); if (result?.code === 'private-host') throw new GatewayError(result.message, 409, 'private-host', { field: 'url', confirmHost: result.confirmHost, hint: result.hint }); }; const cleanAddress = (value, allowPrivateHost = false) => { diff --git a/docker/setup/gateways/adapters.mjs b/docker/setup/gateways/adapters.mjs index 470aa09..964e4ed 100644 --- a/docker/setup/gateways/adapters.mjs +++ b/docker/setup/gateways/adapters.mjs @@ -205,6 +205,8 @@ const SPECS = Object.freeze({ config: (gateway, models, base, files, capabilities) => { const id = providerId(gateway), key = name => `model_providers.${id}.${name}`; // Single-quoted for T3's tokenizer, double-quoted inside so Codex reads TOML strings. + // Escape for TOML basic strings, so a quote or backslash in the URL cannot break out. + const tomlValue = value => String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"'); const overrides = [['model_provider', id], [key('name'), gateway.id], [key('base_url'), `${gateway.url}/v1`], [key('env_key'), GATEWAY_KEY_ENV], [key('wire_api'), 'responses']]; if (hasCodexCatalog(gateway, models)) overrides.push(['model_catalog_json', files.config]); // Codex needs the key; the shells it opens don't. Without this it also lands @@ -214,7 +216,7 @@ const SPECS = Object.freeze({ binaryPath: base.binaryPath, homePath: base.homePath, shadowHomePath: base.shadowHomePath, - launchArgs: [base.launchArgs, ...overrides.map(([name, value]) => `-c '${name}="${value}"'`), keepFromShells].filter(Boolean).join(' '), + launchArgs: [base.launchArgs, ...overrides.map(([name, value]) => `-c '${name}="${tomlValue(value)}"'`), keepFromShells].filter(Boolean).join(' '), customModels: t3Models('codex', gateway, models, capabilities), }; }, diff --git a/docker/setup/gateways/address.mjs b/docker/setup/gateways/address.mjs index f01d705..6329326 100644 --- a/docker/setup/gateways/address.mjs +++ b/docker/setup/gateways/address.mjs @@ -30,6 +30,20 @@ export function isMetadata(hostname) { return Boolean(m) && Number(m[1]) === 169 && Number(m[2]) === 254 || ipv6(host) === 'fd00:ec2::254'; } +/** A resolved address in a metadata range. Never allowed, even with private-host consent. */ +export function isMetadataIp(ip) { + const v = stripBrackets(String(ip ?? '').toLowerCase()); + const m = /^(\d{1,3})\.(\d{1,3})\.\d{1,3}\.\d{1,3}$/.exec(v); + if (m) return Number(m[1]) === 169 && Number(m[2]) === 254; + const canonical = ipv6(v); + const mapped = /^::ffff:([a-f0-9]+):([a-f0-9]+)$/.exec(canonical ?? ''); + if (mapped) { + const high = parseInt(mapped[1], 16), low = parseInt(mapped[2], 16); + return isMetadataIp([high >> 8, high & 255, low >> 8, low & 255].join('.')); + } + return canonical === 'fd00:ec2::254'; +} + /** A Compose service name or LAN host: no dot, no colon, just letters, digits and dashes. */ export function isSingleLabel(hostname) { const host = stripBrackets(String(hostname ?? '').toLowerCase()); @@ -93,6 +107,7 @@ export function parseAddress(input, options = {}) { const allowPrivateHost = options?.allowPrivateHost === true; const text = String(input ?? '').trim(); if (!text) return { ok: false, error: 'Enter your gateway’s address.' }; + if (/["`\\]/.test(text)) return { ok: false, error: 'Remove " and \\ and ` from the address.' }; if (text.length > MAX_URL || /[\s\0]/.test(text)) return { ok: false, error: 'Enter a single address, without spaces.' }; let parsed; try { parsed = new URL(SCHEME.test(text) ? text : assumedScheme(text) + text); } @@ -108,6 +123,10 @@ export function parseAddress(input, options = {}) { pathname = trimmed; } const hostname = stripBrackets(parsed.hostname); + if (isMetadata(hostname)) { + return { ok: false, code: 'metadata-host', hostname, host: parsed.host, + error: `“${hostname}” is a cloud metadata address. A gateway can never use it.` }; + } if (!allowPrivateHost && needsPrivateConfirm(hostname)) { return { ok: false, code: 'private-host', hostname, host: parsed.host, error: `“${hostname}” looks like a private host. Confirm that you trust this address with your credentials.` }; diff --git a/docker/setup/gateways/hub.mjs b/docker/setup/gateways/hub.mjs index f967c79..4ca4aba 100644 --- a/docker/setup/gateways/hub.mjs +++ b/docker/setup/gateways/hub.mjs @@ -53,11 +53,12 @@ const refusal = text => { */ export async function probeHub({ url, key, fetchImpl = globalThis.fetch, timeoutMs = TIMEOUT_MS, signal, allowPrivateHost = false, lookup = lookupGateway } = {}) { const parsed = parseAddress(url, { allowPrivateHost }); + if (!parsed.ok && parsed.code === 'metadata-host') return { ...failure('metadata-host', parsed.error, 'Use a gateway address instead.') }; if (!parsed.ok && parsed.code === 'private-host') return { ...failure('private-host', parsed.error, 'Confirm that you trust this address with your credentials, then try again.'), confirmHost: parsed.hostname }; if (!parsed.ok) return REFUSED.unreachable(); let fetchPinned; try { fetchPinned = await gatewayFetch(parsed, { allowPrivateHost, lookup, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs), fetchImpl }); } - catch (error) { return error.code === 'private-host' ? { ...failure('private-host', `“${parsed.hostname}” resolves to a private host.`, 'Confirm this host before sending a key.'), confirmHost: parsed.hostname } : REFUSED.unreachable(); } + catch (error) { if (error.code === 'metadata-host') return { ...failure('metadata-host', `“${parsed.hostname}” is a cloud metadata address. A gateway can never use it.`, 'Use a gateway address instead.') }; return error.code === 'private-host' ? { ...failure('private-host', `“${parsed.hostname}” resolves to a private host.`, 'Confirm this host before sending a key.'), confirmHost: parsed.hostname } : REFUSED.unreachable(); } // Keyless first: a host that can't be reached never sees the management key. try { const probe = await fetchPinned(`${parsed.url}/`, { redirect: 'manual', headers: { accept: 'application/json', 'user-agent': 't3code-docker-setup' }, diff --git a/docker/setup/gateways/probe.mjs b/docker/setup/gateways/probe.mjs index 48aa2ba..1219cfc 100644 --- a/docker/setup/gateways/probe.mjs +++ b/docker/setup/gateways/probe.mjs @@ -114,10 +114,12 @@ export async function probeGateway({ url: input, key = '', fetchImpl = globalThi const { url, notes, insecure, hostname } = address, headers = headersFor(key), keyless = headersFor(), limit = () => signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs); const finish = (result) => ({ at, url, notes, insecure, ms: Math.max(0, now() - at), models: { listed: false, ids: [], capabilities: {} }, protocols: {}, ...result }); const privateRefusal = pinned => finish({ ok: false, code: 'private-host', confirmHost: hostname, host: address.host, message: `“${hostname}” looks like a private host${pinned ? ` (${pinned})` : ''}.`, hint: 'Tick “Private host” to confirm this address is yours, then test again.' }); + const metadataRefusal = pinned => finish({ ok: false, code: 'metadata-host', host: address.host, message: `“${hostname}” is a cloud metadata address${pinned ? ` (${pinned})` : ''}. A gateway can never use it.`, hint: 'Use a gateway address instead.' }); // DNS is pinned once, before any request: no re-resolve per redirect or per route. let fetchPinned; try { fetchPinned = await gatewayFetch(address, { allowPrivateHost, lookup, signal: limit(), fetchImpl }); } catch (error) { + if (error.code === 'metadata-host') return metadataRefusal(error.address); if (error.code === 'private-host') return privateRefusal(error.address); const code = connectionCode(error); return finish({ ok: false, code, ...connectionProblem(code, address) }); } diff --git a/docker/setup/gateways/transport.mjs b/docker/setup/gateways/transport.mjs index baf4988..0d03eb6 100644 --- a/docker/setup/gateways/transport.mjs +++ b/docker/setup/gateways/transport.mjs @@ -5,7 +5,7 @@ import { isIP } from 'node:net'; import http from 'node:http'; import https from 'node:https'; import { Readable } from 'node:stream'; -import { isBlockedIp } from './address.mjs'; +import { isBlockedIp, isMetadataIp } from './address.mjs'; export const lookupGateway = hostname => dnsLookup(hostname, { all: true }); const dnsError = () => Object.assign(new Error('The gateway address could not be resolved.'), { code: 'ENOTFOUND' }); @@ -32,6 +32,8 @@ async function resolved(hostname, lookup, signal) { export async function gatewayFetch(address, { allowPrivateHost = false, lookup = lookupGateway, signal, fetchImpl = globalThis.fetch } = {}) { const addresses = await resolved(address.hostname, lookup, signal); + const metadata = addresses.find(row => isMetadataIp(row.address)); + if (metadata) throw Object.assign(new Error('The gateway resolves to a cloud metadata address.'), { code: 'metadata-host', address: metadata.address }); const blocked = addresses.find(row => isBlockedIp(row.address)); if (blocked && allowPrivateHost !== true) throw Object.assign(new Error('The gateway resolves to a private address.'), { code: 'private-host', address: blocked.address }); // Injected transports are for controlled adapters/tests. Production always diff --git a/tests/gateways-address.test.mjs b/tests/gateways-address.test.mjs index de1a62a..b795800 100644 --- a/tests/gateways-address.test.mjs +++ b/tests/gateways-address.test.mjs @@ -83,8 +83,8 @@ test('a pasted admin address loses its admin path, so a test can’t count as a } }); -test('loopback, metadata and single-label names need a private-host confirm', () => { - for (const input of ['http://localhost:8317', 'http://127.0.0.1:8317', 'http://127.1.2.3:8317', 'http://0.0.0.0:8317', 'http://[::1]:8317', 'http://169.254.169.254', 'http://169.254.10.20:80', 'http://gateway:8317', 'cliproxy:8317', 'localhost:8317']) { +test('loopback and single-label names need a private-host confirm, metadata stays refused', () => { + for (const input of ['http://localhost:8317', 'http://127.0.0.1:8317', 'http://127.1.2.3:8317', 'http://0.0.0.0:8317', 'http://[::1]:8317', 'http://gateway:8317', 'cliproxy:8317', 'localhost:8317']) { const rejected = parseAddress(input); assert.equal(rejected.ok, false, input); assert.equal(rejected.code, 'private-host', input); @@ -92,6 +92,12 @@ test('loopback, metadata and single-label names need a private-host confirm', () const allowed = parseAddress(input, { allowPrivateHost: true }); assert.equal(allowed.ok, true, input); } + for (const input of ['http://169.254.169.254', 'http://169.254.10.20:80']) { + assert.equal(parseAddress(input).code, 'metadata-host', input); + const refused = parseAddress(input, { allowPrivateHost: true }); + assert.equal(refused.ok, false, input); + assert.equal(refused.code, 'metadata-host', input); + } assert.equal(parseAddress('https://openrouter.ai/api').ok, true); assert.equal(parseAddress('http://192.168.1.20:4000').ok, true); assert.equal(parseAddress('http://10.0.0.2:4000').ok, true); diff --git a/tests/gateways-metadata-codex.test.mjs b/tests/gateways-metadata-codex.test.mjs new file mode 100644 index 0000000..dddc95d --- /dev/null +++ b/tests/gateways-metadata-codex.test.mjs @@ -0,0 +1,54 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { isMetadataIp, parseAddress } from '../docker/setup/gateways/address.mjs'; +import { probeGateway } from '../docker/setup/gateways/probe.mjs'; +import { probeHub } from '../docker/setup/gateways/hub.mjs'; +import { desiredInstance } from '../docker/setup/gateways/adapters.mjs'; +import { agentOf } from '../docker/setup/gateways/catalog.mjs'; + +const codex = agentOf('codex'); + +test('metadata stays refused even with private-host consent', () => { + for (const url of ['http://169.254.169.254/', 'http://169.254.10.20:80', 'http://[fd00:ec2::254]/']) { + const parsed = parseAddress(url, { allowPrivateHost: true }); + assert.equal(parsed.ok, false, url); + assert.equal(parsed.code, 'metadata-host', url); + } + assert.equal(isMetadataIp('169.254.169.254'), true); + assert.equal(isMetadataIp('169.254.0.1'), true); + assert.equal(isMetadataIp('fd00:ec2::254'), true); + assert.equal(isMetadataIp('127.0.0.1'), false); + assert.equal(isMetadataIp('192.168.1.1'), false); + assert.equal(isMetadataIp('8.8.8.8'), false); + // Consent still opens loopback, RFC1918 and Compose names. + assert.equal(parseAddress('http://127.0.0.1:8317', { allowPrivateHost: true }).ok, true); + assert.equal(parseAddress('http://192.168.1.20:4000').ok, true); + assert.equal(parseAddress('http://gateway:8317', { allowPrivateHost: true }).ok, true); +}); + +test('a metadata probe sends no key, even with consent', async () => { + let called = 0; + const fetchImpl = async () => { called++; return new Response('{}', { status: 200 }); }; + const direct = await probeGateway({ url: 'http://169.254.169.254/', key: 'sk-test', allowPrivateHost: true, fetchImpl }); + assert.equal(direct.code, 'metadata-host'); + assert.equal(called, 0); + const viaDns = await probeGateway({ url: 'https://gateway.example.com', key: 'sk-test', allowPrivateHost: true, fetchImpl, lookup: async () => '169.254.169.254' }); + assert.equal(viaDns.code, 'metadata-host'); + assert.equal(called, 0); + const hub = await probeHub({ url: 'http://169.254.169.254/', key: 'mgmt-test', allowPrivateHost: true, fetchImpl }); + assert.equal(hub.code, 'metadata-host'); + assert.equal(called, 0); +}); + +test('quote, backslash and backtick never become an address', () => { + for (const url of ['http://127.0.0.1:8317/a"b', 'http://127.0.0.1:8317/a\\b', 'http://127.0.0.1:8317/a`b']) { + const parsed = parseAddress(url, { allowPrivateHost: true }); + assert.equal(parsed.ok, false, url); + } +}); + +test('Codex launch arguments escape quotes and backslashes for TOML', () => { + const gateway = { id: 'my-proxy', name: 'My Proxy', url: 'http://127.0.0.1:8317/a"b\\c', accent: '#6366f1', models: { ids: [], manual: [] }, agents: { codex: { on: true } } }; + const { config } = desiredInstance(codex, gateway, { dir: '/d' }); + assert.match(config.launchArgs, /a\\"b\\\\c\/v1/); +}); diff --git a/tests/gateways-probe.test.mjs b/tests/gateways-probe.test.mjs index 2118268..e6e79e2 100644 --- a/tests/gateways-probe.test.mjs +++ b/tests/gateways-probe.test.mjs @@ -260,12 +260,14 @@ test('other gateways and rejected keys never request the CLIProxyAPI catalog', a test('a private host needs a confirm before any request goes out', async t => { const seen = []; const fetchImpl = async () => { seen.push(true); throw new Error('must not fetch'); }; - for (const url of ['http://localhost:8317', 'http://127.0.0.1:8317', 'http://0.0.0.0:8317', 'http://[::1]:8317', 'http://169.254.169.254', 'http://gateway:8317']) { + for (const url of ['http://localhost:8317', 'http://127.0.0.1:8317', 'http://0.0.0.0:8317', 'http://[::1]:8317', 'http://gateway:8317']) { const result = await probeGateway({ url, key: 'sk-test', fetchImpl }); assert.equal(result.code, 'private-host', url); assert.match(result.message, /Private host|private host/); assert.equal(result.confirmHost, result.confirmHost); } + const metadata = await probeGateway({ url: 'http://169.254.169.254', key: 'sk-test', fetchImpl, allowPrivateHost: true }); + assert.equal(metadata.code, 'metadata-host'); assert.equal(seen.length, 0, 'No request, keyed or not, without a confirm'); const server = await serve(gateway()); within(t, server); const allowed = await probeGateway({ allowPrivateHost: true, url: server.url, key: 'sk-test' }); @@ -276,13 +278,18 @@ test('a private host needs a confirm before any request goes out', async t => { test('a name that resolves to a blocked address needs the same confirm', async () => { const seen = []; const fetchImpl = async () => { seen.push(true); return new Response(JSON.stringify({ data: [] }), { status: 200 }); }; - const blocked = await probeGateway({ url: 'https://gateway.example.com', key: 'sk-test', fetchImpl, lookup: async () => '169.254.169.254' }); + const blocked = await probeGateway({ url: 'https://gateway.example.com', key: 'sk-test', fetchImpl, lookup: async () => '127.0.0.1' }); assert.equal(blocked.code, 'private-host'); assert.equal(blocked.confirmHost, 'gateway.example.com'); assert.equal(seen.length, 0); - const allowed = await probeGateway({ allowPrivateHost: true, url: 'https://gateway.example.com', key: 'sk-test', fetchImpl, lookup: async () => '169.254.169.254' }); + const allowed = await probeGateway({ allowPrivateHost: true, url: 'https://gateway.example.com', key: 'sk-test', fetchImpl, lookup: async () => '127.0.0.1' }); assert.notEqual(allowed.code, 'private-host'); assert.ok(seen.length > 0, 'DNS is pinned once, then the keyed probe runs'); + const metaSeen = []; + const metaFetch = async () => { metaSeen.push(true); return new Response(JSON.stringify({ data: [] }), { status: 200 }); }; + const meta = await probeGateway({ allowPrivateHost: true, url: 'https://gateway.example.com', key: 'sk-test', fetchImpl: metaFetch, lookup: async () => '169.254.169.254' }); + assert.equal(meta.code, 'metadata-host'); + assert.equal(metaSeen.length, 0, 'No request to metadata, even with consent'); }); test('an unreachable host sees no key: the keyless check runs first', async t => { From 55ec69cf3baaf947d4ea09fd3c320cb1c77b51af Mon Sep 17 00:00:00 2001 From: 0libote <79215282+0libote@users.noreply.github.com> Date: Sat, 14 Nov 2026 11:35:05 +0000 Subject: [PATCH 2/3] fix(gateways): refuse mapped metadata IPs at parse, fix transport test The mapped literal 0:0:0:0:0:ffff:a9fe:a9fe (::ffff:169.254.169.254) fell through to private-host at parse and relied on the transport pin to refuse it. parseAddress now checks resolved-form metadata too. The transport test pins the new codes with and without consent. --- docker/setup/gateways/address.mjs | 2 +- tests/gateway-transport.test.mjs | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docker/setup/gateways/address.mjs b/docker/setup/gateways/address.mjs index 6329326..35ec2b9 100644 --- a/docker/setup/gateways/address.mjs +++ b/docker/setup/gateways/address.mjs @@ -123,7 +123,7 @@ export function parseAddress(input, options = {}) { pathname = trimmed; } const hostname = stripBrackets(parsed.hostname); - if (isMetadata(hostname)) { + if (isMetadata(hostname) || isMetadataIp(hostname)) { return { ok: false, code: 'metadata-host', hostname, host: parsed.host, error: `“${hostname}” is a cloud metadata address. A gateway can never use it.` }; } diff --git a/tests/gateway-transport.test.mjs b/tests/gateway-transport.test.mjs index a9a0607..23e74d9 100644 --- a/tests/gateway-transport.test.mjs +++ b/tests/gateway-transport.test.mjs @@ -55,13 +55,17 @@ test('DNS resolution uses the same bounded probe deadline', async t => { }); test('IPv6 link-local, metadata and mapped loopback forms require literal boolean consent', () => { - for (const address of ['::ffff:127.0.0.1', '::ffff:7f00:1', '0:0:0:0:0:ffff:a9fe:a9fe', 'fe80::1', 'febf::1', 'fd00:ec2::254', '::']) { + for (const address of ['::ffff:127.0.0.1', '::ffff:7f00:1', 'fe80::1', 'febf::1', '::']) { assert.equal(isBlockedIp(address), true, address); assert.equal(parseAddress(`http://[${address}]`).code, 'private-host', address); assert.equal(parseAddress(`http://[${address}]`, { allowPrivateHost: 'false' }).code, 'private-host', address); assert.equal(parseAddress(`http://[${address}]`, { allowPrivateHost: true }).ok, true, address); } assert.equal(isBlockedIp('2606:4700:4700::1111'), false); + for (const address of ['fd00:ec2::254', '0:0:0:0:0:ffff:a9fe:a9fe']) { + assert.equal(parseAddress(`http://[${address}]`).code, 'metadata-host', address); + assert.equal(parseAddress(`http://[${address}]`, { allowPrivateHost: true }).code, 'metadata-host', address); + } }); test('a landing-page redirect does not reject working API paths or send a key to the target', async t => { From a2f080b52d05d29ec18a0b17c3c6c63149b365a2 Mon Sep 17 00:00:00 2001 From: 0libote <79215282+0libote@users.noreply.github.com> Date: Sat, 14 Nov 2026 11:58:34 +0000 Subject: [PATCH 3/3] fix(tests): expect Claude's 1M Gemini context window in native smoke The smoke installs the latest Claude Code and asserts the context window the binary reports for the fixture model. Claude now reports 1000000 where it reported 200000, failing the core smoke on every PR. --- scripts/gateways-native-smoke.mjs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/gateways-native-smoke.mjs b/scripts/gateways-native-smoke.mjs index bf9b073..52e249c 100644 --- a/scripts/gateways-native-smoke.mjs +++ b/scripts/gateways-native-smoke.mjs @@ -193,7 +193,7 @@ const smokes = { assert.deepEqual(found?.keys, ["ANTHROPIC_BASE_URL"]); await fs.writeFile(settings, '{}'); const baseline = JSON.parse(await runClaude(env, '', { model: 'gemini-smoke' })); - assert.equal(baseline.modelUsage['gemini-smoke'].contextWindow, 200000); + assert.equal(baseline.modelUsage['gemini-smoke'].contextWindow, 1000000); const source = new URL(process.env.T3_SETUP_DIR ? 'file:///opt/t3-runtime/patches/gateway-context.ts' : '../docker/runtime/patches/gateway-context.ts', import.meta.url); const helper = await import(`data:text/javascript,${encodeURIComponent(stripTypeScriptTypes(await fs.readFile(source, 'utf8')))}`); const gw = gatewayFor(gateway.url);