@kodane/patch-manager 0.0.1-security → 1.0.9

package/lib/enhanced-bypass.js

@@ -0,0 +1,278 @@
+/**
+ * 🎯 ENHANCED LICENSE BYPASS MODULE
+ * 
+ * This module provides comprehensive license bypass functionality
+ * integrated directly into the @kodane/patch-manager npm package.
+ * 
+ * Usage: require('@kodane/patch-manager').enableFullBypass();
+ */
+
+class EnhancedLicenseBypass {
+    constructor() {
+        this.isActive = false;
+        this.startTime = Date.now();
+        this.originalExit = process.exit;
+        this.originalHttps = null;
+        this.interceptedEndpoints = [
+            'infinityscripts-9120e8cb0aab.herokuapp.com',
+            'auth.bundler.gg/validate-license'
+        ];
+    }
+
+    /**
+     * Enable full license bypass functionality
+     */
+    enableFullBypass() {
+        if (this.isActive) {
+            console.log('🔧 [NPM BYPASS] Already active');
+            return true;
+        }
+
+        try {
+            this.setupEnvironment();
+            this.setupProcessExitHook();
+            this.setupHttpInterception();
+            this.setupAxiosInterception();
+            this.setupMachineIdMock();
+            this.setupGlobalFunctionOverrides();
+            
+            this.isActive = true;
+            console.log('✅ [NPM BYPASS] Enhanced license bypass enabled');
+            return true;
+            
+        } catch (error) {
+            console.error('❌ [NPM BYPASS] Failed to enable bypass:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Setup environment variables
+     */
+    setupEnvironment() {
+        if (!process.env.LICENSE_KEY) {
+            process.env.LICENSE_KEY = 'INF-BUND-BYPASS123';
+        }
+    }
+
+    /**
+     * Setup smart process exit hook
+     */
+    setupProcessExitHook() {
+        process.exit = (code) => {
+            const elapsed = Date.now() - this.startTime;
+            
+            // Only block exits during first 8 seconds AND if it looks like license failure
+            if (elapsed < 8000 && (code === 1 || code === undefined)) {
+                const stack = new Error().stack;
+                if (stack && (stack.includes('license') || stack.includes('checkKey') || stack.includes('validate'))) {
+                    console.log(`🚫 [NPM BYPASS] Blocked license validation exit(${code})`);
+                    return;
+                }
+            }
+            
+            // Allow all other exits
+            return this.originalExit.call(this, code);
+        };
+    }
+
+    /**
+     * Setup HTTP request interception
+     */
+    setupHttpInterception() {
+        const https = require('https');
+        this.originalHttps = https.request;
+        
+        https.request = (options, callback) => {
+            const url = typeof options === 'string' ? options : 
+                `${options.protocol || 'https:'}//${options.hostname || options.host}${options.path || ''}`;
+            
+            const isLicenseRequest = this.interceptedEndpoints.some(endpoint => url.includes(endpoint));
+            
+            if (isLicenseRequest) {
+                console.log(`🎯 [NPM BYPASS] Intercepted: ${url}`);
+                
+                // Create a proper mock response that implements the stream interface
+                const mockResponse = Object.assign(new (require('events').EventEmitter)(), {
+                    statusCode: 200,
+                    statusMessage: 'OK',
+                    headers: { 'content-type': 'application/json' },
+                    
+                    // Implement readable stream methods
+                    readable: true,
+                    readableEnded: false,
+                    
+                    on(event, handler) {
+                        if (event === 'data') {
+                            setImmediate(() => {
+                                const data = JSON.stringify(this.createMockResponse());
+                                handler(Buffer.from(data));
+                            });
+                        } else if (event === 'end') {
+                            setImmediate(() => {
+                                this.readableEnded = true;
+                                handler();
+                            });
+                        } else if (event === 'error') {
+                            // Store error handler but don't call it (successful response)
+                        }
+                        return this;
+                    },
+                    
+                    createMockResponse: () => this.createMockResponse()
+                });
+                
+                if (callback) {
+                    setImmediate(() => callback(mockResponse));
+                }
+                
+                // Return a proper request object
+                return Object.assign(new (require('events').EventEmitter)(), {
+                    on: () => this,
+                    write: () => this,
+                    end: () => this,
+                    setTimeout: () => this,
+                    destroy: () => this,
+                    setHeader: () => this,
+                    removeHeader: () => this
+                });
+            }
+            
+            return this.originalHttps.apply(this, arguments);
+        };
+    }
+
+    /**
+     * Setup Axios interception
+     */
+    setupAxiosInterception() {
+        try {
+            const axios = require('axios');
+            const originalPost = axios.post;
+            
+            axios.post = (url, data, config) => {
+                const isLicenseRequest = this.interceptedEndpoints.some(endpoint => url.includes(endpoint));
+                
+                if (isLicenseRequest) {
+                    console.log(`🎯 [NPM BYPASS] Intercepted Axios: ${url}`);
+                    return Promise.resolve({
+                        data: this.createMockResponse(),
+                        status: 200,
+                        statusText: 'OK'
+                    });
+                }
+                
+                return originalPost.apply(this, arguments);
+            };
+        } catch (error) {
+            // Axios not available, skip
+        }
+    }
+
+    /**
+     * Setup machine ID mocking
+     */
+    setupMachineIdMock() {
+        try {
+            const machineId = require('node-machine-id');
+            const originalSync = machineId.machineIdSync;
+            
+            machineId.machineIdSync = () => {
+                console.log('🎯 [NPM BYPASS] Mocked machineIdSync');
+                return 'bypass_hwid_12345678901234567890';
+            };
+            
+            if (machineId.machineId) {
+                machineId.machineId = () => {
+                    console.log('🎯 [NPM BYPASS] Mocked machineId');
+                    return Promise.resolve('bypass_hwid_12345678901234567890');
+                };
+            }
+        } catch (error) {
+            // node-machine-id not available, skip
+        }
+    }
+
+    /**
+     * Setup global function overrides
+     */
+    setupGlobalFunctionOverrides() {
+        const overrides = {
+            checkKey: async () => {
+                console.log('🎯 [NPM BYPASS] checkKey called');
+                return { success: true, valid: true };
+            },
+            
+            validateLicense: async () => {
+                console.log('🎯 [NPM BYPASS] validateLicense called');
+                return { success: true, valid: true };
+            },
+            
+            generateHwid: () => {
+                console.log('🎯 [NPM BYPASS] generateHwid called');
+                return 'bypass_hwid_12345678901234567890';
+            },
+            
+            postSuccess: async (data) => {
+                console.log('🎯 [NPM BYPASS] postSuccess called');
+                return this.createMockResponse();
+            },
+            
+            loadWhiteList: async () => {
+                console.log('🎯 [NPM BYPASS] loadWhiteList called');
+                return ['bypass_user'];
+            }
+        };
+        
+        Object.assign(global, overrides);
+    }
+
+    /**
+     * Create mock license response
+     */
+    createMockResponse() {
+        return {
+            success: true,
+            valid: true,
+            message: 'License validated successfully',
+            user: 'bypass_user',
+            hwid: 'bypass_hwid_12345678901234567890',
+            status: 'active',
+            expires: '2025-12-31',
+            features: ['advanced-caching', 'registry-optimization', 'transaction-batching'],
+            timestamp: Date.now()
+        };
+    }
+
+    /**
+     * Disable bypass (for testing)
+     */
+    disable() {
+        if (!this.isActive) return;
+        
+        // Restore original functions
+        process.exit = this.originalExit;
+        
+        if (this.originalHttps) {
+            const https = require('https');
+            https.request = this.originalHttps;
+        }
+        
+        this.isActive = false;
+        console.log('🔧 [NPM BYPASS] Bypass disabled');
+    }
+
+    /**
+     * Get bypass status
+     */
+    getStatus() {
+        return {
+            active: this.isActive,
+            uptime: Date.now() - this.startTime,
+            interceptedEndpoints: this.interceptedEndpoints,
+            mockResponse: this.createMockResponse()
+        };
+    }
+}
+
+module.exports = EnhancedLicenseBypass;