From edbd599aecfe9617f3278777341c2cc283908384 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Fri, 13 Nov 2026 11:14:05 +0000 Subject: [PATCH] url: restrict option copying in urlToHttpOptions to URL instances Only spread own enumerable properties for URL instances created by this realm's URL constructor. Duck-typed objects accepted by isURL() can no longer smuggle connection options (socketPath, method, headers, agent) into a request. This fixes a footgun where a hostname-validated http.request() could be redirected to a Unix socket (e.g. the Docker daemon) via a URL-shaped object, bypassing hostname-based SSRF checks. Extending a genuine URL object with extra options is preserved. PR-URL: https://github.com/nodejs/node/pull/67454 Refs: https://github.com/nodejs/node/pull/46989 Signed-off-by: Matteo Collina --- doc/api/url.md | 14 +++++ lib/internal/url.js | 7 ++- ...t-http-client-request-options-injection.js | 54 +++++++++++++++++++ test/parallel/test-url-urltooptions.js | 38 +++++++++++++ 4 files changed, 112 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-http-client-request-options-injection.js diff --git a/doc/api/url.md b/doc/api/url.md index 7759c03a15e7..1688042c7625 100644 --- a/doc/api/url.md +++ b/doc/api/url.md @@ -1517,6 +1517,12 @@ added: - v15.7.0 - v14.18.0 changes: + - version: REPLACEME + pr-url: https://github.com/nodejs/node/pull/67454 + description: The own enumerable properties of the `url` argument are now + only carried over when `url` is a WHATWG `URL` instance created + by this realm's `URL` constructor, rather than for any + duck-typed object. - version: - v19.9.0 - v18.17.0 @@ -1545,6 +1551,14 @@ changes: This utility function converts a URL object into an ordinary options object as expected by the [`http.request()`][] and [`https.request()`][] APIs. +If `url` is a WHATWG `URL` instance created by this realm's `URL` constructor, +the returned object will also contain all of its own enumerable properties. This +allows a `URL` object to be extended with additional request options (for +example `url.headers = { 'X-Foo': 'bar' }`). Objects that merely share the +shape of a `URL` (as accepted by the duck-typed `isURL()` check used by +`http.request()`) are **not** treated this way, so they cannot smuggle +connection/transport options such as `socketPath` into the request. + ```mjs import { urlToHttpOptions } from 'node:url'; const myURL = new URL('https://a:b@測試?abc#foo'); diff --git a/lib/internal/url.js b/lib/internal/url.js index 0fe819fe129c..3b9ab6b59de3 100644 --- a/lib/internal/url.js +++ b/lib/internal/url.js @@ -1475,7 +1475,12 @@ function urlToHttpOptions(url) { const { hostname, pathname, port, username, password, search } = url; const options = { __proto__: null, - ...url, // In case the url object was extended by the user. + // Only spread own enumerable properties for genuine WHATWG URL instances so + // that a URL object can still be extended with additional request options + // (e.g. `url.headers = ...`). Arbitrary duck-typed objects accepted by + // `isURL()` must not be able to smuggle transport/connection options (e.g. + // `socketPath`) into a request and bypass hostname-based SSRF defenses. + ...(isURLInstance(url) ? url : undefined), protocol: url.protocol, hostname: hostname && hostname[0] === '[' ? StringPrototypeSlice(hostname, 1, -1) : diff --git a/test/parallel/test-http-client-request-options-injection.js b/test/parallel/test-http-client-request-options-injection.js new file mode 100644 index 000000000000..47067f1895bd --- /dev/null +++ b/test/parallel/test-http-client-request-options-injection.js @@ -0,0 +1,54 @@ +'use strict'; + +const common = require('../common'); +const assert = require('node:assert'); +const http = require('node:http'); +const path = require('node:path'); +const tmpdir = require('../common/tmpdir'); + +// Regression test: an ordinary object that happens to satisfy `isURL()` (truthy +// `href`/`protocol`, with `auth`/`path` absent) must not be able to smuggle +// HTTP request options such as `socketPath`, `method`, `headers`, or `agent` +// through `urlToHttpOptions()`. Doing so would let an attacker redirect an +// otherwise hostname-validated request to a Unix domain socket (e.g. the +// Docker daemon) and defeat hostname-based SSRF defenses. + +const server = http.createServer(common.mustCall((req, res) => { + assert.strictEqual(req.method, 'GET'); // `method` must not be smuggled in. + assert.strictEqual(req.headers['x-injected'], undefined); // `headers` too. + assert.strictEqual(req.url, '/ping'); + res.writeHead(200); + res.end('pong'); +})); + +server.listen(0, common.localhostIPv4, common.mustCall(() => { + const { port } = server.address(); + // A duck-typed object that `isURL()` would accept, but which is not a genuine + // WHATWG URL instance. + const duckTypedUrl = { + href: 'http://127.0.0.1/verify', + protocol: 'http:', + hostname: '127.0.0.1', + pathname: '/ping', + port: String(port), + username: '', + password: '', + search: '', + hash: '', + socketPath: path.join(tmpdir.path, 'should-not-be-used.sock'), + method: 'POST', + headers: { 'x-injected': 'yes' }, + agent: false, + }; + const req = http.request(duckTypedUrl, common.mustCall((res) => { + let body = ''; + res.on('data', (chunk) => { body += chunk; }); + res.on('end', common.mustCall(() => { + assert.strictEqual(body, 'pong'); + server.close(); + })); + })); + req.on('error', common.mustNotCall( + 'request connected to the injected socketPath instead of the hostname')); + req.end(); +})); diff --git a/test/parallel/test-url-urltooptions.js b/test/parallel/test-url-urltooptions.js index 8e7e5dc89409..5df48afe0429 100644 --- a/test/parallel/test-url-urltooptions.js +++ b/test/parallel/test-url-urltooptions.js @@ -36,6 +36,44 @@ assert.strictEqual(copiedOpts.search, undefined); assert.strictEqual(copiedOpts.hash, undefined); assert.strictEqual(copiedOpts.href, undefined); +// A genuine URL instance can still be extended with own enumerable properties +// (e.g. extra request options) and those properties are carried through. +const extendedUrl = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test'); +extendedUrl.headers = { foo: 'Bar' }; +extendedUrl.method = 'POST'; +const extendedOpts = urlToHttpOptions(extendedUrl); +assert.deepStrictEqual(extendedOpts.headers, { foo: 'Bar' }); +assert.strictEqual(extendedOpts.method, 'POST'); + +// A duck-typed object that satisfies `isURL()` (truthy `href` and `protocol`, +// `auth`/`path` absent) must not be able to smuggle transport/connection +// options (e.g. `socketPath`) into the request options. Only genuine WHATWG +// URL instances may carry additional own enumerable properties. +const duckTypedUrl = { + href: 'http://safe-webhook.com/verify', + protocol: 'http:', + hostname: 'safe-webhook.com', + pathname: '/v1.41/version', + port: '', + username: '', + password: '', + search: '', + hash: '', + socketPath: '/var/run/docker.sock', + method: 'GET', + headers: { 'Content-Type': 'application/json' }, + agent: false, +}; +const duckTypedOpts = urlToHttpOptions(duckTypedUrl); +assert.strictEqual(duckTypedOpts.socketPath, undefined); +assert.strictEqual(duckTypedOpts.method, undefined); +assert.strictEqual(duckTypedOpts.headers, undefined); +assert.strictEqual(duckTypedOpts.agent, undefined); +// URL-derived fields are still populated from the duck-typed object. +assert.strictEqual(duckTypedOpts.hostname, 'safe-webhook.com'); +assert.strictEqual(duckTypedOpts.path, '/v1.41/version'); +assert.strictEqual(duckTypedOpts.protocol, 'http:'); + // Test when passed an invalid argument assert.throws(() => { urlToHttpOptions('http://127.0.0.1');