Feat/socks

.gitignore

@@ -4,3 +4,23 @@ dist
 node_modules
 coverage
 package-lock.json
+
+# Swap
+[._]*.s[a-v][a-z]
+!*.svg  # comment out if you don't need vector files
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# Session
+Session.vim
+Sessionx.vim
+
+# Temporary
+.netrwhist
+*~
+# Auto-generated tag files
+tags
+# Persistent undo
+[._]*.un~

package.json

@@ -16,6 +16,8 @@
         "mimic-response": "^3.1.0",
         "ow": "^0.28.1",
         "quick-lru": "^5.1.1",
+        "socks": "^2.7.1",
+        "socks-proxy-agent": "^8.0.2",
         "tslib": "^2.4.0"
     },
     "devDependencies": {

src/agent/h1-proxy-agent.ts

@@ -5,12 +5,12 @@
 import http, { ClientRequest, ClientRequestArgs } from 'http';
 import https from 'https';
 
-interface AgentOptions extends http.AgentOptions {
+export interface AgentOptions extends http.AgentOptions {
     proxy: string | URL;
     disableConnect?: boolean;
 }
 
-const initialize = (self: http.Agent & { proxy: URL }, options: AgentOptions) => {
+export const initialize = (self: { proxy: URL }, options: AgentOptions) => {
     self.proxy = typeof options.proxy === 'string' ? new URL(options.proxy) : options.proxy;
 };
 
@@ -138,7 +138,7 @@
                 return;
             }
 
             if ((options as any).protocol === 'https:') {
                 callback(undefined, tls.connect({
                     ...options,
                     socket,

src/agent/socks/http-socks-agent.ts

@@ -0,0 +1,11 @@
+import { SocksProxyAgent } from 'socks-proxy-agent';
+
+export class HttpSocksAgent extends SocksProxyAgent {
+    override get protocol(): string {
+        return 'http:';
+    }
+
+    override set protocol(value: string) {
+        super.protocol = value;
+    }
+}

src/agent/socks/https-socks-agent.ts

@@ -0,0 +1,11 @@
+import { SocksProxyAgent } from 'socks-proxy-agent';
+
+export class HttpsSocksAgent extends SocksProxyAgent {
+    override get protocol(): string {
+        return 'https:';
+    }
+
+    override set protocol(value: string) {
+        super.protocol = value;
+    }
+}

src/agent/socks/socks-http2-agent.ts

@@ -0,0 +1,46 @@
+import http2, { Agent } from 'http2-wrapper';
+import tls from 'tls';
+import { URL } from 'url';
+
+import { SocksClient } from 'socks';
+
+export class SocksHttp2Agent extends Agent {
+    proxy: URL;
+
+    constructor(options: {
+        proxyOptions: {
+            url: URL,
+            rejectUnauthorized: boolean
+        },
+        maxFreeSockets: number,
+        maxEmptySessions: number,
+    }) {
+        super(options);
+        this.proxy = options.proxyOptions.url;
+    }
+
+    override async createConnection(origin: URL, options: http2.SecureClientSessionOptions): Promise<tls.TLSSocket> {
+        const port = Number(origin.port) || 443;
+        const host = origin.hostname;
+        const { socket } = await SocksClient.createConnection({
+            proxy: {
+                host: this.proxy.hostname,
+                port: parseInt(this.proxy.port, 10),
+                password: decodeURIComponent(this.proxy.password),
+                // determine type 4 or 5 based on protocol, may be different like socks4, socks5, socks5h, socks
+                type: this.proxy.protocol.includes('4') ? 4 : 5,
+            },
+            command: 'connect',
+            destination: {
+                host,
+                port,
+            },
+            existing_socket: options.socket,
+            timeout: options.timeout,
+        });
+        return super.createConnection(origin, {
+            ...options,
+            socket,
+        });
+    }
+}

src/hooks/fix-decompress.ts

@@ -12,7 +12,6 @@
         flush: zlib.constants.Z_SYNC_FLUSH,
         finishFlush: zlib.constants.Z_SYNC_FLUSH,
     };
-
     const useDecompressor = (decompressor: Transform) => {
         delete response.headers['content-encoding'];
 
@@ -71,8 +70,8 @@
     // @ts-expect-error Looks like a TypeScript bug
     result.on('request', (request: ClientRequest) => {
         const emit = request.emit.bind(request);
-
         request.emit = (event: string, ...args: unknown[]) => {
+
             // It won't double decompress, because Got checks the content-encoding header.
             // We delete it if the response is compressed.
             if (event === 'response' && options.decompress) {
@@ -86,7 +85,6 @@
 
                 return emitted;
             }
-
             return emit(event, ...args);
         };
     });

src/hooks/http2.ts

@@ -13,7 +13,6 @@ export function http2Hook(options: Options): void {
             if (proxyUrl) {
                 typedRequestOptions.resolveProtocol = createResolveProtocol(proxyUrl, sessionData as any);
             }
-
             return auto(url, typedRequestOptions, callback);
         };
     } else {

src/hooks/proxy.ts

@@ -3,6 +3,9 @@ import { proxies, auto } from 'http2-wrapper';
 import { Agents, Options } from 'got-cjs';
 import { HttpsProxyAgent, HttpRegularProxyAgent } from '../agent/h1-proxy-agent';
 import { TransformHeadersAgent } from '../agent/transform-headers-agent';
+import { SocksHttp2Agent } from '../agent/socks/socks-http2-agent';
+import { HttpSocksAgent } from '../agent/socks/http-socks-agent';
+import { HttpsSocksAgent } from '../agent/socks/https-socks-agent';
 
 const {
     HttpOverHttp2,
@@ -25,10 +28,10 @@ export async function proxyHook(options: Options): Promise<void> {
 }
 
 function validateProxyProtocol(protocol: string) {
-    const isSupported = protocol === 'http:' || protocol === 'https:';
+    const isSupported = protocol === 'http:' || protocol === 'https:' || protocol.startsWith('socks');
 
     if (!isSupported) {
-        throw new Error(`Proxy URL protocol "${protocol}" is not supported. Please use HTTP or HTTPS.`);
+        throw new Error(`Proxy URL protocol "${protocol}" is not supported. Please use HTTP, HTTPS or SOCKS family.`);
     }
 }
 
@@ -92,13 +95,23 @@ async function getAgents(parsedProxyUrl: URL, rejectUnauthorized: boolean) {
                 http2: new Http2OverHttps(wrapperOptions),
             };
         }
-    } else {
+    } else if (parsedProxyUrl.protocol === 'http:') {
         // Upstream proxies hang up connections on CONNECT + unsecure HTTP
         agent = {
             http: new TransformHeadersAgent(new HttpRegularProxyAgent(nativeOptions)),
             https: new TransformHeadersAgent(new HttpsProxyAgent(nativeOptions)),
             http2: new Http2OverHttp(wrapperOptions),
         };
+    } else {
+        agent = {
+            http: new TransformHeadersAgent(new HttpSocksAgent(nativeOptions.proxy, {
+                maxFreeSockets: nativeOptions.maxFreeSockets,
+            })),
+            https: new TransformHeadersAgent(new HttpsSocksAgent(nativeOptions.proxy, {
+                maxFreeSockets: nativeOptions.maxFreeSockets,
+            })),
+            http2: new SocksHttp2Agent(wrapperOptions),
+        };
     }
 
     return agent;

src/resolve-protocol.ts

@@ -4,8 +4,32 @@ import { URL } from 'url';
 import { Headers } from 'got-cjs';
 import { auto, ResolveProtocolConnectFunction, ResolveProtocolFunction } from 'http2-wrapper';
 import QuickLRU from 'quick-lru';
+import { SocksClient } from 'socks';
+
+const connectSocks = async (proxyUrl: string, options: tls.ConnectionOptions, callback: () => void) => {
+    const url = new URL(proxyUrl);
+    const { socket } = await SocksClient.createConnection({
+        proxy: {
+            host: url.hostname,
+            port: parseInt(url.port, 10),
+            password: decodeURIComponent(url.password),
+            type: url.protocol.includes('4') ? 4 : 5,
+        },
+        command: 'connect',
+        destination: {
+            host: options.host!,
+            port: options.port!,
+        },
+        existing_socket: options.socket,
+        timeout: options.timeout,
+    });
+    return tls.connect({
+        ...options,
+        socket,
+    }, callback);
+};
 
-const connect = async (proxyUrl: string, options: tls.ConnectionOptions, callback: () => void) => new Promise<TLSSocket>((resolve, reject) => {
+const connectHttp = async (proxyUrl: string, options: tls.ConnectionOptions, callback: () => void) => new Promise<TLSSocket>((resolve, reject) => {
     let host = `${options.host}:${options.port}`;
 
     if (isIPv6(options.host!)) {
@@ -85,7 +109,7 @@ export const createResolveProtocol = (proxyUrl: string, sessionData?: ProtocolCa
     }
 
     const connectWithProxy: ResolveProtocolConnectFunction = async (pOptions, pCallback) => {
-        return connect(proxyUrl, pOptions, pCallback);
+        return (proxyUrl.startsWith('http') ? connectHttp : connectSocks)(proxyUrl, pOptions, pCallback);
     };
 
     return auto.createResolveProtocol(

test/proxy.test.ts

@@ -1,5 +1,6 @@
 import { URL } from 'url';
 import http2 from 'http2-wrapper';
+import { SocksProxyAgent } from 'socks-proxy-agent';
 import {
     HttpsProxyAgent,
     HttpRegularProxyAgent,
@@ -51,7 +52,7 @@ describe('Proxy', () => {
 
         await expect(proxyHook(options))
             .rejects
-            .toThrow(/is not supported. Please use HTTP or HTTPS./);
+            .toThrow(/is not supported/);
     });
 
     describe('agents', () => {
@@ -160,5 +161,38 @@ describe('Proxy', () => {
             const { agent } = options;
             expect(agent.http2).toBeInstanceOf(Http2OverHttp2);
         });
+
+        test('should support http request over socks proxy', async () => {
+            options.context.proxyUrl = 'socks://localhost:8080';
+            jest.spyOn(http2.auto, 'resolveProtocol').mockResolvedValue({ alpnProtocol: 'http/1.1' });
+
+            await proxyHook(options);
+
+            const { agent } = options;
+            expect(agent.http).toBeInstanceOf(TransformHeadersAgent);
+            expect((agent.http as any).agent).toBeInstanceOf(SocksProxyAgent);
+        });
+
+        test('should support https request over socks proxy', async () => {
+            options.context.proxyUrl = 'socks://localhost:8080';
+            jest.spyOn(http2.auto, 'resolveProtocol').mockResolvedValue({ alpnProtocol: 'http/1.1' });
+
+            await proxyHook(options);
+
+            const { agent } = options;
+            expect(agent.http).toBeInstanceOf(TransformHeadersAgent);
+            expect((agent.http as any).agent).toBeInstanceOf(SocksProxyAgent);
+        });
+
+        test('should support http2 request over socks proxy', async () => {
+            options.context.proxyUrl = 'socks://localhost:8080';
+            jest.spyOn(http2.auto, 'resolveProtocol').mockResolvedValue({ alpnProtocol: 'h2' });
+
+            await proxyHook(options);
+
+            const { agent } = options;
+            expect(agent.http).toBeInstanceOf(TransformHeadersAgent);
+            expect((agent.http as any).agent).toBeInstanceOf(SocksProxyAgent);
+        });
     });
 });