<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Advanced System Info</title>
  <style>
    body {
      margin: 0;
      font-family: Arial, sans-serif;
      color: white;
      overflow: hidden;
    }

    #video-background {
      position: fixed;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      object-fit: cover;
      z-index: -1;
    }

    .info-container {
      position: absolute;
      top: 50%;
      left: 50%;
      transform: translate(-50%, -50%);
      text-align: left;
      background-color: rgba(0, 0, 0, 0.7);
      padding: 20px;
      border-radius: 10px;
      box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
      max-width: 600px;
      overflow-y: auto;
      max-height: 80%;
    }

    .info-header {
      font-size: 28px;
      font-weight: bold;
      margin-bottom: 20px;
      text-align: center;
    }

    .info-content {
      font-size: 14px;
      line-height: 1.6;
      white-space: pre-wrap;
    }
  </style>
</head>
<body>
  <!-- Video Background -->
  <video id="video-background" autoplay loop muted>
    <source src="https://www.dropbox.com/scl/fi/9bml0q5vy5f0s3p0ftlsu/ssstik.io_1735071150979.mp4?rlkey=plyexp4x3ucl7nofdvo4hfc85&dl=1" type="video/mp4">
    Your browser does not support the video tag.
  </video>

  <!-- Info Container -->
  <div class="info-container">
    <div class="info-header">Advanced System Info</div>
    <div class="info-content" id="info-content">Fetching data...</div>
  </div>

  <script>
    async function fetchData() {
      const infoContent = document.getElementById("info-content");

      const [
        systemInfo,
        gpuInfo,
        batteryInfo,
        locationInfo,
        weatherInfo,
        ipDetails,
        diskUsage,
        networkInfo,
        userPermissions,
        browserExtensions,
        systemFonts,
        clipboardAccess,
        cpuPerformance,
        memoryUsage,
        networkTraffic,
        firewallLogs,
        malwareDetection,
        userActivityLogs,
        softwareAnalytics,
        systemMetrics,
        storageHealth,
        vpnProxyStatus,
        cryptocurrencyPrices,
        benchmarks,
        processMonitoring,
        databaseAnalytics,
        securityBreaches
      ] = await Promise.all([
        getSystemInfo(),
        getGPUInfo(),
        getBatteryStatus(),
        getLocation(),
        getWeather(),
        getPublicIP(),
        getDiskUsage(),
        getNetworkInfo(),
        getUserPermissions(),
        getBrowserExtensions(),
        getSystemFonts(),
        getClipboardAccess(),
        getCPUPerformance(),
        getMemoryUsage(),
        getNetworkTraffic(),
        getFirewallLogs(),
        getMalwareDetection(),
        getUserActivityLogs(),
        getSoftwareAnalytics(),
        getSystemMetrics(),
        getStorageHealth(),
        getVPNProxyStatus(),
        getCryptocurrencyPrices(),
        getBenchmarks(),
        getProcessMonitoring(),
        getDatabaseAnalytics(),
        getSecurityBreaches()
      ]);

      const infoText = `
Operating System: ${systemInfo.platform}
Browser: ${systemInfo.userAgent}
CPU Cores: ${systemInfo.cpuCores}
Memory: ${systemInfo.memory}
GPU: ${gpuInfo.renderer}

Battery Level: ${batteryInfo.level} (${batteryInfo.chargingStatus})
Charging Cycles: ${batteryInfo.chargingCycles}

Public IP: ${ipDetails.ip} (${ipDetails.location})
Location: ${locationInfo.latitude}, ${locationInfo.longitude} (${locationInfo.city})
Timezone: ${locationInfo.timezone}

Disk Usage: ${diskUsage.total} GB Total, ${diskUsage.used} GB Used

Network Info: 
  Type: ${networkInfo.type}
  IPv4 Supported: ${networkInfo.ipv4}
  IPv6 Supported: ${networkInfo.ipv6}

User Permissions: ${userPermissions.cookies}, ${userPermissions.camera}, ${userPermissions.microphone}, etc.

Installed Extensions: ${browserExtensions.join(", ")}
System Fonts: ${systemFonts.join(", ")}

Clipboard Access: ${clipboardAccess.enabled}

CPU Performance: ${cpuPerformance.performanceScore}
Memory Usage: ${memoryUsage.used} GB / ${memoryUsage.total} GB

Network Traffic: ${networkTraffic.upload} Uploaded, ${networkTraffic.download} Downloaded

Firewall Logs: ${firewallLogs.length} Entries

Malware Detection: ${malwareDetection.status}

User Activity Logs: ${userActivityLogs.length} Events

Software Analytics: ${softwareAnalytics.installedApplications.length} Installed Applications

System Metrics: 
  CPU Frequency: ${systemMetrics.cpuFrequency} GHz
  CPU Temperature: ${systemMetrics.cpuTemperature} °C
  CPU Load: ${systemMetrics.cpuLoad} %

Storage Health: ${storageHealth.status}
VPN/Proxy Status: ${vpnProxyStatus.active ? "Active" : "Inactive"}

Cryptocurrency Prices: 
  Bitcoin: ${cryptocurrencyPrices.BTC}
  Ethereum: ${cryptocurrencyPrices.ETH}

Benchmarks: 
  Storage Speed: ${benchmarks.storageSpeed}
  Network Speed: ${benchmarks.networkSpeed}

Running Processes: ${processMonitoring.length} Processes
Database Analytics: ${databaseAnalytics.connections} Connections

Security Breaches: ${securityBreaches.length} Reports
      `;

      infoContent.textContent = infoText;
    }

    // Fetch all the APIs

    async function getSystemInfo() {
      return {
        platform: navigator.platform,
        userAgent: navigator.userAgent,
        cpuCores: navigator.hardwareConcurrency || "N/A",
        memory: navigator.deviceMemory ? `${navigator.deviceMemory} GB` : "N/A"
      };
    }

    async function getGPUInfo() {
      const canvas = document.createElement("canvas");
      const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
      if (!gl) return { renderer: "Not Available" };
      const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
      const renderer = debugInfo
        ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
        : "Unknown Renderer";
      return { renderer };
    }

    async function getBatteryStatus() {
      if (navigator.getBattery) {
        const battery = await navigator.getBattery();
        return {
          level: `${(battery.level * 100).toFixed(0)}%`,
          chargingStatus: battery.charging ? "Charging" : "Not Charging",
          chargingCycles: battery.chargingCycles || "N/A"
        };
      }
      return { level: "N/A", chargingStatus: "Battery info not available." };
    }

    async function getPublicIP() {
      try {
        const response = await fetch("https://ipapi.co/json/");
        const data = await response.json();
        return {
          ip: data.ip || "N/A",
          location: `${data.city}, ${data.region}, ${data.country_name}` || "N/A"
        };
      } catch {
        return { ip: "N/A", location: "N/A" };
      }
    }

    async function getLocation() {
      return new Promise((resolve) => {
        if (navigator.geolocation) {
          navigator.geolocation.getCurrentPosition(async (position) => {
            const { latitude, longitude } = position.coords;
            const city = await reverseGeocode(latitude, longitude);
            const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
            resolve({ latitude, longitude, city, timezone });
          });
        } else {
          resolve({ latitude: "N/A", longitude: "N/A", city: "Geolocation not supported.", timezone: "N/A" });
        }
      });
    }

    async function reverseGeocode(latitude, longitude) {
      try {
        const response = await fetch(
          `https://api.opencagedata.com/geocode/v1/json?q=${latitude}+${longitude}&key=YOUR_API_KEY`
        );
        const data = await response.json();
        return data.results[0]?.formatted || "Unknown City";
      } catch {
        return "Unknown City";
      }
    }

    async function getWeather() {
      try {
        const response = await fetch("https://api.open-meteo.com/v1/forecast?latitude=35&longitude=139&current_weather=true");
        const data = await response.json();
        const weather = data.current_weather;
        return {
          temperature: weather.temperature || "N/A",
          description: weather.weathercode || "N/A"
        };
      } catch {
        return { temperature: "N/A", description: "N/A" };
      }
    }

    async function getDiskUsage() {
      try {
        const response = await fetch("https://api.diskusage.io/info");
        const data = await response.json();
        return {
          total: data.total || "N/A",
          used: data.used || "N/A"
        };
      } catch {
        return { total: "N/A", used: "N/A" };
      }
    }

    async function getNetworkInfo() {
      return {
        type: navigator.connection ? navigator.connection.effectiveType : "Unknown",
        ipv4: navigator.connection ? navigator.connection.type.includes('4') : false,
        ipv6: navigator.connection ? navigator.connection.type.includes('6') : false
      };
    }

    async function getUserPermissions() {
      return {
        cookies: navigator.cookieEnabled ? "Enabled" : "Disabled",
        camera: navigator.mediaDevices && navigator.mediaDevices.getUserMedia ? "Granted" : "Denied",
        microphone: navigator.mediaDevices && navigator.mediaDevices.getUserMedia ? "Granted" : "Denied",
        geolocation: navigator.geolocation ? "Granted" : "Denied"
      };
    }

    async function getBrowserExtensions() {
      return new Promise((resolve) => {
        if (typeof chrome !== "undefined") {
          chrome.management.getAll((extensions) => {
            resolve(extensions.map(ext => ext.name));
          });
        } else {
          resolve(["Browser extensions not available."]);
        }
      });
    }

    async function getSystemFonts() {
      const fonts = await fetch("https://www.googleapis.com/webfonts/v1/webfonts?key=YOUR_GOOGLE_API_KEY")
        .then(res => res.json())
        .then(data => data.items.map(font => font.family));
      return fonts;
    }

    async function getClipboardAccess() {
      return {
        enabled: navigator.clipboard ? "Granted" : "Denied"
      };
    }

    async function getCPUPerformance() {
      return fetch("https://api.cpu.info/performance")
        .then(res => res.json())
        .then(data => ({ performanceScore: data.score }));
    }

    async function getMemoryUsage() {
      return fetch("https://api.memory.info/usage")
        .then(res => res.json())
        .then(data => ({
          used: data.used,
          total: data.total
        }));
    }

    async function getNetworkTraffic() {
      return fetch("https://api.network.info/traffic")
        .then(res => res.json())
        .then(data => ({
          upload: data.upload,
          download: data.download
        }));
    }

    async function getFirewallLogs() {
      return fetch("https://api.firewall.logs")
        .then(res => res.json())
        .then(data => ({ length: data.logs.length }));
    }

    async function getMalwareDetection() {
      return fetch("https://api.malware.detection")
        .then(res => res.json())
        .then(data => ({ status: data.status }));
    }

    async function getUserActivityLogs() {
      return fetch("https://api.activity.logs")
        .then(res => res.json())
        .then(data => ({ length: data.events.length }));
    }

    async function getSoftwareAnalytics() {
      return fetch("https://api.software.analytics")
        .then(res => res.json())
        .then(data => ({ installedApplications: data.applications }));
    }

    async function getSystemMetrics() {
      return fetch("https://api.system.metrics")
        .then(res => res.json())
        .then(data => ({
          cpuFrequency: data.cpuFrequency,
          cpuTemperature: data.cpuTemperature,
          cpuLoad: data.cpuLoad
        }));
    }

    async function getStorageHealth() {
      return fetch("https://api.storage.health")
        .then(res => res.json())
        .then(data => ({ status: data.status }));
    }

    async function getVPNProxyStatus() {
      return fetch("https://api.vpn.proxy.status")
        .then(res => res.json())
        .then(data => ({ active: data.active }));
    }

    async function getCryptocurrencyPrices() {
      return fetch("https://api.cryptocurrency.prices")
        .then(res => res.json())
        .then(data => ({
          BTC: data.BTC,
          ETH: data.ETH
        }));
    }

    async function getBenchmarks() {
      return fetch("https://api.benchmarks.performance")
        .then(res => res.json())
        .then(data => ({
          storageSpeed: data.storageSpeed,
          networkSpeed: data.networkSpeed
        }));
    }

    async function getProcessMonitoring() {
      return fetch("https://api.process.monitoring")
        .then(res => res.json())
        .then(data => ({ length: data.processes.length }));
    }

    async function getDatabaseAnalytics() {
      return fetch("https://api.database.analytics")
        .then(res => res.json())
        .then(data => ({ connections: data.connections }));
    }

    async function getSecurityBreaches() {
      return fetch("https://api.security.breaches")
        .then(res => res.json())
        .then(data => ({ length: data.breaches.length }));
    }

    // Update data every 5 seconds
    fetchData();
    setInterval(fetchData, 5000);
  </script>
</body>
</html>
