@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/forwarding/handlers/https-passthrough-handler.js

@@ -0,0 +1,162 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+/**
+ * Handler for HTTPS passthrough (SNI forwarding without termination)
+ */
+export class HttpsPassthroughHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTPS passthrough handler
+     * @param config The forwarding configuration
+     */
+    constructor(config) {
+        super(config);
+        // Validate that this is an HTTPS passthrough configuration
+        if (config.type !== 'https-passthrough') {
+            throw new Error(`Invalid configuration type for HttpsPassthroughHandler: ${config.type}`);
+        }
+    }
+    /**
+     * Initialize the handler
+     * HTTPS passthrough handler doesn't need special initialization
+     */
+    async initialize() {
+        // Basic initialization from parent class
+        await super.initialize();
+    }
+    /**
+     * Handle a TLS/SSL socket connection by forwarding it without termination
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket) {
+        // Get the target from configuration
+        const target = this.getTargetFromConfig();
+        // Log the connection
+        const remoteAddress = clientSocket.remoteAddress || 'unknown';
+        const remotePort = clientSocket.remotePort || 0;
+        this.emit(ForwardingHandlerEvents.CONNECTED, {
+            remoteAddress,
+            remotePort,
+            target: `${target.host}:${target.port}`
+        });
+        // Create a connection to the target server
+        const serverSocket = plugins.net.connect(target.port, target.host);
+        // Handle errors on the server socket
+        serverSocket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: `Target connection error: ${error.message}`
+            });
+            // Close the client socket if it's still open
+            if (!clientSocket.destroyed) {
+                clientSocket.destroy();
+            }
+        });
+        // Handle errors on the client socket
+        clientSocket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: `Client connection error: ${error.message}`
+            });
+            // Close the server socket if it's still open
+            if (!serverSocket.destroyed) {
+                serverSocket.destroy();
+            }
+        });
+        // Track data transfer for logging
+        let bytesSent = 0;
+        let bytesReceived = 0;
+        // Forward data from client to server
+        clientSocket.on('data', (data) => {
+            bytesSent += data.length;
+            // Check if server socket is writable
+            if (serverSocket.writable) {
+                const flushed = serverSocket.write(data);
+                // Handle backpressure
+                if (!flushed) {
+                    clientSocket.pause();
+                    serverSocket.once('drain', () => {
+                        clientSocket.resume();
+                    });
+                }
+            }
+            this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
+                direction: 'outbound',
+                bytes: data.length,
+                total: bytesSent
+            });
+        });
+        // Forward data from server to client
+        serverSocket.on('data', (data) => {
+            bytesReceived += data.length;
+            // Check if client socket is writable
+            if (clientSocket.writable) {
+                const flushed = clientSocket.write(data);
+                // Handle backpressure
+                if (!flushed) {
+                    serverSocket.pause();
+                    clientSocket.once('drain', () => {
+                        serverSocket.resume();
+                    });
+                }
+            }
+            this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
+                direction: 'inbound',
+                bytes: data.length,
+                total: bytesReceived
+            });
+        });
+        // Handle connection close
+        const handleClose = () => {
+            if (!clientSocket.destroyed) {
+                clientSocket.destroy();
+            }
+            if (!serverSocket.destroyed) {
+                serverSocket.destroy();
+            }
+            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+                remoteAddress,
+                bytesSent,
+                bytesReceived
+            });
+        };
+        // Set up close handlers
+        clientSocket.on('close', handleClose);
+        serverSocket.on('close', handleClose);
+        // Set timeouts
+        const timeout = this.getTimeout();
+        clientSocket.setTimeout(timeout);
+        serverSocket.setTimeout(timeout);
+        // Handle timeouts
+        clientSocket.on('timeout', () => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: 'Client connection timeout'
+            });
+            handleClose();
+        });
+        serverSocket.on('timeout', () => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: 'Server connection timeout'
+            });
+            handleClose();
+        });
+    }
+    /**
+     * Handle an HTTP request - HTTPS passthrough doesn't support HTTP
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req, res) {
+        // HTTPS passthrough doesn't support HTTP requests
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('HTTP not supported for this domain');
+        this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
+            statusCode: 404,
+            headers: { 'Content-Type': 'text/plain' },
+            size: 'HTTP not supported for this domain'.length
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/forwarding/handlers/https-terminate-to-http-handler.d.ts

@@ -0,0 +1,36 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import type { IForwardConfig } from '../config/forwarding-types.js';
+/**
+ * Handler for HTTPS termination with HTTP backend
+ */
+export declare class HttpsTerminateToHttpHandler extends ForwardingHandler {
+    private tlsServer;
+    private secureContext;
+    /**
+     * Create a new HTTPS termination with HTTP backend handler
+     * @param config The forwarding configuration
+     */
+    constructor(config: IForwardConfig);
+    /**
+     * Initialize the handler, setting up TLS context
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set the secure context for TLS termination
+     * Called when a certificate is available
+     * @param context The secure context
+     */
+    setSecureContext(context: plugins.tls.SecureContext): void;
+    /**
+     * Handle a TLS/SSL socket connection by terminating TLS and forwarding to HTTP backend
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket: plugins.net.Socket): void;
+    /**
+     * Handle an HTTP request by forwarding to the HTTP backend
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+}

package/dist_ts/forwarding/handlers/https-terminate-to-http-handler.js

@@ -0,0 +1,229 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+/**
+ * Handler for HTTPS termination with HTTP backend
+ */
+export class HttpsTerminateToHttpHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTPS termination with HTTP backend handler
+     * @param config The forwarding configuration
+     */
+    constructor(config) {
+        super(config);
+        this.tlsServer = null;
+        this.secureContext = null;
+        // Validate that this is an HTTPS terminate to HTTP configuration
+        if (config.type !== 'https-terminate-to-http') {
+            throw new Error(`Invalid configuration type for HttpsTerminateToHttpHandler: ${config.type}`);
+        }
+    }
+    /**
+     * Initialize the handler, setting up TLS context
+     */
+    async initialize() {
+        // We need to load or create TLS certificates
+        if (this.config.https?.customCert) {
+            // Use custom certificate from configuration
+            this.secureContext = plugins.tls.createSecureContext({
+                key: this.config.https.customCert.key,
+                cert: this.config.https.customCert.cert
+            });
+            this.emit(ForwardingHandlerEvents.CERTIFICATE_LOADED, {
+                source: 'config',
+                domain: this.config.target.host
+            });
+        }
+        else if (this.config.acme?.enabled) {
+            // Request certificate through ACME if needed
+            this.emit(ForwardingHandlerEvents.CERTIFICATE_NEEDED, {
+                domain: Array.isArray(this.config.target.host)
+                    ? this.config.target.host[0]
+                    : this.config.target.host,
+                useProduction: this.config.acme.production || false
+            });
+            // In a real implementation, we would wait for the certificate to be issued
+            // For now, we'll use a dummy context
+            this.secureContext = plugins.tls.createSecureContext({
+                key: '-----BEGIN PRIVATE KEY-----\nDummy key\n-----END PRIVATE KEY-----',
+                cert: '-----BEGIN CERTIFICATE-----\nDummy cert\n-----END CERTIFICATE-----'
+            });
+        }
+        else {
+            throw new Error('HTTPS termination requires either a custom certificate or ACME enabled');
+        }
+    }
+    /**
+     * Set the secure context for TLS termination
+     * Called when a certificate is available
+     * @param context The secure context
+     */
+    setSecureContext(context) {
+        this.secureContext = context;
+    }
+    /**
+     * Handle a TLS/SSL socket connection by terminating TLS and forwarding to HTTP backend
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket) {
+        // Make sure we have a secure context
+        if (!this.secureContext) {
+            clientSocket.destroy(new Error('TLS secure context not initialized'));
+            return;
+        }
+        const remoteAddress = clientSocket.remoteAddress || 'unknown';
+        const remotePort = clientSocket.remotePort || 0;
+        // Create a TLS socket using our secure context
+        const tlsSocket = new plugins.tls.TLSSocket(clientSocket, {
+            secureContext: this.secureContext,
+            isServer: true,
+            server: this.tlsServer || undefined
+        });
+        this.emit(ForwardingHandlerEvents.CONNECTED, {
+            remoteAddress,
+            remotePort,
+            tls: true
+        });
+        // Handle TLS errors
+        tlsSocket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: `TLS error: ${error.message}`
+            });
+            if (!tlsSocket.destroyed) {
+                tlsSocket.destroy();
+            }
+        });
+        // The TLS socket will now emit HTTP traffic that can be processed
+        // In a real implementation, we would create an HTTP parser and handle
+        // the requests here, but for simplicity, we'll just log the data
+        let dataBuffer = Buffer.alloc(0);
+        tlsSocket.on('data', (data) => {
+            // Append to buffer
+            dataBuffer = Buffer.concat([dataBuffer, data]);
+            // Very basic HTTP parsing - in a real implementation, use http-parser
+            if (dataBuffer.includes(Buffer.from('\r\n\r\n'))) {
+                const target = this.getTargetFromConfig();
+                // Simple example: forward the data to an HTTP server
+                const socket = plugins.net.connect(target.port, target.host, () => {
+                    socket.write(dataBuffer);
+                    dataBuffer = Buffer.alloc(0);
+                    // Set up bidirectional data flow
+                    tlsSocket.pipe(socket);
+                    socket.pipe(tlsSocket);
+                });
+                socket.on('error', (error) => {
+                    this.emit(ForwardingHandlerEvents.ERROR, {
+                        remoteAddress,
+                        error: `Target connection error: ${error.message}`
+                    });
+                    if (!tlsSocket.destroyed) {
+                        tlsSocket.destroy();
+                    }
+                });
+            }
+        });
+        // Handle close
+        tlsSocket.on('close', () => {
+            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+                remoteAddress
+            });
+        });
+        // Set timeout
+        const timeout = this.getTimeout();
+        tlsSocket.setTimeout(timeout);
+        tlsSocket.on('timeout', () => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: 'TLS connection timeout'
+            });
+            if (!tlsSocket.destroyed) {
+                tlsSocket.destroy();
+            }
+        });
+    }
+    /**
+     * Handle an HTTP request by forwarding to the HTTP backend
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req, res) {
+        // Check if we should redirect to HTTPS
+        if (this.config.http?.redirectToHttps) {
+            this.redirectToHttps(req, res);
+            return;
+        }
+        // Get the target from configuration
+        const target = this.getTargetFromConfig();
+        // Create custom headers with variable substitution
+        const variables = {
+            clientIp: req.socket.remoteAddress || 'unknown'
+        };
+        // Prepare headers, merging with any custom headers from config
+        const headers = this.applyCustomHeaders(req.headers, variables);
+        // Create the proxy request options
+        const options = {
+            hostname: target.host,
+            port: target.port,
+            path: req.url,
+            method: req.method,
+            headers
+        };
+        // Create the proxy request
+        const proxyReq = plugins.http.request(options, (proxyRes) => {
+            // Copy status code and headers from the proxied response
+            res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+            // Pipe the proxy response to the client response
+            proxyRes.pipe(res);
+            // Track response size for logging
+            let responseSize = 0;
+            proxyRes.on('data', (chunk) => {
+                responseSize += chunk.length;
+            });
+            proxyRes.on('end', () => {
+                this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
+                    statusCode: proxyRes.statusCode,
+                    headers: proxyRes.headers,
+                    size: responseSize
+                });
+            });
+        });
+        // Handle errors in the proxy request
+        proxyReq.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress: req.socket.remoteAddress,
+                error: `Proxy request error: ${error.message}`
+            });
+            // Send an error response if headers haven't been sent yet
+            if (!res.headersSent) {
+                res.writeHead(502, { 'Content-Type': 'text/plain' });
+                res.end(`Error forwarding request: ${error.message}`);
+            }
+            else {
+                // Just end the response if headers have already been sent
+                res.end();
+            }
+        });
+        // Track request details for logging
+        let requestSize = 0;
+        req.on('data', (chunk) => {
+            requestSize += chunk.length;
+        });
+        // Log the request
+        this.emit(ForwardingHandlerEvents.HTTP_REQUEST, {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            remoteAddress: req.socket.remoteAddress,
+            target: `${target.host}:${target.port}`
+        });
+        // Pipe the client request to the proxy request
+        if (req.readable) {
+            req.pipe(proxyReq);
+        }
+        else {
+            proxyReq.end();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"https-terminate-to-http-handler.js","sourceRoot":"","sources":["../../../ts/forwarding/handlers/https-terminate-to-http-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/forwarding/handlers/https-terminate-to-https-handler.d.ts

@@ -0,0 +1,35 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import type { IForwardConfig } from '../config/forwarding-types.js';
+/**
+ * Handler for HTTPS termination with HTTPS backend
+ */
+export declare class HttpsTerminateToHttpsHandler extends ForwardingHandler {
+    private secureContext;
+    /**
+     * Create a new HTTPS termination with HTTPS backend handler
+     * @param config The forwarding configuration
+     */
+    constructor(config: IForwardConfig);
+    /**
+     * Initialize the handler, setting up TLS context
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set the secure context for TLS termination
+     * Called when a certificate is available
+     * @param context The secure context
+     */
+    setSecureContext(context: plugins.tls.SecureContext): void;
+    /**
+     * Handle a TLS/SSL socket connection by terminating TLS and creating a new TLS connection to backend
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket: plugins.net.Socket): void;
+    /**
+     * Handle an HTTP request by forwarding to the HTTPS backend
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+}