@push.rocks/smartproxy 3.28.6 → 3.29.1

package/dist_ts/classes.iptablesproxy.js

@@ -3,22 +3,34 @@ 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.
+ * Enhanced with multi-port support, IPv6, and integration with PortProxy/NetworkProxy.
  */
 export class IPTablesProxy {
     constructor(settings) {
-        this.rulesInstalled = false;
+        this.rules = [];
+        this.customChain = null;
+        // Validate inputs to prevent command injection
+        this.validateSettings(settings);
+        // Set default settings
         this.settings = {
             ...settings,
             toHost: settings.toHost || 'localhost',
+            protocol: settings.protocol || 'tcp',
+            enableLogging: settings.enableLogging !== undefined ? settings.enableLogging : false,
+            ipv6Support: settings.ipv6Support !== undefined ? settings.ipv6Support : false,
+            checkExistingRules: settings.checkExistingRules !== undefined ? settings.checkExistingRules : true,
+            netProxyIntegration: settings.netProxyIntegration || { enabled: false }
         };
-        // Generate a unique identifier for the rules added by this instance.
+        // 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.addJumpRule) {
+            this.customChain = `IPTablesProxy_${Math.random().toString(36).substr(2, 5)}`;
+        }
+        // Register cleanup handlers if deleteOnExit is true
         if (this.settings.deleteOnExit) {
             const cleanup = () => {
                 try {
-                    IPTablesProxy.cleanSlateSync();
+                    this.stopSync();
                 }
                 catch (err) {
                     console.error('Error cleaning iptables rules on exit:', err);
@@ -36,105 +48,614 @@ export class IPTablesProxy {
         }
     }
     /**
-     * Sets up iptables rules for port forwarding.
-     * The rules are tagged with a unique comment so that they can be identified later.
+     * Validates settings to prevent command injection and ensure valid values
      */
-    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"`;
+    validateSettings(settings) {
+        // Validate port numbers
+        const validatePorts = (port) => {
+            if (Array.isArray(port)) {
+                port.forEach(p => validatePorts(p));
+                return;
+            }
+            if (typeof port === 'number') {
+                if (port < 1 || port > 65535) {
+                    throw new Error(`Invalid port number: ${port}`);
+                }
+            }
+            else if (typeof port === 'object') {
+                if (port.from < 1 || port.from > 65535 || port.to < 1 || port.to > 65535 || port.from > port.to) {
+                    throw new Error(`Invalid port range: ${port.from}-${port.to}`);
+                }
+            }
+        };
+        validatePorts(settings.fromPort);
+        validatePorts(settings.toPort);
+        // Define regex patterns at the method level so they're available throughout
+        const ipRegex = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\/([0-9]|[1-2][0-9]|3[0-2]))?$/;
+        const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))(\/([0-9]|[1-9][0-9]|1[0-1][0-9]|12[0-8]))?$/;
+        // Validate IP addresses
+        const validateIPs = (ips) => {
+            if (!ips)
+                return;
+            for (const ip of ips) {
+                if (!ipRegex.test(ip) && !ipv6Regex.test(ip)) {
+                    throw new Error(`Invalid IP address format: ${ip}`);
+                }
+            }
+        };
+        validateIPs(settings.allowedSourceIPs);
+        validateIPs(settings.bannedSourceIPs);
+        // Validate toHost - only allow hostnames or IPs
+        if (settings.toHost) {
+            const hostRegex = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
+            if (!hostRegex.test(settings.toHost) && !ipRegex.test(settings.toHost) && !ipv6Regex.test(settings.toHost)) {
+                throw new Error(`Invalid host format: ${settings.toHost}`);
+            }
+        }
+    }
+    /**
+     * Normalizes port specifications into an array of port ranges
+     */
+    normalizePortSpec(portSpec) {
+        const result = [];
+        if (Array.isArray(portSpec)) {
+            // If it's an array, process each element
+            for (const spec of portSpec) {
+                result.push(...this.normalizePortSpec(spec));
+            }
+        }
+        else if (typeof portSpec === 'number') {
+            // Single port becomes a range with the same start and end
+            result.push({ from: portSpec, to: portSpec });
+        }
+        else {
+            // Already a range
+            result.push(portSpec);
+        }
+        return result;
+    }
+    /**
+     * Gets the appropriate iptables command based on settings
+     */
+    getIptablesCommand(isIpv6 = false) {
+        return isIpv6 ? 'ip6tables' : 'iptables';
+    }
+    /**
+     * Checks if a rule already exists in iptables
+     */
+    async ruleExists(table, command, isIpv6 = false) {
         try {
-            await execAsync(dnatCmd);
-            console.log(`Added iptables rule: ${dnatCmd}`);
-            this.rulesInstalled = true;
+            const iptablesCmd = this.getIptablesCommand(isIpv6);
+            const { stdout } = await execAsync(`${iptablesCmd}-save -t ${table}`);
+            // Convert the command to the format found in iptables-save output
+            // (This is a simplification - in reality, you'd need more parsing)
+            const rulePattern = command.replace(`${iptablesCmd} -t ${table} -A `, '-A ');
+            return stdout.split('\n').some(line => line.trim() === rulePattern);
         }
         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}`);
+            this.log('error', `Failed to check if rule exists: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Sets up a custom chain for better rule management
+     */
+    async setupCustomChain(isIpv6 = false) {
+        if (!this.customChain)
+            return true;
+        const iptablesCmd = this.getIptablesCommand(isIpv6);
+        const table = 'nat';
+        try {
+            // Create the chain
+            await execAsync(`${iptablesCmd} -t ${table} -N ${this.customChain}`);
+            this.log('info', `Created custom chain: ${this.customChain}`);
+            // Add jump rule to PREROUTING chain
+            const jumpCommand = `${iptablesCmd} -t ${table} -A PREROUTING -j ${this.customChain} -m comment --comment "${this.ruleTag}:JUMP"`;
+            await execAsync(jumpCommand);
+            this.log('info', `Added jump rule to ${this.customChain}`);
+            // Store the jump rule
+            this.rules.push({
+                table,
+                chain: 'PREROUTING',
+                command: jumpCommand,
+                tag: `${this.ruleTag}:JUMP`,
+                added: true
+            });
+            return true;
+        }
+        catch (err) {
+            this.log('error', `Failed to set up custom chain: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Add a source IP filter rule
+     */
+    async addSourceIPFilter(isIpv6 = false) {
+        if (!this.settings.allowedSourceIPs && !this.settings.bannedSourceIPs) {
+            return true;
+        }
+        const iptablesCmd = this.getIptablesCommand(isIpv6);
+        const table = 'nat';
+        const chain = this.customChain || 'PREROUTING';
+        try {
+            // Add banned IPs first (explicit deny)
+            if (this.settings.bannedSourceIPs && this.settings.bannedSourceIPs.length > 0) {
+                for (const ip of this.settings.bannedSourceIPs) {
+                    const command = `${iptablesCmd} -t ${table} -A ${chain} -s ${ip} -j DROP -m comment --comment "${this.ruleTag}:BANNED"`;
+                    // Check if rule already exists
+                    if (this.settings.checkExistingRules && await this.ruleExists(table, command, isIpv6)) {
+                        this.log('info', `Rule already exists, skipping: ${command}`);
+                        continue;
+                    }
+                    await execAsync(command);
+                    this.log('info', `Added banned IP rule: ${command}`);
+                    this.rules.push({
+                        table,
+                        chain,
+                        command,
+                        tag: `${this.ruleTag}:BANNED`,
+                        added: true
+                    });
+                }
             }
-            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;
+            // Add allowed IPs (explicit allow)
+            if (this.settings.allowedSourceIPs && this.settings.allowedSourceIPs.length > 0) {
+                // First add a default deny for all
+                const denyAllCommand = `${iptablesCmd} -t ${table} -A ${chain} -p ${this.settings.protocol} -j DROP -m comment --comment "${this.ruleTag}:DENY_ALL"`;
+                // Add allow rules for specific IPs
+                for (const ip of this.settings.allowedSourceIPs) {
+                    const command = `${iptablesCmd} -t ${table} -A ${chain} -s ${ip} -p ${this.settings.protocol} -j ACCEPT -m comment --comment "${this.ruleTag}:ALLOWED"`;
+                    // Check if rule already exists
+                    if (this.settings.checkExistingRules && await this.ruleExists(table, command, isIpv6)) {
+                        this.log('info', `Rule already exists, skipping: ${command}`);
+                        continue;
+                    }
+                    await execAsync(command);
+                    this.log('info', `Added allowed IP rule: ${command}`);
+                    this.rules.push({
+                        table,
+                        chain,
+                        command,
+                        tag: `${this.ruleTag}:ALLOWED`,
+                        added: true
+                    });
+                }
+                // Now add the default deny after all allows
+                if (this.settings.checkExistingRules && await this.ruleExists(table, denyAllCommand, isIpv6)) {
+                    this.log('info', `Rule already exists, skipping: ${denyAllCommand}`);
                 }
-                catch (rollbackErr) {
-                    console.error(`Rollback failed: ${rollbackErr}`);
+                else {
+                    await execAsync(denyAllCommand);
+                    this.log('info', `Added default deny rule: ${denyAllCommand}`);
+                    this.rules.push({
+                        table,
+                        chain,
+                        command: denyAllCommand,
+                        tag: `${this.ruleTag}:DENY_ALL`,
+                        added: true
+                    });
                 }
-                throw err;
             }
+            return true;
+        }
+        catch (err) {
+            this.log('error', `Failed to add source IP filter rules: ${err}`);
+            return false;
         }
     }
     /**
-     * Removes the iptables rules that were added in start(), by matching the unique comment.
+     * Adds a port forwarding rule
      */
-    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"`;
+    async addPortForwardingRule(fromPortRange, toPortRange, isIpv6 = false) {
+        const iptablesCmd = this.getIptablesCommand(isIpv6);
+        const table = 'nat';
+        const chain = this.customChain || 'PREROUTING';
+        try {
+            // Handle single port case
+            if (fromPortRange.from === fromPortRange.to && toPortRange.from === toPortRange.to) {
+                // Single port forward
+                const command = `${iptablesCmd} -t ${table} -A ${chain} -p ${this.settings.protocol} --dport ${fromPortRange.from} ` +
+                    `-j DNAT --to-destination ${this.settings.toHost}:${toPortRange.from} ` +
+                    `-m comment --comment "${this.ruleTag}:DNAT"`;
+                // Check if rule already exists
+                if (this.settings.checkExistingRules && await this.ruleExists(table, command, isIpv6)) {
+                    this.log('info', `Rule already exists, skipping: ${command}`);
+                }
+                else {
+                    await execAsync(command);
+                    this.log('info', `Added port forwarding rule: ${command}`);
+                    this.rules.push({
+                        table,
+                        chain,
+                        command,
+                        tag: `${this.ruleTag}:DNAT`,
+                        added: true
+                    });
+                }
+            }
+            else if (fromPortRange.to - fromPortRange.from === toPortRange.to - toPortRange.from) {
+                // Port range forward with equal ranges
+                const command = `${iptablesCmd} -t ${table} -A ${chain} -p ${this.settings.protocol} --dport ${fromPortRange.from}:${fromPortRange.to} ` +
+                    `-j DNAT --to-destination ${this.settings.toHost}:${toPortRange.from}-${toPortRange.to} ` +
+                    `-m comment --comment "${this.ruleTag}:DNAT_RANGE"`;
+                // Check if rule already exists
+                if (this.settings.checkExistingRules && await this.ruleExists(table, command, isIpv6)) {
+                    this.log('info', `Rule already exists, skipping: ${command}`);
+                }
+                else {
+                    await execAsync(command);
+                    this.log('info', `Added port range forwarding rule: ${command}`);
+                    this.rules.push({
+                        table,
+                        chain,
+                        command,
+                        tag: `${this.ruleTag}:DNAT_RANGE`,
+                        added: true
+                    });
+                }
+            }
+            else {
+                // Unequal port ranges need individual rules
+                for (let i = 0; i <= fromPortRange.to - fromPortRange.from; i++) {
+                    const fromPort = fromPortRange.from + i;
+                    const toPort = toPortRange.from + i % (toPortRange.to - toPortRange.from + 1);
+                    const command = `${iptablesCmd} -t ${table} -A ${chain} -p ${this.settings.protocol} --dport ${fromPort} ` +
+                        `-j DNAT --to-destination ${this.settings.toHost}:${toPort} ` +
+                        `-m comment --comment "${this.ruleTag}:DNAT_INDIVIDUAL"`;
+                    // Check if rule already exists
+                    if (this.settings.checkExistingRules && await this.ruleExists(table, command, isIpv6)) {
+                        this.log('info', `Rule already exists, skipping: ${command}`);
+                        continue;
+                    }
+                    await execAsync(command);
+                    this.log('info', `Added individual port forwarding rule: ${command}`);
+                    this.rules.push({
+                        table,
+                        chain,
+                        command,
+                        tag: `${this.ruleTag}:DNAT_INDIVIDUAL`,
+                        added: true
+                    });
+                }
+            }
+            // If preserveSourceIP is false, add a MASQUERADE rule
+            if (!this.settings.preserveSourceIP) {
+                // For port range
+                const masqCommand = `${iptablesCmd} -t nat -A POSTROUTING -p ${this.settings.protocol} -d ${this.settings.toHost} ` +
+                    `--dport ${toPortRange.from}:${toPortRange.to} -j MASQUERADE ` +
+                    `-m comment --comment "${this.ruleTag}:MASQ"`;
+                // Check if rule already exists
+                if (this.settings.checkExistingRules && await this.ruleExists('nat', masqCommand, isIpv6)) {
+                    this.log('info', `Rule already exists, skipping: ${masqCommand}`);
+                }
+                else {
+                    await execAsync(masqCommand);
+                    this.log('info', `Added MASQUERADE rule: ${masqCommand}`);
+                    this.rules.push({
+                        table: 'nat',
+                        chain: 'POSTROUTING',
+                        command: masqCommand,
+                        tag: `${this.ruleTag}:MASQ`,
+                        added: true
+                    });
+                }
+            }
+            return true;
+        }
+        catch (err) {
+            this.log('error', `Failed to add port forwarding rule: ${err}`);
+            // Try to roll back any rules that were already added
+            await this.rollbackRules();
+            return false;
+        }
+    }
+    /**
+     * Special handling for NetworkProxy integration
+     */
+    async setupNetworkProxyIntegration(isIpv6 = false) {
+        if (!this.settings.netProxyIntegration?.enabled) {
+            return true;
+        }
+        const netProxyConfig = this.settings.netProxyIntegration;
+        const iptablesCmd = this.getIptablesCommand(isIpv6);
+        const table = 'nat';
+        const chain = this.customChain || 'PREROUTING';
         try {
-            await execAsync(dnatDelCmd);
-            console.log(`Removed iptables rule: ${dnatDelCmd}`);
+            // If redirectLocalhost is true, set up special rule to redirect localhost traffic to NetworkProxy
+            if (netProxyConfig.redirectLocalhost && netProxyConfig.sslTerminationPort) {
+                const redirectCommand = `${iptablesCmd} -t ${table} -A OUTPUT -p tcp -d 127.0.0.1 -j REDIRECT ` +
+                    `--to-port ${netProxyConfig.sslTerminationPort} ` +
+                    `-m comment --comment "${this.ruleTag}:NETPROXY_REDIRECT"`;
+                // Check if rule already exists
+                if (this.settings.checkExistingRules && await this.ruleExists(table, redirectCommand, isIpv6)) {
+                    this.log('info', `Rule already exists, skipping: ${redirectCommand}`);
+                }
+                else {
+                    await execAsync(redirectCommand);
+                    this.log('info', `Added NetworkProxy redirection rule: ${redirectCommand}`);
+                    this.rules.push({
+                        table,
+                        chain: 'OUTPUT',
+                        command: redirectCommand,
+                        tag: `${this.ruleTag}:NETPROXY_REDIRECT`,
+                        added: true
+                    });
+                }
+            }
+            return true;
         }
         catch (err) {
-            console.error(`Failed to remove iptables DNAT rule: ${err}`);
+            this.log('error', `Failed to set up NetworkProxy integration: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Rolls back rules that were added in case of error
+     */
+    async rollbackRules() {
+        // Process rules in reverse order (LIFO)
+        for (let i = this.rules.length - 1; i >= 0; i--) {
+            const rule = this.rules[i];
+            if (rule.added) {
+                try {
+                    // Convert -A (add) to -D (delete)
+                    const deleteCommand = rule.command.replace('-A', '-D');
+                    await execAsync(deleteCommand);
+                    this.log('info', `Rolled back rule: ${deleteCommand}`);
+                    rule.added = false;
+                }
+                catch (err) {
+                    this.log('error', `Failed to roll back rule: ${err}`);
+                }
+            }
+        }
+    }
+    /**
+     * Sets up iptables rules for port forwarding with enhanced features
+     */
+    async start() {
+        // Optionally clean the slate first
+        if (this.settings.forceCleanSlate) {
+            await IPTablesProxy.cleanSlate();
         }
-        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"`;
+        // First set up any custom chains
+        if (this.settings.addJumpRule) {
+            const chainSetupSuccess = await this.setupCustomChain();
+            if (!chainSetupSuccess) {
+                throw new Error('Failed to set up custom chain');
+            }
+            // For IPv6 if enabled
+            if (this.settings.ipv6Support) {
+                const chainSetupSuccessIpv6 = await this.setupCustomChain(true);
+                if (!chainSetupSuccessIpv6) {
+                    this.log('warn', 'Failed to set up IPv6 custom chain, continuing with IPv4 only');
+                }
+            }
+        }
+        // Add source IP filters
+        await this.addSourceIPFilter();
+        if (this.settings.ipv6Support) {
+            await this.addSourceIPFilter(true);
+        }
+        // Set up NetworkProxy integration if enabled
+        if (this.settings.netProxyIntegration?.enabled) {
+            const netProxySetupSuccess = await this.setupNetworkProxyIntegration();
+            if (!netProxySetupSuccess) {
+                this.log('warn', 'Failed to set up NetworkProxy integration');
+            }
+            if (this.settings.ipv6Support) {
+                await this.setupNetworkProxyIntegration(true);
+            }
+        }
+        // Normalize port specifications
+        const fromPortRanges = this.normalizePortSpec(this.settings.fromPort);
+        const toPortRanges = this.normalizePortSpec(this.settings.toPort);
+        // Handle the case where fromPort and toPort counts don't match
+        if (fromPortRanges.length !== toPortRanges.length) {
+            if (toPortRanges.length === 1) {
+                // If there's only one toPort, use it for all fromPorts
+                for (const fromRange of fromPortRanges) {
+                    await this.addPortForwardingRule(fromRange, toPortRanges[0]);
+                    if (this.settings.ipv6Support) {
+                        await this.addPortForwardingRule(fromRange, toPortRanges[0], true);
+                    }
+                }
+            }
+            else {
+                throw new Error('Mismatched port counts: fromPort and toPort arrays must have equal length or toPort must be a single value');
+            }
+        }
+        else {
+            // Add port forwarding rules for each port specification
+            for (let i = 0; i < fromPortRanges.length; i++) {
+                await this.addPortForwardingRule(fromPortRanges[i], toPortRanges[i]);
+                if (this.settings.ipv6Support) {
+                    await this.addPortForwardingRule(fromPortRanges[i], toPortRanges[i], true);
+                }
+            }
+        }
+        // Final check - ensure we have at least one rule added
+        if (this.rules.filter(r => r.added).length === 0) {
+            throw new Error('No rules were added');
+        }
+    }
+    /**
+     * Removes all added iptables rules
+     */
+    async stop() {
+        // Process rules in reverse order (LIFO)
+        for (let i = this.rules.length - 1; i >= 0; i--) {
+            const rule = this.rules[i];
+            if (rule.added) {
+                try {
+                    // Convert -A (add) to -D (delete)
+                    const deleteCommand = rule.command.replace('-A', '-D');
+                    await execAsync(deleteCommand);
+                    this.log('info', `Removed rule: ${deleteCommand}`);
+                    rule.added = false;
+                }
+                catch (err) {
+                    this.log('error', `Failed to remove rule: ${err}`);
+                }
+            }
+        }
+        // If we created a custom chain, we need to clean it up
+        if (this.customChain) {
             try {
-                await execAsync(masqueradeDelCmd);
-                console.log(`Removed iptables rule: ${masqueradeDelCmd}`);
+                // First flush the chain
+                await execAsync(`iptables -t nat -F ${this.customChain}`);
+                this.log('info', `Flushed custom chain: ${this.customChain}`);
+                // Then delete it
+                await execAsync(`iptables -t nat -X ${this.customChain}`);
+                this.log('info', `Deleted custom chain: ${this.customChain}`);
+                // Same for IPv6 if enabled
+                if (this.settings.ipv6Support) {
+                    try {
+                        await execAsync(`ip6tables -t nat -F ${this.customChain}`);
+                        await execAsync(`ip6tables -t nat -X ${this.customChain}`);
+                        this.log('info', `Deleted IPv6 custom chain: ${this.customChain}`);
+                    }
+                    catch (err) {
+                        this.log('error', `Failed to delete IPv6 custom chain: ${err}`);
+                    }
+                }
             }
             catch (err) {
-                console.error(`Failed to remove iptables MASQUERADE rule: ${err}`);
+                this.log('error', `Failed to delete custom chain: ${err}`);
             }
         }
-        this.rulesInstalled = false;
+        // Clear rules array
+        this.rules = [];
+    }
+    /**
+     * Synchronous version of stop, for use in exit handlers
+     */
+    stopSync() {
+        // Process rules in reverse order (LIFO)
+        for (let i = this.rules.length - 1; i >= 0; i--) {
+            const rule = this.rules[i];
+            if (rule.added) {
+                try {
+                    // Convert -A (add) to -D (delete)
+                    const deleteCommand = rule.command.replace('-A', '-D');
+                    execSync(deleteCommand);
+                    this.log('info', `Removed rule: ${deleteCommand}`);
+                    rule.added = false;
+                }
+                catch (err) {
+                    this.log('error', `Failed to remove rule: ${err}`);
+                }
+            }
+        }
+        // If we created a custom chain, we need to clean it up
+        if (this.customChain) {
+            try {
+                // First flush the chain
+                execSync(`iptables -t nat -F ${this.customChain}`);
+                // Then delete it
+                execSync(`iptables -t nat -X ${this.customChain}`);
+                this.log('info', `Deleted custom chain: ${this.customChain}`);
+                // Same for IPv6 if enabled
+                if (this.settings.ipv6Support) {
+                    try {
+                        execSync(`ip6tables -t nat -F ${this.customChain}`);
+                        execSync(`ip6tables -t nat -X ${this.customChain}`);
+                    }
+                    catch (err) {
+                        // IPv6 failures are non-critical
+                    }
+                }
+            }
+            catch (err) {
+                this.log('error', `Failed to delete custom chain: ${err}`);
+            }
+        }
+        // Clear rules array
+        this.rules = [];
     }
     /**
      * 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() {
+        await IPTablesProxy.cleanSlateInternal();
+        // Also clean IPv6 rules
+        await IPTablesProxy.cleanSlateInternal(true);
+    }
+    /**
+     * Internal implementation of cleanSlate with IPv6 support
+     */
+    static async cleanSlateInternal(isIpv6 = false) {
+        const iptablesCmd = isIpv6 ? 'ip6tables' : 'iptables';
         try {
-            const { stdout } = await execAsync('iptables-save -t nat');
+            const { stdout } = await execAsync(`${iptablesCmd}-save -t nat`);
             const lines = stdout.split('\n');
             const proxyLines = lines.filter(line => line.includes('IPTablesProxy:'));
+            // First, find and remove any custom chains
+            const customChains = new Set();
+            const jumpRules = [];
             for (const line of proxyLines) {
+                if (line.includes('IPTablesProxy:JUMP')) {
+                    // Extract chain name from jump rule
+                    const match = line.match(/\s+-j\s+(\S+)\s+/);
+                    if (match && match[1].startsWith('IPTablesProxy_')) {
+                        customChains.add(match[1]);
+                        jumpRules.push(line);
+                    }
+                }
+            }
+            // Remove jump rules first
+            for (const line of jumpRules) {
                 const trimmedLine = line.trim();
                 if (trimmedLine.startsWith('-A')) {
-                    // Replace the "-A" with "-D" to form a deletion command.
+                    // Replace the "-A" with "-D" to form a deletion command
                     const deleteRule = trimmedLine.replace('-A', '-D');
-                    const cmd = `iptables -t nat ${deleteRule}`;
+                    const cmd = `${iptablesCmd} -t nat ${deleteRule}`;
                     try {
                         await execAsync(cmd);
-                        console.log(`Cleaned up iptables rule: ${cmd}`);
+                        console.log(`Cleaned up iptables jump rule: ${cmd}`);
                     }
                     catch (err) {
-                        console.error(`Failed to remove iptables rule: ${cmd}`, err);
+                        console.error(`Failed to remove iptables jump rule: ${cmd}`, err);
+                    }
+                }
+            }
+            // Then remove all other rules
+            for (const line of proxyLines) {
+                if (!line.includes('IPTablesProxy:JUMP')) { // Skip jump rules we already handled
+                    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 = `${iptablesCmd} -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);
+                        }
                     }
                 }
             }
+            // Finally clean up custom chains
+            for (const chain of customChains) {
+                try {
+                    // Flush the chain
+                    await execAsync(`${iptablesCmd} -t nat -F ${chain}`);
+                    console.log(`Flushed custom chain: ${chain}`);
+                    // Delete the chain
+                    await execAsync(`${iptablesCmd} -t nat -X ${chain}`);
+                    console.log(`Deleted custom chain: ${chain}`);
+                }
+                catch (err) {
+                    console.error(`Failed to delete custom chain ${chain}:`, err);
+                }
+            }
         }
         catch (err) {
-            console.error(`Failed to run iptables-save: ${err}`);
+            console.error(`Failed to run ${iptablesCmd}-save: ${err}`);
         }
     }
     /**
@@ -143,28 +664,102 @@ export class IPTablesProxy {
      * This method is intended for use in process exit handlers.
      */
     static cleanSlateSync() {
+        IPTablesProxy.cleanSlateSyncInternal();
+        // Also clean IPv6 rules
+        IPTablesProxy.cleanSlateSyncInternal(true);
+    }
+    /**
+     * Internal implementation of cleanSlateSync with IPv6 support
+     */
+    static cleanSlateSyncInternal(isIpv6 = false) {
+        const iptablesCmd = isIpv6 ? 'ip6tables' : 'iptables';
         try {
-            const stdout = execSync('iptables-save -t nat').toString();
+            const stdout = execSync(`${iptablesCmd}-save -t nat`).toString();
             const lines = stdout.split('\n');
             const proxyLines = lines.filter(line => line.includes('IPTablesProxy:'));
+            // First, find and remove any custom chains
+            const customChains = new Set();
+            const jumpRules = [];
             for (const line of proxyLines) {
+                if (line.includes('IPTablesProxy:JUMP')) {
+                    // Extract chain name from jump rule
+                    const match = line.match(/\s+-j\s+(\S+)\s+/);
+                    if (match && match[1].startsWith('IPTablesProxy_')) {
+                        customChains.add(match[1]);
+                        jumpRules.push(line);
+                    }
+                }
+            }
+            // Remove jump rules first
+            for (const line of jumpRules) {
                 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}`;
+                    const cmd = `${iptablesCmd} -t nat ${deleteRule}`;
                     try {
                         execSync(cmd);
-                        console.log(`Cleaned up iptables rule: ${cmd}`);
+                        console.log(`Cleaned up iptables jump rule: ${cmd}`);
                     }
                     catch (err) {
-                        console.error(`Failed to remove iptables rule: ${cmd}`, err);
+                        console.error(`Failed to remove iptables jump rule: ${cmd}`, err);
                     }
                 }
             }
+            // Then remove all other rules
+            for (const line of proxyLines) {
+                if (!line.includes('IPTablesProxy:JUMP')) { // Skip jump rules we already handled
+                    const trimmedLine = line.trim();
+                    if (trimmedLine.startsWith('-A')) {
+                        const deleteRule = trimmedLine.replace('-A', '-D');
+                        const cmd = `${iptablesCmd} -t nat ${deleteRule}`;
+                        try {
+                            execSync(cmd);
+                            console.log(`Cleaned up iptables rule: ${cmd}`);
+                        }
+                        catch (err) {
+                            console.error(`Failed to remove iptables rule: ${cmd}`, err);
+                        }
+                    }
+                }
+            }
+            // Finally clean up custom chains
+            for (const chain of customChains) {
+                try {
+                    // Flush the chain
+                    execSync(`${iptablesCmd} -t nat -F ${chain}`);
+                    // Delete the chain
+                    execSync(`${iptablesCmd} -t nat -X ${chain}`);
+                    console.log(`Deleted custom chain: ${chain}`);
+                }
+                catch (err) {
+                    console.error(`Failed to delete custom chain ${chain}:`, err);
+                }
+            }
         }
         catch (err) {
-            console.error(`Failed to run iptables-save: ${err}`);
+            console.error(`Failed to run ${iptablesCmd}-save: ${err}`);
+        }
+    }
+    /**
+     * Logging utility that respects the enableLogging setting
+     */
+    log(level, message) {
+        if (!this.settings.enableLogging && level === 'info') {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        switch (level) {
+            case 'info':
+                console.log(`[${timestamp}] [INFO] ${message}`);
+                break;
+            case 'warn':
+                console.warn(`[${timestamp}] [WARN] ${message}`);
+                break;
+            case 'error':
+                console.error(`[${timestamp}] [ERROR] ${message}`);
+                break;
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5pcHRhYmxlc3Byb3h5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5pcHRhYmxlc3Byb3h5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQy9DLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFakMsTUFBTSxTQUFTLEdBQUcsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBYWxDOzs7R0FHRztBQUNILE1BQU0sT0FBTyxhQUFhO0lBS3hCLFlBQVksUUFBK0I7UUFIbkMsbUJBQWMsR0FBWSxLQUFLLENBQUM7UUFJdEMsSUFBSSxDQUFDLFFBQVEsR0FBRztZQUNkLEdBQUcsUUFBUTtZQUNYLE1BQU0sRUFBRSxRQUFRLENBQUMsTUFBTSxJQUFJLFdBQVc7U0FDdkMsQ0FBQztRQUNGLHFFQUFxRTtRQUNyRSxJQUFJLENBQUMsT0FBTyxHQUFHLGlCQUFpQixJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFFeEYsc0RBQXNEO1FBQ3RELElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUMvQixNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUU7Z0JBQ25CLElBQUksQ0FBQztvQkFDSCxhQUFhLENBQUMsY0FBYyxFQUFFLENBQUM7Z0JBQ2pDLENBQUM7Z0JBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztvQkFDYixPQUFPLENBQUMsS0FBSyxDQUFDLHdDQUF3QyxFQUFFLEdBQUcsQ0FBQyxDQUFDO2dCQUMvRCxDQUFDO1lBQ0gsQ0FBQyxDQUFDO1lBQ0YsT0FBTyxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUM7WUFDNUIsT0FBTyxDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsR0FBRyxFQUFFO2dCQUN4QixPQUFPLEVBQUUsQ0FBQztnQkFDVixPQUFPLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDakIsQ0FBQyxDQUFDLENBQUM7WUFDSCxPQUFPLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxHQUFHLEVBQUU7Z0JBQ3pCLE9BQU8sRUFBRSxDQUFDO2dCQUNWLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNqQixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7SUFDSCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksS0FBSyxDQUFDLEtBQUs7UUFDaEIsTUFBTSxPQUFPLEdBQUcsZ0RBQWdELElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxHQUFHO1lBQ3ZGLDRCQUE0QixJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRztZQUMzRSx5QkFBeUIsSUFBSSxDQUFDLE9BQU8sUUFBUSxDQUFDO1FBQ2hELElBQUksQ0FBQztZQUNILE1BQU0sU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBQ3pCLE9BQU8sQ0FBQyxHQUFHLENBQUMsd0JBQXdCLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDL0MsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUM7UUFDN0IsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixPQUFPLENBQUMsS0FBSyxDQUFDLHFDQUFxQyxHQUFHLEVBQUUsQ0FBQyxDQUFDO1lBQzFELE1BQU0sR0FBRyxDQUFDO1FBQ1osQ0FBQztRQUVELHVEQUF1RDtRQUN2RCxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO1lBQ3BDLE1BQU0sYUFBYSxHQUFHLDRDQUE0QyxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRztnQkFDdkYsV0FBVyxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0saUJBQWlCO2dCQUNoRCx5QkFBeUIsSUFBSSxDQUFDLE9BQU8sUUFBUSxDQUFDO1lBQ2hELElBQUksQ0FBQztnQkFDSCxNQUFNLFNBQVMsQ0FBQyxhQUFhLENBQUMsQ0FBQztnQkFDL0IsT0FBTyxDQUFDLEdBQUcsQ0FBQyx3QkFBd0IsYUFBYSxFQUFFLENBQUMsQ0FBQztZQUN2RCxDQUFDO1lBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztnQkFDYixPQUFPLENBQUMsS0FBSyxDQUFDLDJDQUEyQyxHQUFHLEVBQUUsQ0FBQyxDQUFDO2dCQUNoRSwrQ0FBK0M7Z0JBQy9DLElBQUksQ0FBQztvQkFDSCxNQUFNLFdBQVcsR0FBRyxnREFBZ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEdBQUc7d0JBQzNGLDRCQUE0QixJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRzt3QkFDM0UseUJBQXlCLElBQUksQ0FBQyxPQUFPLFFBQVEsQ0FBQztvQkFDaEQsTUFBTSxTQUFTLENBQUMsV0FBVyxDQUFDLENBQUM7b0JBQzdCLElBQUksQ0FBQyxjQUFjLEdBQUcsS0FBSyxDQUFDO2dCQUM5QixDQUFDO2dCQUFDLE9BQU8sV0FBVyxFQUFFLENBQUM7b0JBQ3JCLE9BQU8sQ0FBQyxLQUFLLENBQUMsb0JBQW9CLFdBQVcsRUFBRSxDQUFDLENBQUM7Z0JBQ25ELENBQUM7Z0JBQ0QsTUFBTSxHQUFHLENBQUM7WUFDWixDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjO1lBQUUsT0FBTztRQUVqQyxNQUFNLFVBQVUsR0FBRyxnREFBZ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEdBQUc7WUFDMUYsNEJBQTRCLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxHQUFHO1lBQzNFLHlCQUF5QixJQUFJLENBQUMsT0FBTyxRQUFRLENBQUM7UUFDaEQsSUFBSSxDQUFDO1lBQ0gsTUFBTSxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDNUIsT0FBTyxDQUFDLEdBQUcsQ0FBQywwQkFBMEIsVUFBVSxFQUFFLENBQUMsQ0FBQztRQUN0RCxDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLE9BQU8sQ0FBQyxLQUFLLENBQUMsd0NBQXdDLEdBQUcsRUFBRSxDQUFDLENBQUM7UUFDL0QsQ0FBQztRQUVELElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGdCQUFnQixFQUFFLENBQUM7WUFDcEMsTUFBTSxnQkFBZ0IsR0FBRyw0Q0FBNEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEdBQUc7Z0JBQzFGLFdBQVcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLGlCQUFpQjtnQkFDaEQseUJBQXlCLElBQUksQ0FBQyxPQUFPLFFBQVEsQ0FBQztZQUNoRCxJQUFJLENBQUM7Z0JBQ0gsTUFBTSxTQUFTLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztnQkFDbEMsT0FBTyxDQUFDLEdBQUcsQ0FBQywwQkFBMEIsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDO1lBQzVELENBQUM7WUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO2dCQUNiLE9BQU8sQ0FBQyxLQUFLLENBQUMsOENBQThDLEdBQUcsRUFBRSxDQUFDLENBQUM7WUFDckUsQ0FBQztRQUNILENBQUM7UUFFRCxJQUFJLENBQUMsY0FBYyxHQUFHLEtBQUssQ0FBQztJQUM5QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVO1FBQzVCLElBQUksQ0FBQztZQUNILE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLFNBQVMsQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO1lBQzNELE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDakMsTUFBTSxVQUFVLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDO1lBQ3pFLEtBQUssTUFBTSxJQUFJLElBQUksVUFBVSxFQUFFLENBQUM7Z0JBQzlCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDaEMsSUFBSSxXQUFXLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7b0JBQ2pDLHlEQUF5RDtvQkFDekQsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7b0JBQ25ELE1BQU0sR0FBRyxHQUFHLG1CQUFtQixVQUFVLEVBQUUsQ0FBQztvQkFDNUMsSUFBSSxDQUFDO3dCQUNILE1BQU0sU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDO3dCQUNyQixPQUFPLENBQUMsR0FBRyxDQUFDLDZCQUE2QixHQUFHLEVBQUUsQ0FBQyxDQUFDO29CQUNsRCxDQUFDO29CQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7d0JBQ2IsT0FBTyxDQUFDLEtBQUssQ0FBQyxtQ0FBbUMsR0FBRyxFQUFFLEVBQUUsR0FBRyxDQUFDLENBQUM7b0JBQy9ELENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLE9BQU8sQ0FBQyxLQUFLLENBQUMsZ0NBQWdDLEdBQUcsRUFBRSxDQUFDLENBQUM7UUFDdkQsQ0FBQztJQUNILENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksTUFBTSxDQUFDLGNBQWM7UUFDMUIsSUFBSSxDQUFDO1lBQ0gsTUFBTSxNQUFNLEdBQUcsUUFBUSxDQUFDLHNCQUFzQixDQUFDLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDM0QsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNqQyxNQUFNLFVBQVUsR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7WUFDekUsS0FBSyxNQUFNLElBQUksSUFBSSxVQUFVLEVBQUUsQ0FBQztnQkFDOUIsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO2dCQUNoQyxJQUFJLFdBQVcsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztvQkFDakMsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7b0JBQ25ELE1BQU0sR0FBRyxHQUFHLG1CQUFtQixVQUFVLEVBQUUsQ0FBQztvQkFDNUMsSUFBSSxDQUFDO3dCQUNILFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQzt3QkFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLDZCQUE2QixHQUFHLEVBQUUsQ0FBQyxDQUFDO29CQUNsRCxDQUFDO29CQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7d0JBQ2IsT0FBTyxDQUFDLEtBQUssQ0FBQyxtQ0FBbUMsR0FBRyxFQUFFLEVBQUUsR0FBRyxDQUFDLENBQUM7b0JBQy9ELENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLE9BQU8sQ0FBQyxLQUFLLENBQUMsZ0NBQWdDLEdBQUcsRUFBRSxDQUFDLENBQUM7UUFDdkQsQ0FBQztJQUNILENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.iptablesproxy.js","sourceRoot":"","sources":["../ts/classes.iptablesproxy.ts"],"names":[],"mappings":"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"}