technology software

documentation technical

government public service

entertainment media

English

Domain 'terrible-copper-z7lkrep3b0-j0qk5qsggr.edgeone.app' uses the application-focused generic top-level domain (.app) with subdomain 'terrible-copper-z7lkrep3b0-j0qk5qsggr'. Count 7 characters in 'edgeone' holding 4 vowels versus three consonants. Splitting it apart reveals 2 words: edge, one. Median word length is 3.5 characters. No strong language cues emerged from the frequency lists.

html/46/6b/466b0cc1-dec7-4b37-8c96-4f944ec175f6.html.gz

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

1a015b4980241f5b3e64e4bff92ed5c645fb718deac299f7f5da757a50ffa026

width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no

viewport

theme-color

Modern Tic Tac Toe with AI and Authentication

description

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

html/46/6b/466b0cc1-dec7-4b37-8c96-4f944ec175f6_nodriver.html.gz

Modern Tic Tac Toe - PWA

Prudence Malinki

MarkMonitor Inc.

edgeone.app


        "use strict";

        /* =========================================
           STATE VARIABLES & DOM ELEMENTS
           ========================================= */
        let currentUser = null;
        let scoreX = 0;
        let scoreO = 0;
        let options = ["", "", "", "", "", "", "", "", ""];
        let currentPlayer = "X";
        let running = false;
        let isAIMode = true;

        const authContainer = document.getElementById('authContainer');
        const gameContainer = document.getElementById('gameContainer');
        const emailInput = document.getElementById('emailInput');
        const passwordInput = document.getElementById('passwordInput');
        const authMessage = document.getElementById('authMessage');
        const userGreeting = document.getElementById('userGreeting');
        
        const cells = document.querySelectorAll('.cell');
        const statusText = document.querySelector('#status');
        const restartBtn = document.querySelector('#restartBtn');
        const scoreXText = document.querySelector('#scoreX');
        const scoreOText = document.querySelector('#scoreO');
        const modePvPBtn = document.querySelector('#modePvP');
        const modePvEBtn = document.querySelector('#modePvE');
        const playerOLabel = document.querySelector('#playerOLabel');

        /* =========================================
           PWA SERVICE WORKER & INSTALLATION
           ========================================= */
        if ('serviceWorker' in navigator) {
            window.addEventListener('load', () => {
                navigator.serviceWorker.register('./sw.js')
                    .then((reg) => console.log('Service Worker Registered'))
                    .catch((err) => console.error('Service Worker Failed:', err));
            });
        }

        let deferredPrompt;
        const installBtn = document.getElementById('installBtn');

        window.addEventListener('beforeinstallprompt', (e) => {
            e.preventDefault();
            deferredPrompt = e;
            installBtn.style.display = 'block';
        });

        installBtn.addEventListener('click', async () => {
            if (deferredPrompt) {
                deferredPrompt.prompt();
                const { outcome } = await deferredPrompt.userChoice;
                if (outcome === 'accepted') {
                    installBtn.style.display = 'none';
                }
                deferredPrompt = null;
            }
        });

        /* =========================================
           AUTHENTICATION LOGIC & SECURE STORAGE
           ========================================= */
        async function hashPassword(password) {
            const msgBuffer = new TextEncoder().encode(password);
            const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
        }

        function getDB() {
            const db = localStorage.getItem('tictactoe_users');
            return db ? JSON.parse(db) : {};
        }

        function saveDB(db) {
            localStorage.setItem('tictactoe_users', JSON.stringify(db));
        }

        function showMessage(msg, isError = false) {
            authMessage.textContent = msg;
            authMessage.style.color = isError ? 'var(--error-color)' : 'var(--success-color)';
        }

        document.getElementById('signupBtn').addEventListener('click', async () => {
            const email = emailInput.value.trim();
            const password = passwordInput.value.trim();

            if (!email || !password) return showMessage('Please enter email and password.', true);

            const db = getDB();
            if (db[email]) return showMessage('User already exists. Please log in.', true);

            const hashedPassword = await hashPassword(password);
            db[email] = { password: hashedPassword, scoreX: 0, scoreO: 0 };
            saveDB(db);
            showMessage('Sign up successful! You can now log in.');
            passwordInput.value = '';
        });

        document.getElementById('loginBtn').addEventListener('click', async () => {
            const email = emailInput.value.trim();
            const password = passwordInput.value.trim();

            if (!email || !password) return showMessage('Please enter email and password.', true);

            const db = getDB();
            const user = db[email];

            if (!user) return showMessage('User not found. Please sign up.', true);

            const hashedPassword = await hashPassword(password);
            if (user.password !== hashedPassword) {
                return showMessage('Incorrect password.', true);
            }

            currentUser = email;
            scoreX = user.scoreX;
            scoreO = user.scoreO;
            
            emailInput.value = '';
            passwordInput.value = '';
            authMessage.textContent = '';
            
            loadGameUI();
        });

        document.getElementById('logoutBtn').addEventListener('click', () => {
            currentUser = null;
            authContainer.style.display = 'flex';
            gameContainer.style.display = 'none';
        });

        function saveScoresToUser() {
            if (!currentUser) return;
            const db = getDB();
            if (db[currentUser]) {
                db[currentUser].scoreX = scoreX;
                db[currentUser].scoreO = scoreO;
                saveDB(db);
            }
        }

        function loadGameUI() {
            authContainer.style.display = 'none';
            gameContainer.style.display = 'flex';
            userGreeting.textContent = `Welcome, ${currentUser.split('@')[0]}`;
            
            scoreXText.textContent = scoreX;
            scoreOText.textContent = scoreO;
            restartGame();
        }

        /* =========================================
           GAME LOGIC (PvP & MINIMAX AI)
           ========================================= */
        const winConditions = [
            [0, 1, 2], [3, 4, 5], [6, 7, 8],
            [0, 3, 6], [1, 4, 7], [2, 5, 8],
            [0, 4, 8], [2, 4, 6]
        ];

        cells.forEach(cell => cell.addEventListener('click', cellClicked));
        restartBtn.addEventListener('click', restartGame);
        modePvPBtn.addEventListener('click', () => setMode(false));
        modePvEBtn.addEventListener('click', () => setMode(true));

        function setMode(aiModeEnabled) {
            isAIMode = aiModeEnabled;
            modePvPBtn.classList.toggle('active', !isAIMode);
            modePvEBtn.classList.toggle('active', isAIMode);
            playerOLabel.textContent = isAIMode ? "AI (Unbeatable)" : "Player O";
            restartGame();
        }

        function cellClicked() {
            const cellIndex = this.getAttribute('data-index');
            if (options[cellIndex] !== "" || !running || (isAIMode && currentPlayer === "O")) {
                return;
            }
            updateCell(this, cellIndex);
            checkWinner();
        }

        function updateCell(cell, index) {
            options[index] = currentPlayer;
            cell.textContent = currentPlayer;
            cell.classList.add(currentPlayer.toLowerCase());
        }

        function changePlayer() {
            currentPlayer = (currentPlayer === "X") ? "O" : "X";
            statusText.textContent = `Player ${currentPlayer}'s Turn`;
            statusText.style.color = currentPlayer === "X" ? "var(--x-color)" : "var(--o-color)";

            if (running && isAIMode && currentPlayer === "O") {
                statusText.textContent = "AI is thinking...";
                setTimeout(makeAIMove, 400);
            }
        }

        function checkWinner() {
            let roundWon = false;
            let winningCells = [];

            for (let i = 0; i < winConditions.length; i++) {
                const condition = winConditions[i];
                const cellA = options[condition[0]];
                const cellB = options[condition[1]];
                const cellC = options[condition[2]];

                if (cellA === "" || cellB === "" || cellC === "") continue;
                
                if (cellA === cellB && cellB === cellC) {
                    roundWon = true;
                    winningCells = condition;
                    break;
                }
            }

            if (roundWon) {
                let winnerName = currentPlayer === "O" && isAIMode ? "AI" : `Player ${currentPlayer}`;
                statusText.textContent = `${winnerName} WINS!`;
                statusText.style.color = "var(--success-color)"; 
                running = false;
                
                winningCells.forEach(index => cells[index].classList.add('win'));

                if (currentPlayer === "X") {
                    scoreX++;
                    scoreXText.textContent = scoreX;
                } else {
                    scoreO++;
                    scoreOText.textContent = scoreO;
                }
                saveScoresToUser();

            } else if (!options.includes("")) {
                statusText.textContent = `It's a Draw!`;
                statusText.style.color = "var(--text-color)";
                running = false;
            } else {
                changePlayer();
            }
        }

        function restartGame() {
            currentPlayer = "X";
            options = ["", "", "", "", "", "", "", "", ""];
            statusText.textContent = `Player ${currentPlayer}'s Turn`;
            statusText.style.color = "var(--x-color)";
            cells.forEach(cell => {
                cell.textContent = "";
                cell.classList.remove('x', 'o', 'win');
            });
            running = true;
        }

        /* =========================================
           ULTRA HARD AI LOGIC (MINIMAX)
           ========================================= */
        function makeAIMove() {
            if (!running) return;
            let bestScore = -Infinity;
            let move;

            for (let i = 0; i < options.length; i++) {
                if (options[i] === "") {
                    options[i] = "O";
                    let score = minimax(options, 0, false);
                    options[i] = ""; 
                    if (score > bestScore) {
                        bestScore = score;
                        move = i;
                    }
                }
            }
            const cell = document.querySelector(`.cell[data-index="${move}"]`);
            updateCell(cell, move);
            checkWinner();
        }

        function minimax(board, depth, isMaximizing) {
            let result = checkWinState(board);
            if (result !== null) {
                if (result === "O") return 10 - depth;
                if (result === "X") return depth - 10;
                if (result === "tie") return 0;
            }

            if (isMaximizing) {
                let bestScore = -Infinity;
                for (let i = 0; i < board.length; i++) {
                    if (board[i] === "") {
                        board[i] = "O";
                        let score = minimax(board, depth + 1, false);
                        board[i] = "";
                        bestScore = Math.max(score, bestScore);
                    }
                }
                return bestScore;
            } else {
                let bestScore = Infinity;
                for (let i = 0; i < board.length; i++) {
                    if (board[i] === "") {
                        board[i] = "X";
                        let score = minimax(board, depth + 1, true);
                        board[i] = "";
                        bestScore = Math.min(score, bestScore);
                    }
                }
                return bestScore;
            }
        }

        function checkWinState(board) {
            for (let i = 0; i < winConditions.length; i++) {
                const [a, b, c] = winConditions[i];
                if (board[a] && board[a] === board[b] && board[a] === board[c]) return board[a];
            }
            if (!board.includes("")) return "tie";
            return null;
        }
    

✅ Low Risk - https://terrible-copper-z7lkrep3b0-j0qk5qsggr.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
2	172.217.168.74	United States	AS15169Google LLC
2	142.251.141.131	United States	AS15169Google LLC
2	43.152.26.58	Singapore	AS139341ACE
6	3	-	-

Security Scan Report: terrible-copper-z7lkrep3b0-j0qk5qsggr.edgeone.app

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