English

The domain 'pongpower-2pccv8s5xf.edgeone.dev' uses the developer-focused generic top-level domain (.dev), featuring subdomain 'pongpower-2pccv8s5xf'. Its registrable label 'edgeone' stretches across 7 characters containing four vowels alongside 3 consonants. Word splitting yields two words: edge, one. Median word length is 3.5 characters. No strong language cues emerged from the frequency lists.

html/94/cc/94cc2297-4893-41b3-a419-8238595c5065.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

0da43e54cd0389a6f9ec1f822de09ce2b26d727279105b12e68eba9f189973c2

3e723c26f8a9ac73df8756d37ba9dcfbe9c3c675b38b1492d194ce05b58896dd

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

html/94/cc/94cc2297-4893-41b3-a419-8238595c5065_nodriver.html.gz

Pong Power — Easy

Prudence Malinki

MarkMonitor Inc.

edgeone.dev

IRT-SG-ACE

ACE administrator

ACE-SG


// ─── SPACE BACKGROUND ─────────────────────────────────────
(function() {
    const bg = document.getElementById('space-bg');
    const bx = bg.getContext('2d');
    let W, H;

    // Pixel-star clusters — retro feel
    const STAR_COUNT = 380;
    const NEBULA_COUNT = 6;

    let stars = [];
    let nebulae = [];
    let scanlineOffset = 0;
    let t = 0;

    function resize() {
        W = bg.width  = window.innerWidth;
        H = bg.height = window.innerHeight;
        init();
    }

    function rand(a, b) { return a + Math.random() * (b - a); }
    function randInt(a, b) { return Math.floor(rand(a, b + 1)); }

    function init() {
        stars = [];
        nebulae = [];

        // Stars — mix of tiny pixel dots and slightly larger ones
        for (let i = 0; i < STAR_COUNT; i++) {
            const size = Math.random() < 0.75 ? 1 : (Math.random() < 0.6 ? 2 : 3);
            const colors = [
                '#ffffff', '#ccddff', '#aaccff', '#ffeebb',
                '#0DFF72', '#0DC2FF', '#FF0D72', '#C938FF'
            ];
            // Mostly white/cool, rare neon
            const colorPool = Math.random() < 0.72
                ? ['#ffffff', '#ddddff', '#bbccff', '#ffeedd']
                : colors;
            stars.push({
                x: rand(0, W),
                y: rand(0, H),
                size,
                color: colorPool[randInt(0, colorPool.length - 1)],
                // Blink params
                blinkSpeed: rand(0.4, 2.2),
                blinkPhase: rand(0, Math.PI * 2),
                blinkAmp:   rand(0.35, 1.0),   // how much brightness varies
                baseBright: rand(0.45, 1.0),
                // Slow drift
                driftX: rand(-0.015, 0.015),
                driftY: rand(-0.008, 0.008),
            });
        }

        // Subtle nebula blobs — blurry pixel-art style
        const nebulaColors = [
            ['#0DC2FF', '#0DFF72'],  // cyan → green
            ['#C938FF', '#0DC2FF'],  // purple → cyan
            ['#FF0D72', '#C938FF'],  // pink → purple
            ['#0DFF72', '#FFE138'],  // green → yellow
        ];
        for (let i = 0; i < NEBULA_COUNT; i++) {
            const pair = nebulaColors[i % nebulaColors.length];
            nebulae.push({
                x: rand(0.05, 0.95) * W,
                y: rand(0.05, 0.95) * H,
                rx: rand(80, 220),
                ry: rand(50, 140),
                angle: rand(0, Math.PI),
                c1: pair[0],
                c2: pair[1],
                alpha: rand(0.07, 0.18),
                pulseSpeed: rand(0.2, 0.6),
                pulsePhase: rand(0, Math.PI * 2),
            });
        }
    }

    let elapsed = 0;
    let lastTime = null;

    function drawFrame(now) {
        if (!lastTime) lastTime = now;
        const dt = Math.min(now - lastTime, 50);
        lastTime = now;
        elapsed += dt;
        t = elapsed * 0.001;

        bx.clearRect(0, 0, W, H);

        // ── Nebulae (behind stars) ──
        nebulae.forEach(n => {
            const pulse = 1 + 0.14 * Math.sin(t * n.pulseSpeed + n.pulsePhase);
            const a = n.alpha * pulse;
            bx.save();
            bx.translate(n.x, n.y);
            bx.rotate(n.angle);
            const g = bx.createRadialGradient(0, 0, 0, 0, 0, n.rx * pulse);
            g.addColorStop(0,   hexAlpha(n.c1, a));
            g.addColorStop(0.5, hexAlpha(n.c2, a * 0.5));
            g.addColorStop(1,   hexAlpha(n.c2, 0));
            bx.scale(1, n.ry / n.rx);
            bx.beginPath();
            bx.arc(0, 0, n.rx * pulse, 0, Math.PI * 2);
            bx.fillStyle = g;
            bx.fill();
            bx.restore();
        });

        // ── Stars ──
        stars.forEach(s => {
            // Drift
            s.x = (s.x + s.driftX + W) % W;
            s.y = (s.y + s.driftY + H) % H;

            // Blink
            const blink = s.baseBright + s.blinkAmp * Math.sin(t * s.blinkSpeed + s.blinkPhase);
            const alpha  = Math.max(0, Math.min(1, blink));

            bx.globalAlpha = alpha;

            if (s.size === 1) {
                // Single pixel — crisp retro look
                bx.fillStyle = s.color;
                bx.fillRect(Math.round(s.x), Math.round(s.y), 1, 1);
            } else if (s.size === 2) {
                bx.fillStyle = s.color;
                bx.fillRect(Math.round(s.x), Math.round(s.y), 2, 2);
            } else {
                // Bright star: 2×2 + cross arms (pixel-art star shape)
                const sx = Math.round(s.x), sy = Math.round(s.y);
                bx.fillStyle = s.color;
                bx.fillRect(sx, sy, 3, 3);
                // Faint cross
                bx.globalAlpha = alpha * 0.4;
                bx.fillRect(sx - 2, sy + 1, 2, 1); // left arm
                bx.fillRect(sx + 3, sy + 1, 2, 1); // right arm
                bx.fillRect(sx + 1, sy - 2, 1, 2); // top arm
                bx.fillRect(sx + 1, sy + 3, 1, 2); // bottom arm
            }
        });
        bx.globalAlpha = 1;

        // ── Scanlines — very subtle CRT retro feel ──
        scanlineOffset = (scanlineOffset + 0.4) % 4;
        for (let y = Math.round(scanlineOffset); y < H; y += 4) {
            bx.fillStyle = 'rgba(0,0,0,0.12)';
            bx.fillRect(0, y, W, 1);
        }

        requestAnimationFrame(drawFrame);
    }

    function hexAlpha(hex, a) {
        // Convert #rrggbb to rgba(r,g,b,a)
        const r = parseInt(hex.slice(1, 3), 16);
        const g = parseInt(hex.slice(3, 5), 16);
        const b = parseInt(hex.slice(5, 7), 16);
        return `rgba(${r},${g},${b},${a})`;
    }

    window.addEventListener('resize', resize);
    resize();
    requestAnimationFrame(drawFrame);
})();


✅ Low Risk - https://pongpower-2pccv8s5xf.edgeone.dev/pong_power_space_24.html

Requests	IP Address	Location	AS Autonomous System
2	142.250.186.67	United States	AS15169Google LLC
1	43.174.246.29	Singapore	AS139341ACE
1	142.251.14.95	United States	AS15169Google LLC
4	3	-	-

Security Scan Report: pongpower-2pccv8s5xf.edgeone.dev

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History