@push.rocks/smartproxy 3.11.0 → 3.13.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '3.11.0',
-    description: 'a proxy for handling high workloads of proxying'
+    version: '3.13.0',
+    description: 'A robust and versatile proxy package designed to handle high workloads, offering features like SSL redirection, port proxying, WebSocket support, and customizable routing and authentication.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLGlEQUFpRDtDQUMvRCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLGdNQUFnTTtDQUM5TSxDQUFBIn0=

package/dist_ts/classes.iptablesproxy.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Settings for IPTablesProxy.
+ */
+export interface IIpTableProxySettings {
+    fromPort: number;
+    toPort: number;
+    toHost?: string;
+    preserveSourceIP?: boolean;
+    deleteOnExit?: boolean;
+}
+/**
+ * IPTablesProxy sets up iptables NAT rules to forward TCP traffic.
+ * It only supports basic port forwarding and uses iptables comments to tag rules.
+ */
+export declare class IPTablesProxy {
+    settings: IIpTableProxySettings;
+    private rulesInstalled;
+    private ruleTag;
+    constructor(settings: IIpTableProxySettings);
+    /**
+     * Sets up iptables rules for port forwarding.
+     * The rules are tagged with a unique comment so that they can be identified later.
+     */
+    start(): Promise<void>;
+    /**
+     * Removes the iptables rules that were added in start(), by matching the unique comment.
+     */
+    stop(): Promise<void>;
+    /**
+     * Asynchronously cleans up any iptables rules in the nat table that were added by this module.
+     * It looks for rules with comments containing "IPTablesProxy:".
+     */
+    static cleanSlate(): Promise<void>;
+    /**
+     * Synchronously cleans up any iptables rules in the nat table that were added by this module.
+     * It looks for rules with comments containing "IPTablesProxy:".
+     * This method is intended for use in process exit handlers.
+     */
+    static cleanSlateSync(): void;
+}

package/dist_ts/classes.iptablesproxy.js

@@ -0,0 +1,170 @@
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * IPTablesProxy sets up iptables NAT rules to forward TCP traffic.
+ * It only supports basic port forwarding and uses iptables comments to tag rules.
+ */
+export class IPTablesProxy {
+    constructor(settings) {
+        this.rulesInstalled = false;
+        this.settings = {
+            ...settings,
+            toHost: settings.toHost || 'localhost',
+        };
+        // Generate a unique identifier for the rules added by this instance.
+        this.ruleTag = `IPTablesProxy:${Date.now()}:${Math.random().toString(36).substr(2, 5)}`;
+        // If deleteOnExit is true, register cleanup handlers.
+        if (this.settings.deleteOnExit) {
+            const cleanup = () => {
+                try {
+                    IPTablesProxy.cleanSlateSync();
+                }
+                catch (err) {
+                    console.error('Error cleaning iptables rules on exit:', err);
+                }
+            };
+            process.on('exit', cleanup);
+            process.on('SIGINT', () => {
+                cleanup();
+                process.exit();
+            });
+            process.on('SIGTERM', () => {
+                cleanup();
+                process.exit();
+            });
+        }
+    }
+    /**
+     * Sets up iptables rules for port forwarding.
+     * The rules are tagged with a unique comment so that they can be identified later.
+     */
+    async start() {
+        const dnatCmd = `iptables -t nat -A PREROUTING -p tcp --dport ${this.settings.fromPort} ` +
+            `-j DNAT --to-destination ${this.settings.toHost}:${this.settings.toPort} ` +
+            `-m comment --comment "${this.ruleTag}:DNAT"`;
+        try {
+            await execAsync(dnatCmd);
+            console.log(`Added iptables rule: ${dnatCmd}`);
+            this.rulesInstalled = true;
+        }
+        catch (err) {
+            console.error(`Failed to add iptables DNAT rule: ${err}`);
+            throw err;
+        }
+        // If preserveSourceIP is false, add a MASQUERADE rule.
+        if (!this.settings.preserveSourceIP) {
+            const masqueradeCmd = `iptables -t nat -A POSTROUTING -p tcp -d ${this.settings.toHost} ` +
+                `--dport ${this.settings.toPort} -j MASQUERADE ` +
+                `-m comment --comment "${this.ruleTag}:MASQ"`;
+            try {
+                await execAsync(masqueradeCmd);
+                console.log(`Added iptables rule: ${masqueradeCmd}`);
+            }
+            catch (err) {
+                console.error(`Failed to add iptables MASQUERADE rule: ${err}`);
+                // Roll back the DNAT rule if MASQUERADE fails.
+                try {
+                    const rollbackCmd = `iptables -t nat -D PREROUTING -p tcp --dport ${this.settings.fromPort} ` +
+                        `-j DNAT --to-destination ${this.settings.toHost}:${this.settings.toPort} ` +
+                        `-m comment --comment "${this.ruleTag}:DNAT"`;
+                    await execAsync(rollbackCmd);
+                    this.rulesInstalled = false;
+                }
+                catch (rollbackErr) {
+                    console.error(`Rollback failed: ${rollbackErr}`);
+                }
+                throw err;
+            }
+        }
+    }
+    /**
+     * Removes the iptables rules that were added in start(), by matching the unique comment.
+     */
+    async stop() {
+        if (!this.rulesInstalled)
+            return;
+        const dnatDelCmd = `iptables -t nat -D PREROUTING -p tcp --dport ${this.settings.fromPort} ` +
+            `-j DNAT --to-destination ${this.settings.toHost}:${this.settings.toPort} ` +
+            `-m comment --comment "${this.ruleTag}:DNAT"`;
+        try {
+            await execAsync(dnatDelCmd);
+            console.log(`Removed iptables rule: ${dnatDelCmd}`);
+        }
+        catch (err) {
+            console.error(`Failed to remove iptables DNAT rule: ${err}`);
+        }
+        if (!this.settings.preserveSourceIP) {
+            const masqueradeDelCmd = `iptables -t nat -D POSTROUTING -p tcp -d ${this.settings.toHost} ` +
+                `--dport ${this.settings.toPort} -j MASQUERADE ` +
+                `-m comment --comment "${this.ruleTag}:MASQ"`;
+            try {
+                await execAsync(masqueradeDelCmd);
+                console.log(`Removed iptables rule: ${masqueradeDelCmd}`);
+            }
+            catch (err) {
+                console.error(`Failed to remove iptables MASQUERADE rule: ${err}`);
+            }
+        }
+        this.rulesInstalled = false;
+    }
+    /**
+     * Asynchronously cleans up any iptables rules in the nat table that were added by this module.
+     * It looks for rules with comments containing "IPTablesProxy:".
+     */
+    static async cleanSlate() {
+        try {
+            const { stdout } = await execAsync('iptables-save -t nat');
+            const lines = stdout.split('\n');
+            const proxyLines = lines.filter(line => line.includes('IPTablesProxy:'));
+            for (const line of proxyLines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('-A')) {
+                    // Replace the "-A" with "-D" to form a deletion command.
+                    const deleteRule = trimmedLine.replace('-A', '-D');
+                    const cmd = `iptables -t nat ${deleteRule}`;
+                    try {
+                        await execAsync(cmd);
+                        console.log(`Cleaned up iptables rule: ${cmd}`);
+                    }
+                    catch (err) {
+                        console.error(`Failed to remove iptables rule: ${cmd}`, err);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Failed to run iptables-save: ${err}`);
+        }
+    }
+    /**
+     * Synchronously cleans up any iptables rules in the nat table that were added by this module.
+     * It looks for rules with comments containing "IPTablesProxy:".
+     * This method is intended for use in process exit handlers.
+     */
+    static cleanSlateSync() {
+        try {
+            const stdout = execSync('iptables-save -t nat').toString();
+            const lines = stdout.split('\n');
+            const proxyLines = lines.filter(line => line.includes('IPTablesProxy:'));
+            for (const line of proxyLines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('-A')) {
+                    const deleteRule = trimmedLine.replace('-A', '-D');
+                    const cmd = `iptables -t nat ${deleteRule}`;
+                    try {
+                        execSync(cmd);
+                        console.log(`Cleaned up iptables rule: ${cmd}`);
+                    }
+                    catch (err) {
+                        console.error(`Failed to remove iptables rule: ${cmd}`, err);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Failed to run iptables-save: ${err}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.portproxy.d.ts

@@ -4,7 +4,7 @@ export interface IDomainConfig {
     allowedIPs: string[];
     targetIP?: string;
 }
-export interface IProxySettings extends plugins.tls.TlsOptions {
+export interface IPortProxySettings extends plugins.tls.TlsOptions {
     fromPort: number;
     toPort: number;
     toHost?: string;
@@ -15,11 +15,11 @@ export interface IProxySettings extends plugins.tls.TlsOptions {
 }
 export declare class PortProxy {
     netServer: plugins.net.Server;
-    settings: IProxySettings;
+    settings: IPortProxySettings;
     private connectionRecords;
     private connectionLogger;
     private terminationStats;
-    constructor(settings: IProxySettings);
+    constructor(settings: IPortProxySettings);
     private incrementTerminationStat;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist_ts/classes.portproxy.js

@@ -292,4 +292,4 @@ export class PortProxy {
         await done.promise;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.portproxy.js","sourceRoot":"","sources":["../ts/classes.portproxy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.portproxy.js","sourceRoot":"","sources":["../ts/classes.portproxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -1,3 +1,4 @@
+export * from './classes.iptablesproxy.js';
 export * from './classes.networkproxy.js';
 export * from './classes.portproxy.js';
 export * from './classes.port80handler.js';

package/dist_ts/index.js

@@ -1,5 +1,6 @@
+export * from './classes.iptablesproxy.js';
 export * from './classes.networkproxy.js';
 export * from './classes.portproxy.js';
 export * from './classes.port80handler.js';
 export * from './classes.sslredirect.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDBCQUEwQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMEJBQTBCLENBQUMifQ==

package/npmextra.json

@@ -5,7 +5,7 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartproxy",
-      "description": "a proxy for handling high workloads of proxying",
+      "description": "A robust and versatile proxy package designed to handle high workloads, offering features like SSL redirection, port proxying, WebSocket support, and customizable routing and authentication.",
       "npmPackagename": "@push.rocks/smartproxy",
       "license": "MIT",
       "projectDomain": "push.rocks",
@@ -20,7 +20,11 @@
         "ssl redirect",
         "port mapping",
         "reverse proxy",
-        "authentication"
+        "authentication",
+        "dynamic routing",
+        "sni",
+        "port forwarding",
+        "real-time applications"
       ]
     }
   },

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "private": false,
-  "description": "a proxy for handling high workloads of proxying",
+  "description": "A robust and versatile proxy package designed to handle high workloads, offering features like SSL redirection, port proxying, WebSocket support, and customizable routing and authentication.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -56,7 +56,11 @@
     "ssl redirect",
     "port mapping",
     "reverse proxy",
-    "authentication"
+    "authentication",
+    "dynamic routing",
+    "sni",
+    "port forwarding",
+    "real-time applications"
   ],
   "homepage": "https://code.foss.global/push.rocks/smartproxy#readme",
   "repository": {

package/readme.md

@@ -14,11 +14,11 @@ This will add `@push.rocks/smartproxy` to your project's dependencies.
 
 ## Usage
 
-`@push.rocks/smartproxy` is a versatile package for setting up and handling proxies with various capabilities such as SSL redirection, port proxying, and creating network proxies with complex routing rules. Below is a comprehensive guide on using its features.
+`@push.rocks/smartproxy` is a comprehensive and versatile package designed to handle complex and high-volume proxying tasks efficiently. It includes features such as SSL redirection, port proxying, WebSocket support, and customizable routing and authentication mechanisms. This guide will provide a detailed walkthrough of how to harness these capabilities effectively. 
 
-### Setting Up a Network Proxy
+### Initial Setup
 
-Create a network proxy to route incoming HTTPS requests to different local servers based on the hostname.
+Before diving into specific features, let's start by configuring and setting up our basic proxy server:
 
 ```typescript
 import { NetworkProxy } from '@push.rocks/smartproxy';
@@ -26,7 +26,7 @@ import { NetworkProxy } from '@push.rocks/smartproxy';
 // Instantiate the NetworkProxy with desired options
 const myNetworkProxy = new NetworkProxy({ port: 443 });
 
-// Define your reverse proxy configurations
+// Define reverse proxy configurations
 const proxyConfigs = [
   {
     destinationIp: '127.0.0.1',
@@ -39,70 +39,187 @@ PRIVATE_KEY_CONTENT
 CERTIFICATE_CONTENT
 -----END CERTIFICATE-----`,
   },
-  // Add more reverse proxy configurations here
+  // More configurations can be added here
 ];
 
 // Start the network proxy
 await myNetworkProxy.start();
 
-// Update proxy configurations dynamically
+// Apply proxy configurations
 await myNetworkProxy.updateProxyConfigs(proxyConfigs);
 
-// Optionally, add default headers to all responses
+// Optionally add default headers to all responses
 await myNetworkProxy.addDefaultHeaders({
   'X-Powered-By': 'smartproxy',
 });
 ```
 
-### Port Proxying
+### Configuring SSL Redirection
 
-You can also set up a port proxy to forward traffic from one port to another, which is useful for dynamic port forwarding scenarios.
+One essential capability of a robust proxy server is ensuring that all HTTP traffic is redirected to secure HTTPS endpoints. This can be effortlessly accomplished using the `SslRedirect` class within `smartproxy`. This class listens on port 80 (HTTP) and redirects all incoming requests to HTTPS:
+
+```typescript
+import { SslRedirect } from '@push.rocks/smartproxy';
+
+// Instantiate the SslRedirect for listening on port 80
+const mySslRedirect = new SslRedirect(80);
+
+// Start listening and redirect HTTP traffic to HTTPS
+await mySslRedirect.start();
+
+// To stop redirection, you can use the following command:
+await mySslRedirect.stop();
+```
+
+### Handling Complex Networking with Port Proxy
+
+Port proxying allows redirection of traffic from one port to another. This capability is crucial when dealing with services that need dynamic port forwarding, or when adapting to infrastructure changes without downtime. Smartproxy's `PortProxy` class handles this efficiently:
 
 ```typescript
 import { PortProxy } from '@push.rocks/smartproxy';
 
-// Create a PortProxy to forward traffic from port 5000 to port 3000
+// Create a PortProxy to directly forward traffic from port 5000 to 3000
 const myPortProxy = new PortProxy(5000, 3000);
 
-// Start the port proxy
+// Initiate the port proxy
 await myPortProxy.start();
 
-// To stop the port proxy, simply call
+// To stop the port proxy mechanism:
 await myPortProxy.stop();
 ```
 
-### Enabling SSL Redirection
+Additionally, smartproxy's port proxying can support intricate scenarios where different forwarding rules are configured based on domain names or allowed IPs:
 
-Easily redirect HTTP traffic to HTTPS using the `SslRedirect` class. This is particularly useful when ensuring all traffic uses encryption.
+```typescript
+import { PortProxy } from '@push.rocks/smartproxy';
+
+const myComplexPortProxy = new PortProxy({
+  fromPort: 6000,
+  toPort: 3000,
+  domains: [
+    {
+      domain: 'api.example.com',
+      allowedIPs: ['192.168.0.*', '127.0.0.1'],
+      targetIP: '192.168.1.100'
+    }
+    // Define more domain-specific rules if needed
+  ],
+  sniEnabled: true,  // if SNI (Server Name Indication) is desired
+  defaultAllowedIPs: ['*']);
+});
+
+// Start listening for complex routing requests
+await myComplexPortProxy.start();
+```
+
+### WebSocket Support and Load Handling
+
+With the advent of real-time applications, efficient WebSocket handling in proxies is crucial. Smartproxy integrates WebSocket support seamlessly, enabling it to proxy WebSocket traffic while maintaining security and performance:
 
 ```typescript
-import { SslRedirect } from '@push.rocks/smartproxy';
+import { NetworkProxy } from '@push.rocks/smartproxy';
 
-// Instantiate the SslRedirect on port 80 (HTTP)
-const mySslRedirect = new SslRedirect(80);
+const wsProxy = new NetworkProxy({ port: 443 });
 
-// Start listening and redirecting to HTTPS
-await mySslRedirect.start();
+// Assume reverse proxy configurations with WebSocket intentions
+const wsProxyConfigs = [
+  {
+    destinationIp: '127.0.0.1',
+    destinationPort: '8080',
+    hostName: 'socket.example.com',
+    // Add further options such as keys for SSL if needed
+  }
+];
 
-// To stop the redirection, use
-await mySslRedirect.stop();
+// Start the network proxy with WebSocket capabilities
+await wsProxy.start();
+await wsProxy.updateProxyConfigs(wsProxyConfigs);
+
+// Ensure WebSocket connections remain alive
+wsProxy.heartbeatInterval = setInterval(() => {
+  // logic for keeping connections alive and healthy
+}, 60000); // Every 60 seconds
+
+// Gracefully handle server or connection errors to maintain uptime
+wsProxy.httpsServer.on('error', (error) => console.log('Server Error:', error));
+```
+
+### Comprehensive Routing and Advanced Features
+
+Smartproxy supports dynamic and customizable request routing based on the incoming request's destination. This feature enables extensive use-case scenarios, from simple API endpoint redirection to elaborate B2B service integrations:
+
+```typescript
+import { NetworkProxy } from '@push.rocks/smartproxy';
+
+const dynamicRoutingProxy = new NetworkProxy({ port: 8443 });
+dynamicRoutingProxy.router.setNewProxyConfigs([
+  {
+    destinationIp: '192.168.1.150',
+    destinationPort: '80',
+    hostName: 'dynamic.example.com',
+    authentication: {
+      type: 'Basic',
+      user: 'admin',
+      pass: 'password123'
+    }
+  }
+]);
+
+await dynamicRoutingProxy.start();
 ```
 
-### Advanced Usage
+For those dealing with high volume or regulatory needs, the integration of tools like `iptables` allows broad control over network traffic:
 
-The package integrates seamlessly with TypeScript, allowing for advanced use cases, such as implementing custom routing logic, authentication mechanisms, and handling WebSocket connections through the network proxy.
+```typescript
+import { IPTablesProxy } from '@push.rocks/smartproxy';
 
-For a more advanced setup involving WebSocket proxying and dynamic configuration reloading, refer to the network proxy example provided above. The WebSocket support demonstrates how seamless it is to work with real-time applications.
+// Setting up iptables for advanced network management
+const ipTablesProxy = new IPTablesProxy({
+  fromPort: 8081,
+  toPort: 8080,
+  deleteOnExit: true // clean rules upon server shutdown
+});
 
-Remember, when dealing with certificates and private keys for HTTPS configurations, always secure your keys and store them appropriately.
+// Begin routing with IPTables
+await ipTablesProxy.start();
+```
 
-`@push.rocks/smartproxy` provides a solid foundation for handling high workloads and complex proxying requirements with ease, whether you're implementing SSL redirections, port forwarding, or extensive routing and WebSocket support in your network.
+### Combining with HTTP and HTTPS Credentials
+
+When undertaking proxy configurations, handling sensitive data like SSL certificates and keys securely is imperative:
+
+```typescript
+import { loadDefaultCertificates } from '@push.rocks/smartproxy';
+
+try {
+  const { privateKey, publicKey } = loadDefaultCertificates(); // adjust path as needed
+  console.log('Certificates loaded.');
+  // Use these certificates in your SSL-based configurations
+} catch (error) {
+  console.error('Cannot load certificates:', error);
+}
+```
+
+### Testing and Validation
+
+Given these powerful capabilities, rigorous testing of configurations and functionality using frameworks like `tap` can ensure high-quality and reliable proxy configurations. Smartproxy integrates with Typescript test setups:
+
+```typescript
+import { expect, tap } from '@push.rocks/tapbundle';
+import { NetworkProxy } from '@push.rocks/smartproxy';
+
+tap.test('proxied request should return status 200', async () => {
+  // Your test logic here
+});
+
+tap.start();
+```
 
-For more information on how to use the features, refer to the in-depth documentation available in the package's repository or the npm package description.
+In summary, `@push.rocks/smartproxy` offers a plethora of solutions tailored to both common and sophisticated proxying needs. Whether you're seeking straightforward port forwarding, secure SSL redirection, WebSocket management, or robust network routing controls, smartproxy provides the right tools for efficient and effective proxy operations. Through its integration simplicity and versatile configurations, developers can ensure high performance and secure proxying across various environments and applications.
 
 ## License and Legal Information
 
-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '3.11.0',
-  description: 'a proxy for handling high workloads of proxying'
+  version: '3.13.0',
+  description: 'A robust and versatile proxy package designed to handle high workloads, offering features like SSL redirection, port proxying, WebSocket support, and customizable routing and authentication.'
 }

package/ts/classes.iptablesproxy.ts

@@ -0,0 +1,183 @@
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Settings for IPTablesProxy.
+ */
+export interface IIpTableProxySettings {
+  fromPort: number;
+  toPort: number;
+  toHost?: string; // Target host for proxying; defaults to 'localhost'
+  preserveSourceIP?: boolean; // If true, the original source IP is preserved.
+  deleteOnExit?: boolean;   // If true, clean up marked iptables rules before process exit.
+}
+
+/**
+ * IPTablesProxy sets up iptables NAT rules to forward TCP traffic.
+ * It only supports basic port forwarding and uses iptables comments to tag rules.
+ */
+export class IPTablesProxy {
+  public settings: IIpTableProxySettings;
+  private rulesInstalled: boolean = false;
+  private ruleTag: string;
+
+  constructor(settings: IIpTableProxySettings) {
+    this.settings = {
+      ...settings,
+      toHost: settings.toHost || 'localhost',
+    };
+    // Generate a unique identifier for the rules added by this instance.
+    this.ruleTag = `IPTablesProxy:${Date.now()}:${Math.random().toString(36).substr(2, 5)}`;
+
+    // If deleteOnExit is true, register cleanup handlers.
+    if (this.settings.deleteOnExit) {
+      const cleanup = () => {
+        try {
+          IPTablesProxy.cleanSlateSync();
+        } catch (err) {
+          console.error('Error cleaning iptables rules on exit:', err);
+        }
+      };
+      process.on('exit', cleanup);
+      process.on('SIGINT', () => {
+        cleanup();
+        process.exit();
+      });
+      process.on('SIGTERM', () => {
+        cleanup();
+        process.exit();
+      });
+    }
+  }
+
+  /**
+   * Sets up iptables rules for port forwarding.
+   * The rules are tagged with a unique comment so that they can be identified later.
+   */
+  public async start(): Promise<void> {
+    const dnatCmd = `iptables -t nat -A PREROUTING -p tcp --dport ${this.settings.fromPort} ` +
+      `-j DNAT --to-destination ${this.settings.toHost}:${this.settings.toPort} ` +
+      `-m comment --comment "${this.ruleTag}:DNAT"`;
+    try {
+      await execAsync(dnatCmd);
+      console.log(`Added iptables rule: ${dnatCmd}`);
+      this.rulesInstalled = true;
+    } catch (err) {
+      console.error(`Failed to add iptables DNAT rule: ${err}`);
+      throw err;
+    }
+
+    // If preserveSourceIP is false, add a MASQUERADE rule.
+    if (!this.settings.preserveSourceIP) {
+      const masqueradeCmd = `iptables -t nat -A POSTROUTING -p tcp -d ${this.settings.toHost} ` +
+        `--dport ${this.settings.toPort} -j MASQUERADE ` +
+        `-m comment --comment "${this.ruleTag}:MASQ"`;
+      try {
+        await execAsync(masqueradeCmd);
+        console.log(`Added iptables rule: ${masqueradeCmd}`);
+      } catch (err) {
+        console.error(`Failed to add iptables MASQUERADE rule: ${err}`);
+        // Roll back the DNAT rule if MASQUERADE fails.
+        try {
+          const rollbackCmd = `iptables -t nat -D PREROUTING -p tcp --dport ${this.settings.fromPort} ` +
+            `-j DNAT --to-destination ${this.settings.toHost}:${this.settings.toPort} ` +
+            `-m comment --comment "${this.ruleTag}:DNAT"`;
+          await execAsync(rollbackCmd);
+          this.rulesInstalled = false;
+        } catch (rollbackErr) {
+          console.error(`Rollback failed: ${rollbackErr}`);
+        }
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Removes the iptables rules that were added in start(), by matching the unique comment.
+   */
+  public async stop(): Promise<void> {
+    if (!this.rulesInstalled) return;
+
+    const dnatDelCmd = `iptables -t nat -D PREROUTING -p tcp --dport ${this.settings.fromPort} ` +
+      `-j DNAT --to-destination ${this.settings.toHost}:${this.settings.toPort} ` +
+      `-m comment --comment "${this.ruleTag}:DNAT"`;
+    try {
+      await execAsync(dnatDelCmd);
+      console.log(`Removed iptables rule: ${dnatDelCmd}`);
+    } catch (err) {
+      console.error(`Failed to remove iptables DNAT rule: ${err}`);
+    }
+
+    if (!this.settings.preserveSourceIP) {
+      const masqueradeDelCmd = `iptables -t nat -D POSTROUTING -p tcp -d ${this.settings.toHost} ` +
+        `--dport ${this.settings.toPort} -j MASQUERADE ` +
+        `-m comment --comment "${this.ruleTag}:MASQ"`;
+      try {
+        await execAsync(masqueradeDelCmd);
+        console.log(`Removed iptables rule: ${masqueradeDelCmd}`);
+      } catch (err) {
+        console.error(`Failed to remove iptables MASQUERADE rule: ${err}`);
+      }
+    }
+
+    this.rulesInstalled = false;
+  }
+
+  /**
+   * Asynchronously cleans up any iptables rules in the nat table that were added by this module.
+   * It looks for rules with comments containing "IPTablesProxy:".
+   */
+  public static async cleanSlate(): Promise<void> {
+    try {
+      const { stdout } = await execAsync('iptables-save -t nat');
+      const lines = stdout.split('\n');
+      const proxyLines = lines.filter(line => line.includes('IPTablesProxy:'));
+      for (const line of proxyLines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith('-A')) {
+          // Replace the "-A" with "-D" to form a deletion command.
+          const deleteRule = trimmedLine.replace('-A', '-D');
+          const cmd = `iptables -t nat ${deleteRule}`;
+          try {
+            await execAsync(cmd);
+            console.log(`Cleaned up iptables rule: ${cmd}`);
+          } catch (err) {
+            console.error(`Failed to remove iptables rule: ${cmd}`, err);
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`Failed to run iptables-save: ${err}`);
+    }
+  }
+
+  /**
+   * Synchronously cleans up any iptables rules in the nat table that were added by this module.
+   * It looks for rules with comments containing "IPTablesProxy:".
+   * This method is intended for use in process exit handlers.
+   */
+  public static cleanSlateSync(): void {
+    try {
+      const stdout = execSync('iptables-save -t nat').toString();
+      const lines = stdout.split('\n');
+      const proxyLines = lines.filter(line => line.includes('IPTablesProxy:'));
+      for (const line of proxyLines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith('-A')) {
+          const deleteRule = trimmedLine.replace('-A', '-D');
+          const cmd = `iptables -t nat ${deleteRule}`;
+          try {
+            execSync(cmd);
+            console.log(`Cleaned up iptables rule: ${cmd}`);
+          } catch (err) {
+            console.error(`Failed to remove iptables rule: ${cmd}`, err);
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`Failed to run iptables-save: ${err}`);
+    }
+  }
+}

package/ts/classes.portproxy.ts

@@ -6,7 +6,7 @@ export interface IDomainConfig {
   targetIP?: string;      // Optional target IP for this domain
 }
 
-export interface IProxySettings extends plugins.tls.TlsOptions {
+export interface IPortProxySettings extends plugins.tls.TlsOptions {
   fromPort: number;
   toPort: number;
   toHost?: string; // Target host to proxy to, defaults to 'localhost'
@@ -89,7 +89,7 @@ interface IConnectionRecord {
 
 export class PortProxy {
   netServer: plugins.net.Server;
-  settings: IProxySettings;
+  settings: IPortProxySettings;
   // Unified record tracking each connection pair.
   private connectionRecords: Set<IConnectionRecord> = new Set();
   private connectionLogger: NodeJS.Timeout | null = null;
@@ -102,7 +102,7 @@ export class PortProxy {
     outgoing: {},
   };
 
-  constructor(settings: IProxySettings) {
+  constructor(settings: IPortProxySettings) {
     this.settings = {
       ...settings,
       toHost: settings.toHost || 'localhost',

package/ts/index.ts

@@ -1,3 +1,4 @@
+export * from './classes.iptablesproxy.js';
 export * from './classes.networkproxy.js';
 export * from './classes.portproxy.js';
 export * from './classes.port80handler.js';