@atproto-labs/fetch-node 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -1,11 +1,24 @@
 # @atproto-labs/fetch-node
 
-## 0.0.1
+## 0.1.1
 
 ### Patch Changes
 
-- [`e134c79a0`](https://github.com/bluesky-social/atproto/commit/e134c79a0ffb000b2cb36437815673fa6bda664b) Thanks [@devinivy](https://github.com/devinivy)! - Initial publish of experimental oauth packages to @atproto-labs
+- [#2770](https://github.com/bluesky-social/atproto/pull/2770) [`a07b21151`](https://github.com/bluesky-social/atproto/commit/a07b21151f1850340c4b7797ebb11521b1a6cdf3) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Prevent bypass of ssrf ip verification
 
-- Updated dependencies [[`e134c79a0`](https://github.com/bluesky-social/atproto/commit/e134c79a0ffb000b2cb36437815673fa6bda664b)]:
-  - @atproto-labs/transformer@0.0.1
-  - @atproto-labs/fetch@0.0.1
+- [#2770](https://github.com/bluesky-social/atproto/pull/2770) [`a07b21151`](https://github.com/bluesky-social/atproto/commit/a07b21151f1850340c4b7797ebb11521b1a6cdf3) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Expose IP filtering utilities
+
+- Updated dependencies [[`a07b21151`](https://github.com/bluesky-social/atproto/commit/a07b21151f1850340c4b7797ebb11521b1a6cdf3), [`a07b21151`](https://github.com/bluesky-social/atproto/commit/a07b21151f1850340c4b7797ebb11521b1a6cdf3), [`a07b21151`](https://github.com/bluesky-social/atproto/commit/a07b21151f1850340c4b7797ebb11521b1a6cdf3)]:
+  - @atproto-labs/fetch@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- [#2482](https://github.com/bluesky-social/atproto/pull/2482) [`a8d6c1123`](https://github.com/bluesky-social/atproto/commit/a8d6c112359f5c4c0cfbe2df63443ed275f2a646) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add OAuth provider capability & support for DPoP signed tokens
+
+### Patch Changes
+
+- Updated dependencies [[`a8d6c1123`](https://github.com/bluesky-social/atproto/commit/a8d6c112359f5c4c0cfbe2df63443ed275f2a646)]:
+  - @atproto-labs/fetch@0.1.0
+  - @atproto-labs/pipe@0.1.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export * from '@atproto-labs/fetch';
 export * from './safe.js';
-export * from './ssrf.js';
+export * from './unicast.js';
+export * from './util.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AAEnC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,WAAW,CAAA"}

package/dist/index.js

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@atproto-labs/fetch"), exports);
 __exportStar(require("./safe.js"), exports);
-__exportStar(require("./ssrf.js"), exports);
+__exportStar(require("./unicast.js"), exports);
+__exportStar(require("./util.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAAyB;AACzB,4CAAyB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAmC;AAEnC,4CAAyB;AACzB,+CAA4B;AAC5B,4CAAyB"}

package/dist/safe.d.ts

@@ -3,14 +3,20 @@ export type SafeFetchWrapOptions = NonNullable<Parameters<typeof safeFetchWrap>[
 /**
  * Wrap a fetch function with safety checks so that it can be safely used
  * with user provided input (URL).
+ *
+ * @see {@link https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html}
  */
-export declare const safeFetchWrap: ({ fetch, responseMaxSize, allowHttp, allowData, ssrfProtection, timeout, forbiddenDomainNames, }?: {
+export declare function safeFetchWrap({ fetch, responseMaxSize, // 512kB
+ssrfProtection, allowCustomPort, allowData, allowHttp, allowIpHost, allowPrivateIps, timeout, forbiddenDomainNames, }?: {
     fetch?: Fetch | undefined;
     responseMaxSize?: number | undefined;
-    allowHttp?: boolean | undefined;
-    allowData?: boolean | undefined;
     ssrfProtection?: boolean | undefined;
+    allowCustomPort?: boolean | undefined;
+    allowData?: boolean | undefined;
+    allowHttp?: boolean | undefined;
+    allowIpHost?: boolean | undefined;
+    allowPrivateIps?: boolean | undefined;
     timeout?: number | undefined;
     forbiddenDomainNames?: Iterable<string> | undefined;
-}) => Fetch;
+}): Fetch<unknown>;
 //# sourceMappingURL=safe.d.ts.map

package/dist/safe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["../src/safe.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,EAMN,MAAM,qBAAqB,CAAA;AAK5B,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAC5C,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CACpC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;MAQjB,KA4CN,CAAA"}
+{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["../src/safe.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,EAQN,MAAM,qBAAqB,CAAA;AAK5B,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAC5C,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CACpC,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAiC,EACjC,eAA4B,EAAE,QAAQ;AACtC,cAAqB,EACrB,eAAiC,EACjC,SAAiB,EACjB,SAA2B,EAC3B,WAAkB,EAClB,eAAiC,EACjC,OAAc,EACd,oBAAyE,GAC1E;;;;;;;;;;;CAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAsDtB"}

package/dist/safe.js

@@ -2,48 +2,58 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.safeFetchWrap = void 0;
 const fetch_1 = require("@atproto-labs/fetch");
-const transformer_1 = require("@atproto-labs/transformer");
-const ssrf_js_1 = require("./ssrf.js");
+const pipe_1 = require("@atproto-labs/pipe");
+const unicast_js_1 = require("./unicast.js");
 /**
  * Wrap a fetch function with safety checks so that it can be safely used
  * with user provided input (URL).
+ *
+ * @see {@link https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html}
  */
-const safeFetchWrap = ({ fetch = globalThis.fetch, responseMaxSize = 512 * 1024, // 512kB
-allowHttp = false, allowData = false, ssrfProtection = true, timeout = 10e3, forbiddenDomainNames = fetch_1.DEFAULT_FORBIDDEN_DOMAIN_NAMES, } = {}) => (0, transformer_1.compose)(
-/**
- * Prevent using http:, file: or data: protocols.
- */
-(0, fetch_1.protocolCheckRequestTransform)(['https:']
-    .concat(allowHttp ? ['http:'] : [])
-    .concat(allowData ? ['data:'] : [])), 
-/**
- * Only requests that will be issued with a "Host" header are allowed.
- */
-(0, fetch_1.requireHostHeaderTranform)(), 
-/**
- * Disallow fetching from domains we know are not atproto/OIDC client
- * implementation. Note that other domains can be blocked by providing a
- * custom fetch function combined with another
- * forbiddenDomainNameRequestTransform.
- */
-(0, fetch_1.forbiddenDomainNameRequestTransform)(forbiddenDomainNames), 
-/**
- * Since we will be fetching from the network based on user provided
- * input, let's mitigate resource exhaustion attacks by setting a timeout.
- */
-(0, fetch_1.timeoutFetchWrap)({
-    timeout,
+function safeFetchWrap({ fetch = globalThis.fetch, responseMaxSize = 512 * 1024, // 512kB
+ssrfProtection = true, allowCustomPort = !ssrfProtection, allowData = false, allowHttp = !ssrfProtection, allowIpHost = true, allowPrivateIps = !ssrfProtection, timeout = 10e3, forbiddenDomainNames = fetch_1.DEFAULT_FORBIDDEN_DOMAIN_NAMES, } = {}) {
+    return (0, fetch_1.toRequestTransformer)((0, pipe_1.pipe)(
+    /**
+     * Disable HTTP redirects
+     */
+    (0, fetch_1.redirectCheckRequestTransform)(), 
+    /**
+     * Only requests that will be issued with a "Host" header are allowed.
+     */
+    allowIpHost ? fetch_1.asRequest : (0, fetch_1.requireHostHeaderTransform)(), 
+    /**
+     * Prevent using http:, file: or data: protocols.
+     */
+    (0, fetch_1.protocolCheckRequestTransform)({
+        'about:': false,
+        'data:': allowData,
+        'file:': false,
+        'http:': allowHttp && { allowCustomPort },
+        'https:': { allowCustomPort },
+    }), 
+    /**
+     * Disallow fetching from domains we know are not atproto/OIDC client
+     * implementation. Note that other domains can be blocked by providing a
+     * custom fetch function combined with another
+     * forbiddenDomainNameRequestTransform.
+     */
+    (0, fetch_1.forbiddenDomainNameRequestTransform)(forbiddenDomainNames), 
+    /**
+     * Since we will be fetching from the network based on user provided
+     * input, let's mitigate resource exhaustion attacks by setting a timeout.
+     */
+    (0, fetch_1.timedFetch)(timeout, 
     /**
      * Since we will be fetching from the network based on user provided
      * input, we need to make sure that the request is not vulnerable to SSRF
      * attacks.
      */
-    fetch: ssrfProtection ? (0, ssrf_js_1.ssrfFetchWrap)({ fetch }) : fetch,
-}), 
-/**
- * Since we will be fetching user owned data, we need to make sure that an
- * attacker cannot force us to download a large amounts of data.
- */
-(0, fetch_1.fetchMaxSizeProcessor)(responseMaxSize));
+    allowPrivateIps ? fetch : (0, unicast_js_1.unicastFetchWrap)({ fetch })), 
+    /**
+     * Since we will be fetching user owned data, we need to make sure that an
+     * attacker cannot force us to download a large amounts of data.
+     */
+    (0, fetch_1.fetchMaxSizeProcessor)(responseMaxSize)));
+}
 exports.safeFetchWrap = safeFetchWrap;
 //# sourceMappingURL=safe.js.map

package/dist/safe.js.map

@@ -1 +1 @@
-{"version":3,"file":"safe.js","sourceRoot":"","sources":["../src/safe.ts"],"names":[],"mappings":";;;AAAA,+CAQ4B;AAC5B,2DAAmD;AAEnD,uCAAyC;AAMzC;;;GAGG;AACI,MAAM,aAAa,GAAG,CAAC,EAC5B,KAAK,GAAG,UAAU,CAAC,KAAc,EACjC,eAAe,GAAG,GAAG,GAAG,IAAI,EAAE,QAAQ;AACtC,SAAS,GAAG,KAAK,EACjB,SAAS,GAAG,KAAK,EACjB,cAAc,GAAG,IAAI,EACrB,OAAO,GAAG,IAAc,EACxB,oBAAoB,GAAG,sCAAkD,MACvE,EAAE,EAAS,EAAE,CACf,IAAA,qBAAO;AACL;;GAEG;AACH,IAAA,qCAA6B,EAC3B,CAAC,QAAQ,CAAC;KACP,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;KAClC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CACtC;AAED;;GAEG;AACH,IAAA,iCAAyB,GAAE;AAE3B;;;;;GAKG;AACH,IAAA,2CAAmC,EAAC,oBAAoB,CAAC;AAEzD;;;GAGG;AACH,IAAA,wBAAgB,EAAC;IACf,OAAO;IAEP;;;;OAIG;IACH,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,IAAA,uBAAa,EAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK;CACzD,CAAC;AAEF;;;GAGG;AACH,IAAA,6BAAqB,EAAC,eAAe,CAAC,CACvC,CAAA;AApDU,QAAA,aAAa,iBAoDvB"}
+{"version":3,"file":"safe.js","sourceRoot":"","sources":["../src/safe.ts"],"names":[],"mappings":";;;AAAA,+CAW4B;AAC5B,6CAAyC;AAEzC,6CAA+C;AAM/C;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,EAC5B,KAAK,GAAG,UAAU,CAAC,KAAc,EACjC,eAAe,GAAG,GAAG,GAAG,IAAI,EAAE,QAAQ;AACtC,cAAc,GAAG,IAAI,EACrB,eAAe,GAAG,CAAC,cAAc,EACjC,SAAS,GAAG,KAAK,EACjB,SAAS,GAAG,CAAC,cAAc,EAC3B,WAAW,GAAG,IAAI,EAClB,eAAe,GAAG,CAAC,cAAc,EACjC,OAAO,GAAG,IAAI,EACd,oBAAoB,GAAG,sCAAkD,MACvE,EAAE;IACJ,OAAO,IAAA,4BAAoB,EACzB,IAAA,WAAI;IACF;;OAEG;IACH,IAAA,qCAA6B,GAAE;IAE/B;;OAEG;IACH,WAAW,CAAC,CAAC,CAAC,iBAAS,CAAC,CAAC,CAAC,IAAA,kCAA0B,GAAE;IAEtD;;OAEG;IACH,IAAA,qCAA6B,EAAC;QAC5B,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,SAAS;QAClB,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,SAAS,IAAI,EAAE,eAAe,EAAE;QACzC,QAAQ,EAAE,EAAE,eAAe,EAAE;KAC9B,CAAC;IAEF;;;;;OAKG;IACH,IAAA,2CAAmC,EAAC,oBAAoB,CAAC;IAEzD;;;OAGG;IACH,IAAA,kBAAU,EACR,OAAO;IAEP;;;;OAIG;IACH,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAA,6BAAgB,EAAC,EAAE,KAAK,EAAE,CAAC,CACtD;IAED;;;OAGG;IACH,IAAA,6BAAqB,EAAC,eAAe,CAAC,CACvC,CACF,CAAA;AACH,CAAC;AAjED,sCAiEC"}

package/dist/unicast.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import dns from 'node:dns';
+import { LookupFunction } from 'node:net';
+import { Fetch, FetchContext } from '@atproto-labs/fetch';
+export type SsrfFetchWrapOptions<C = FetchContext> = {
+    fetch?: Fetch<C>;
+};
+/**
+ * @see {@link https://owasp.org/Top10/A10_2021-Server-Side_Request_Forgery_%28SSRF%29/}
+ */
+export declare function unicastFetchWrap<C = FetchContext>({ fetch, }: SsrfFetchWrapOptions<C>): Fetch<C>;
+export declare function unicastLookup(hostname: string, options: dns.LookupOptions, callback: Parameters<LookupFunction>[2]): void;
+//# sourceMappingURL=unicast.d.ts.map

package/dist/unicast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicast.d.ts","sourceRoot":"","sources":["../src/unicast.ts"],"names":[],"mappings":";;AAAA,OAAO,GAAsB,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC,OAAO,EAGL,KAAK,EACL,YAAY,EAEb,MAAM,qBAAqB,CAAA;AAS5B,MAAM,MAAM,oBAAoB,CAAC,CAAC,GAAG,YAAY,IAAI;IACnD,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,YAAY,EAAE,EACjD,KAAwB,GACzB,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CA8HpC;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,GAAG,CAAC,aAAa,EAC1B,QAAQ,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,QA0BxC"}

package/dist/unicast.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unicastLookup = exports.unicastFetchWrap = void 0;
+const node_dns_1 = __importDefault(require("node:dns"));
+const fetch_1 = require("@atproto-labs/fetch");
+const ipaddr_js_1 = __importDefault(require("ipaddr.js"));
+const psl_1 = require("psl");
+const undici_1 = require("undici");
+const util_js_1 = require("./util.js");
+const { IPv4, IPv6 } = ipaddr_js_1.default;
+/**
+ * @see {@link https://owasp.org/Top10/A10_2021-Server-Side_Request_Forgery_%28SSRF%29/}
+ */
+function unicastFetchWrap({ fetch = globalThis.fetch, }) {
+    // In order to enforce the SSRF protection, we need to use a custom dispatcher
+    // that uses "unicastLookup" to resolve the hostname to a unicast IP address.
+    // In case a custom "fetch" function is passed here, we have no assurance that
+    // the dispatcher will be used to make the request. Because of this, in case a
+    // custom fetch method is passed, we will use a on-time use dispatcher that
+    // ensures that "unicastLookup" gets called to resolve the hostname to an IP
+    // address and ensure that it is a unicast address.
+    // Sadly, this means that we cannot use "keepAlive" connections, as the method
+    // used to ensure that "unicastLookup" gets called requires to create a new
+    // dispatcher for each request.
+    // @TODO: find a way to use a re-usable dispatcher with a custom fetch method.
+    if (fetch === globalThis.fetch) {
+        const dispatcher = new undici_1.Agent({
+            allowH2: true,
+            connect: { keepAlive: true, lookup: unicastLookup },
+        });
+        return async function (input, init) {
+            if (init?.dispatcher) {
+                throw new fetch_1.FetchRequestError((0, fetch_1.asRequest)(input, init), 500, 'SSRF protection cannot be used with a custom request dispatcher');
+            }
+            const url = (0, fetch_1.extractUrl)(input);
+            if (url.hostname && (0, util_js_1.isUnicastIp)(url.hostname) === false) {
+                throw new fetch_1.FetchRequestError((0, fetch_1.asRequest)(input, init), 400, 'Hostname is a non-unicast address');
+            }
+            // @ts-expect-error non-standard option
+            return fetch.call(this, input, { ...init, dispatcher });
+        };
+    }
+    else {
+        return async function (input, init) {
+            if (init?.dispatcher) {
+                throw new fetch_1.FetchRequestError((0, fetch_1.asRequest)(input, init), 500, 'SSRF protection cannot be used with a custom request dispatcher');
+            }
+            const url = (0, fetch_1.extractUrl)(input);
+            if (!url.hostname) {
+                return fetch.call(this, input, init);
+            }
+            switch ((0, util_js_1.isUnicastIp)(url.hostname)) {
+                case true: {
+                    // hostname is a unicast address, safe to proceed.
+                    return fetch.call(this, input, init);
+                }
+                case false: {
+                    throw new fetch_1.FetchRequestError((0, fetch_1.asRequest)(input, init), 400, 'Hostname is a non-unicast address');
+                }
+                case undefined: {
+                    // hostname is a domain name, using the dispatcher defined above
+                    // will result in the DNS lookup being performed, ensuring that the
+                    // hostname resolves to a unicast address.
+                    let didLookup = false;
+                    const dispatcher = new undici_1.Client(url.origin, {
+                        allowH2: true,
+                        connect: {
+                            keepAlive: false, // Client will be used once
+                            lookup(...args) {
+                                didLookup = true;
+                                unicastLookup(...args);
+                            },
+                        },
+                    });
+                    const headers = new Headers(init?.headers);
+                    headers.set('connection', 'close'); // Proactively close the connection
+                    try {
+                        return await fetch.call(this, input, {
+                            ...init,
+                            headers,
+                            // @ts-expect-error non-standard option
+                            dispatcher,
+                        });
+                    }
+                    finally {
+                        // Free resources (we cannot await here since the response was not
+                        // consumed yet).
+                        void dispatcher.close().catch((err) => {
+                            // No biggie, but let's still log it
+                            console.warn('Failed to close dispatcher', err);
+                        });
+                        if (!didLookup) {
+                            // If you encounter this error, either upgrade to Node.js >=21 or
+                            // make sure that the dispatcher passed through the requestInit
+                            // object ends up being used to make the request.
+                            // eslint-disable-next-line no-unsafe-finally
+                            throw new fetch_1.FetchRequestError((0, fetch_1.asRequest)(input, init), 500, 'Unable to enforce SSRF protection');
+                        }
+                    }
+                }
+            }
+        };
+    }
+}
+exports.unicastFetchWrap = unicastFetchWrap;
+function unicastLookup(hostname, options, callback) {
+    if (!(0, psl_1.isValid)(hostname)) {
+        callback(new Error('Hostname is not a public domain'), '');
+        return;
+    }
+    node_dns_1.default.lookup(hostname, options, (err, address, family) => {
+        if (err) {
+            callback(err, address, family);
+        }
+        else {
+            const ips = Array.isArray(address)
+                ? address.map(parseLookupAddress)
+                : [parseLookupAddress({ address, family })];
+            if (ips.some(isNotUnicast)) {
+                callback(new Error('Hostname resolved to non-unicast address'), address, family);
+            }
+            else {
+                callback(null, address, family);
+            }
+        }
+    });
+}
+exports.unicastLookup = unicastLookup;
+function isNotUnicast(ip) {
+    return ip.range() !== 'unicast';
+}
+function parseLookupAddress({ address, family, }) {
+    const ip = family === 4 ? IPv4.parse(address) : IPv6.parse(address);
+    if (ip instanceof IPv6 && ip.isIPv4MappedAddress()) {
+        return ip.toIPv4Address();
+    }
+    else {
+        return ip;
+    }
+}
+//# sourceMappingURL=unicast.js.map

package/dist/unicast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicast.js","sourceRoot":"","sources":["../src/unicast.ts"],"names":[],"mappings":"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"}

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare function isUnicastIp(hostname: string): boolean | undefined;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAkBA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAGjE"}

package/dist/util.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnicastIp = void 0;
+const ipaddr_js_1 = __importDefault(require("ipaddr.js"));
+const { IPv4, IPv6 } = ipaddr_js_1.default;
+function parseIpHostname(hostname) {
+    if (IPv4.isIPv4(hostname)) {
+        return IPv4.parse(hostname);
+    }
+    if (hostname.startsWith('[') && hostname.endsWith(']')) {
+        return IPv6.parse(hostname.slice(1, -1));
+    }
+    return undefined;
+}
+function isUnicastIp(hostname) {
+    const ip = parseIpHostname(hostname);
+    return ip ? ip.range() === 'unicast' : undefined;
+}
+exports.isUnicastIp = isUnicastIp;
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA8B;AAE9B,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,mBAAM,CAAA;AAE7B,SAAS,eAAe,CACtB,QAAgB;IAEhB,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC7B,CAAC;IAED,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1C,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAgB,WAAW,CAAC,QAAgB;IAC1C,MAAM,EAAE,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAA;IACpC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAA;AAClD,CAAC;AAHD,kCAGC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto-labs/fetch-node",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "license": "MIT",
   "description": "SSRF protection for fetch() in Node.js",
   "keywords": [
@@ -12,7 +12,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/bluesky-social/atproto",
-    "directory": "packages/fetch-node"
+    "directory": "packages/internal/fetch-node"
   },
   "type": "commonjs",
   "main": "dist/index.js",
@@ -25,11 +25,13 @@
   },
   "dependencies": {
     "ipaddr.js": "^2.1.0",
-    "tslib": "^2.6.2",
-    "@atproto-labs/fetch": "0.0.1",
-    "@atproto-labs/transformer": "0.0.1"
+    "psl": "^1.9.0",
+    "undici": "^6.14.1",
+    "@atproto-labs/fetch": "0.1.1",
+    "@atproto-labs/pipe": "0.1.0"
   },
   "devDependencies": {
+    "@types/psl": "1.1.3",
     "typescript": "^5.3.3"
   },
   "scripts": {

package/src/index.ts

@@ -1,2 +1,5 @@
+export * from '@atproto-labs/fetch'
+
 export * from './safe.js'
-export * from './ssrf.js'
+export * from './unicast.js'
+export * from './util.js'

package/src/safe.ts

@@ -1,15 +1,18 @@
 import {
+  asRequest,
   DEFAULT_FORBIDDEN_DOMAIN_NAMES,
   Fetch,
   fetchMaxSizeProcessor,
   forbiddenDomainNameRequestTransform,
   protocolCheckRequestTransform,
-  requireHostHeaderTranform,
-  timeoutFetchWrap,
+  redirectCheckRequestTransform,
+  requireHostHeaderTransform,
+  timedFetch,
+  toRequestTransformer,
 } from '@atproto-labs/fetch'
-import { compose } from '@atproto-labs/transformer'
+import { pipe } from '@atproto-labs/pipe'
 
-import { ssrfFetchWrap } from './ssrf.js'
+import { unicastFetchWrap } from './unicast.js'
 
 export type SafeFetchWrapOptions = NonNullable<
   Parameters<typeof safeFetchWrap>[0]
@@ -18,57 +21,72 @@ export type SafeFetchWrapOptions = NonNullable<
 /**
  * Wrap a fetch function with safety checks so that it can be safely used
  * with user provided input (URL).
+ *
+ * @see {@link https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html}
  */
-export const safeFetchWrap = ({
+export function safeFetchWrap({
   fetch = globalThis.fetch as Fetch,
   responseMaxSize = 512 * 1024, // 512kB
-  allowHttp = false,
-  allowData = false,
   ssrfProtection = true,
-  timeout = 10e3 as number,
+  allowCustomPort = !ssrfProtection,
+  allowData = false,
+  allowHttp = !ssrfProtection,
+  allowIpHost = true,
+  allowPrivateIps = !ssrfProtection,
+  timeout = 10e3,
   forbiddenDomainNames = DEFAULT_FORBIDDEN_DOMAIN_NAMES as Iterable<string>,
-} = {}): Fetch =>
-  compose(
-    /**
-     * Prevent using http:, file: or data: protocols.
-     */
-    protocolCheckRequestTransform(
-      ['https:']
-        .concat(allowHttp ? ['http:'] : [])
-        .concat(allowData ? ['data:'] : []),
-    ),
+} = {}): Fetch<unknown> {
+  return toRequestTransformer(
+    pipe(
+      /**
+       * Disable HTTP redirects
+       */
+      redirectCheckRequestTransform(),
 
-    /**
-     * Only requests that will be issued with a "Host" header are allowed.
-     */
-    requireHostHeaderTranform(),
+      /**
+       * Only requests that will be issued with a "Host" header are allowed.
+       */
+      allowIpHost ? asRequest : requireHostHeaderTransform(),
 
-    /**
-     * Disallow fetching from domains we know are not atproto/OIDC client
-     * implementation. Note that other domains can be blocked by providing a
-     * custom fetch function combined with another
-     * forbiddenDomainNameRequestTransform.
-     */
-    forbiddenDomainNameRequestTransform(forbiddenDomainNames),
+      /**
+       * Prevent using http:, file: or data: protocols.
+       */
+      protocolCheckRequestTransform({
+        'about:': false,
+        'data:': allowData,
+        'file:': false,
+        'http:': allowHttp && { allowCustomPort },
+        'https:': { allowCustomPort },
+      }),
 
-    /**
-     * Since we will be fetching from the network based on user provided
-     * input, let's mitigate resource exhaustion attacks by setting a timeout.
-     */
-    timeoutFetchWrap({
-      timeout,
+      /**
+       * Disallow fetching from domains we know are not atproto/OIDC client
+       * implementation. Note that other domains can be blocked by providing a
+       * custom fetch function combined with another
+       * forbiddenDomainNameRequestTransform.
+       */
+      forbiddenDomainNameRequestTransform(forbiddenDomainNames),
 
       /**
        * Since we will be fetching from the network based on user provided
-       * input, we need to make sure that the request is not vulnerable to SSRF
-       * attacks.
+       * input, let's mitigate resource exhaustion attacks by setting a timeout.
        */
-      fetch: ssrfProtection ? ssrfFetchWrap({ fetch }) : fetch,
-    }),
+      timedFetch(
+        timeout,
+
+        /**
+         * Since we will be fetching from the network based on user provided
+         * input, we need to make sure that the request is not vulnerable to SSRF
+         * attacks.
+         */
+        allowPrivateIps ? fetch : unicastFetchWrap({ fetch }),
+      ),
 
-    /**
-     * Since we will be fetching user owned data, we need to make sure that an
-     * attacker cannot force us to download a large amounts of data.
-     */
-    fetchMaxSizeProcessor(responseMaxSize),
+      /**
+       * Since we will be fetching user owned data, we need to make sure that an
+       * attacker cannot force us to download a large amounts of data.
+       */
+      fetchMaxSizeProcessor(responseMaxSize),
+    ),
   )
+}

package/src/unicast.ts

@@ -0,0 +1,202 @@
+import dns, { LookupAddress } from 'node:dns'
+import { LookupFunction } from 'node:net'
+
+import {
+  asRequest,
+  extractUrl,
+  Fetch,
+  FetchContext,
+  FetchRequestError,
+} from '@atproto-labs/fetch'
+import ipaddr from 'ipaddr.js'
+import { isValid as isValidDomain } from 'psl'
+import { Agent, Client } from 'undici'
+
+import { isUnicastIp } from './util.js'
+
+const { IPv4, IPv6 } = ipaddr
+
+export type SsrfFetchWrapOptions<C = FetchContext> = {
+  fetch?: Fetch<C>
+}
+
+/**
+ * @see {@link https://owasp.org/Top10/A10_2021-Server-Side_Request_Forgery_%28SSRF%29/}
+ */
+export function unicastFetchWrap<C = FetchContext>({
+  fetch = globalThis.fetch,
+}: SsrfFetchWrapOptions<C>): Fetch<C> {
+  // In order to enforce the SSRF protection, we need to use a custom dispatcher
+  // that uses "unicastLookup" to resolve the hostname to a unicast IP address.
+
+  // In case a custom "fetch" function is passed here, we have no assurance that
+  // the dispatcher will be used to make the request. Because of this, in case a
+  // custom fetch method is passed, we will use a on-time use dispatcher that
+  // ensures that "unicastLookup" gets called to resolve the hostname to an IP
+  // address and ensure that it is a unicast address.
+
+  // Sadly, this means that we cannot use "keepAlive" connections, as the method
+  // used to ensure that "unicastLookup" gets called requires to create a new
+  // dispatcher for each request.
+
+  // @TODO: find a way to use a re-usable dispatcher with a custom fetch method.
+
+  if (fetch === globalThis.fetch) {
+    const dispatcher = new Agent({
+      allowH2: true,
+      connect: { keepAlive: true, lookup: unicastLookup },
+    })
+
+    return async function (input, init): Promise<Response> {
+      if (init?.dispatcher) {
+        throw new FetchRequestError(
+          asRequest(input, init),
+          500,
+          'SSRF protection cannot be used with a custom request dispatcher',
+        )
+      }
+
+      const url = extractUrl(input)
+
+      if (url.hostname && isUnicastIp(url.hostname) === false) {
+        throw new FetchRequestError(
+          asRequest(input, init),
+          400,
+          'Hostname is a non-unicast address',
+        )
+      }
+
+      // @ts-expect-error non-standard option
+      return fetch.call(this, input, { ...init, dispatcher })
+    }
+  } else {
+    return async function (input, init): Promise<Response> {
+      if (init?.dispatcher) {
+        throw new FetchRequestError(
+          asRequest(input, init),
+          500,
+          'SSRF protection cannot be used with a custom request dispatcher',
+        )
+      }
+
+      const url = extractUrl(input)
+
+      if (!url.hostname) {
+        return fetch.call(this, input, init)
+      }
+
+      switch (isUnicastIp(url.hostname)) {
+        case true: {
+          // hostname is a unicast address, safe to proceed.
+          return fetch.call(this, input, init)
+        }
+
+        case false: {
+          throw new FetchRequestError(
+            asRequest(input, init),
+            400,
+            'Hostname is a non-unicast address',
+          )
+        }
+
+        case undefined: {
+          // hostname is a domain name, using the dispatcher defined above
+          // will result in the DNS lookup being performed, ensuring that the
+          // hostname resolves to a unicast address.
+
+          let didLookup = false
+          const dispatcher = new Client(url.origin, {
+            allowH2: true,
+            connect: {
+              keepAlive: false, // Client will be used once
+              lookup(...args) {
+                didLookup = true
+                unicastLookup(...args)
+              },
+            },
+          })
+
+          const headers = new Headers(init?.headers)
+          headers.set('connection', 'close') // Proactively close the connection
+
+          try {
+            return await fetch.call(this, input, {
+              ...init,
+              headers,
+              // @ts-expect-error non-standard option
+              dispatcher,
+            })
+          } finally {
+            // Free resources (we cannot await here since the response was not
+            // consumed yet).
+            void dispatcher.close().catch((err) => {
+              // No biggie, but let's still log it
+              console.warn('Failed to close dispatcher', err)
+            })
+
+            if (!didLookup) {
+              // If you encounter this error, either upgrade to Node.js >=21 or
+              // make sure that the dispatcher passed through the requestInit
+              // object ends up being used to make the request.
+
+              // eslint-disable-next-line no-unsafe-finally
+              throw new FetchRequestError(
+                asRequest(input, init),
+                500,
+                'Unable to enforce SSRF protection',
+              )
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+export function unicastLookup(
+  hostname: string,
+  options: dns.LookupOptions,
+  callback: Parameters<LookupFunction>[2],
+) {
+  if (!isValidDomain(hostname)) {
+    callback(new Error('Hostname is not a public domain'), '')
+    return
+  }
+
+  dns.lookup(hostname, options, (err, address, family) => {
+    if (err) {
+      callback(err, address, family)
+    } else {
+      const ips = Array.isArray(address)
+        ? address.map(parseLookupAddress)
+        : [parseLookupAddress({ address, family })]
+
+      if (ips.some(isNotUnicast)) {
+        callback(
+          new Error('Hostname resolved to non-unicast address'),
+          address,
+          family,
+        )
+      } else {
+        callback(null, address, family)
+      }
+    }
+  })
+}
+
+function isNotUnicast(ip: ipaddr.IPv4 | ipaddr.IPv6): boolean {
+  return ip.range() !== 'unicast'
+}
+
+function parseLookupAddress({
+  address,
+  family,
+}: LookupAddress): ipaddr.IPv4 | ipaddr.IPv6 {
+  const ip = family === 4 ? IPv4.parse(address) : IPv6.parse(address)
+
+  if (ip instanceof IPv6 && ip.isIPv4MappedAddress()) {
+    return ip.toIPv4Address()
+  } else {
+    return ip
+  }
+}

package/src/util.ts

@@ -0,0 +1,22 @@
+import ipaddr from 'ipaddr.js'
+
+const { IPv4, IPv6 } = ipaddr
+
+function parseIpHostname(
+  hostname: string,
+): ipaddr.IPv4 | ipaddr.IPv6 | undefined {
+  if (IPv4.isIPv4(hostname)) {
+    return IPv4.parse(hostname)
+  }
+
+  if (hostname.startsWith('[') && hostname.endsWith(']')) {
+    return IPv6.parse(hostname.slice(1, -1))
+  }
+
+  return undefined
+}
+
+export function isUnicastIp(hostname: string): boolean | undefined {
+  const ip = parseIpHostname(hostname)
+  return ip ? ip.range() === 'unicast' : undefined
+}

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": ["../../../tsconfig/node.json"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -1,8 +1,4 @@
 {
-  "extends": "../../tsconfig/node.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
+  "include": [],
+  "references": [{ "path": "./tsconfig.build.json" }]
 }

package/dist/ssrf.d.ts

@@ -1,6 +0,0 @@
-import { Fetch } from '@atproto-labs/fetch';
-export type SsrfSafeFetchWrapOptions = NonNullable<Parameters<typeof ssrfFetchWrap>[0]>;
-export declare const ssrfFetchWrap: ({ fetch, }?: {
-    fetch?: Fetch | undefined;
-}) => Fetch;
-//# sourceMappingURL=ssrf.d.ts.map

package/dist/ssrf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssrf.d.ts","sourceRoot":"","sources":["../src/ssrf.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAc,MAAM,qBAAqB,CAAA;AAKvD,MAAM,MAAM,wBAAwB,GAAG,WAAW,CAChD,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CACpC,CAAA;AACD,eAAO,MAAM,aAAa;;MAEjB,KA0CR,CAAA"}

package/dist/ssrf.js

@@ -1,91 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ssrfFetchWrap = void 0;
-const node_dns_1 = __importStar(require("node:dns"));
-const fetch_1 = require("@atproto-labs/fetch");
-const ipaddr_js_1 = __importDefault(require("ipaddr.js"));
-const { IPv4, IPv6 } = ipaddr_js_1.default;
-const ssrfFetchWrap = ({ fetch = globalThis.fetch, } = {}) => {
-    const ssrfSafeFetch = async (request) => {
-        const { protocol, hostname } = new URL(request.url);
-        if (protocol === 'http:' || protocol === 'https:') {
-            if (request.redirect === 'follow') {
-                // TODO: actually implement by calling ssrfSafeFetch recursively (?)
-                throw new fetch_1.FetchError(500, 'Request redirect must be "error" or "manual" when SSRF is enabled', { request });
-            }
-            // Make sure the hostname is a unicast IP address
-            const ip = await hostnameLookup(hostname).catch((cause) => {
-                throw cause?.code === 'ENOTFOUND'
-                    ? new fetch_1.FetchError(400, `Invalid hostname ${hostname}`, {
-                        request,
-                        cause,
-                    })
-                    : new fetch_1.FetchError(500, `Unable resolve DNS for ${hostname}`, {
-                        request,
-                        cause,
-                    });
-            });
-            if (ip.range() !== 'unicast') {
-                throw new fetch_1.FetchError(400, `Invalid hostname IP address ${ip}`, {
-                    request,
-                });
-            }
-        }
-        else if (protocol === 'data:') {
-            // No SSRF issue
-        }
-        else {
-            // blob: about: file: all should be rejected
-            throw new fetch_1.FetchError(400, `Forbidden protocol ${protocol}`, { request });
-        }
-        return fetch(request);
-    };
-    return ssrfSafeFetch;
-};
-exports.ssrfFetchWrap = ssrfFetchWrap;
-async function hostnameLookup(hostname) {
-    if (IPv4.isIPv4(hostname)) {
-        return IPv4.parse(hostname);
-    }
-    if (hostname.startsWith('[') && hostname.endsWith(']')) {
-        return IPv6.parse(hostname.slice(1, -1));
-    }
-    return domainLookup(hostname);
-}
-async function domainLookup(domain) {
-    const addr = await node_dns_1.promises.lookup(domain, {
-        hints: node_dns_1.default.ADDRCONFIG | node_dns_1.default.V4MAPPED,
-    });
-    const ip = addr.family === 4 ? IPv4.parse(addr.address) : IPv6.parse(addr.address);
-    if (ip instanceof IPv6 && ip.isIPv4MappedAddress()) {
-        return ip.toIPv4Address();
-    }
-    return ip;
-}
-//# sourceMappingURL=ssrf.js.map

package/dist/ssrf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssrf.js","sourceRoot":"","sources":["../src/ssrf.ts"],"names":[],"mappings":"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"}

package/src/ssrf.ts

@@ -1,86 +0,0 @@
-import dns, { promises as dnsPromises } from 'node:dns'
-
-import { Fetch, FetchError } from '@atproto-labs/fetch'
-import ipaddr from 'ipaddr.js'
-
-const { IPv4, IPv6 } = ipaddr
-
-export type SsrfSafeFetchWrapOptions = NonNullable<
-  Parameters<typeof ssrfFetchWrap>[0]
->
-export const ssrfFetchWrap = ({
-  fetch = globalThis.fetch as Fetch,
-} = {}): Fetch => {
-  const ssrfSafeFetch: Fetch = async (request) => {
-    const { protocol, hostname } = new URL(request.url)
-
-    if (protocol === 'http:' || protocol === 'https:') {
-      if (request.redirect === 'follow') {
-        // TODO: actually implement by calling ssrfSafeFetch recursively (?)
-        throw new FetchError(
-          500,
-          'Request redirect must be "error" or "manual" when SSRF is enabled',
-          { request },
-        )
-      }
-
-      // Make sure the hostname is a unicast IP address
-      const ip = await hostnameLookup(hostname).catch((cause) => {
-        throw cause?.code === 'ENOTFOUND'
-          ? new FetchError(400, `Invalid hostname ${hostname}`, {
-              request,
-              cause,
-            })
-          : new FetchError(500, `Unable resolve DNS for ${hostname}`, {
-              request,
-              cause,
-            })
-      })
-      if (ip.range() !== 'unicast') {
-        throw new FetchError(400, `Invalid hostname IP address ${ip}`, {
-          request,
-        })
-      }
-    } else if (protocol === 'data:') {
-      // No SSRF issue
-    } else {
-      // blob: about: file: all should be rejected
-      throw new FetchError(400, `Forbidden protocol ${protocol}`, { request })
-    }
-
-    return fetch(request)
-  }
-
-  return ssrfSafeFetch
-}
-
-async function hostnameLookup(
-  hostname: string,
-): Promise<ipaddr.IPv4 | ipaddr.IPv6> {
-  if (IPv4.isIPv4(hostname)) {
-    return IPv4.parse(hostname)
-  }
-
-  if (hostname.startsWith('[') && hostname.endsWith(']')) {
-    return IPv6.parse(hostname.slice(1, -1))
-  }
-
-  return domainLookup(hostname)
-}
-
-async function domainLookup(
-  domain: string,
-): Promise<ipaddr.IPv4 | ipaddr.IPv6> {
-  const addr = await dnsPromises.lookup(domain, {
-    hints: dns.ADDRCONFIG | dns.V4MAPPED,
-  })
-
-  const ip =
-    addr.family === 4 ? IPv4.parse(addr.address) : IPv6.parse(addr.address)
-
-  if (ip instanceof IPv6 && ip.isIPv4MappedAddress()) {
-    return ip.toIPv4Address()
-  }
-
-  return ip
-}