English

The domain 'maloo.pages.dev' uses the developer-focused generic top-level domain (.dev); it also runs on subdomain 'maloo'. The registrable portion 'pages' spans 5 characters with two vowels and 3 consonants. Word splitting yields one word: pages. Median word length comes out to 5 characters. No strong language cues emerged from the frequency lists.

html/77/ad/77ad21b8-0eae-469e-b5fe-07afd1d1f0ac.html.gz

05f8085364acdf081f0fa78d88f338540b9416fa37b9876145f49a84ab20c5cd

viewport

Abuse Team

CloudFlare, Inc.

pages.dev

Cloudflare Abuse Contact

MNT-CLOUDFLARE

Cloudflare Technical Contact

CLOUDFLARENET-EU


        // ---------- CONFIG ----------
        const TOKEN_WORKER = 'https://malooprices.monyephoyn.workers.dev'; // pricing worker
        const OBFUSCATION_WORKER = 'https://maloo.monyephoyn.workers.dev/'; // replace with your actual obfuscation worker URL

        // Free quota constants
        const MAX_FREE_USES = 2;
        const COOLDOWN_MS = 3 * 60 * 60 * 1000; // 3 hours

        // ---------- DOM ----------
        const usernameInput = document.getElementById('usernameInput');
        const setUserBtn = document.getElementById('setUserBtn');
        const userMsg = document.getElementById('userMsg');
        const usesLeftSpan = document.getElementById('usesLeft');
        const timerMsg = document.getElementById('timerMessage');
        const obfBtn = document.getElementById('obfBtn');
        const inputEl = document.getElementById('inputCode');
        const outputContainer = document.getElementById('outputContainer');
        const copyBtn = document.getElementById('copyBtn');
        const downloadBtn = document.getElementById('downloadBtn');
        const errorMsg = document.getElementById('errorMsg');

        let lastObfuscatedCode = null;
        let currentUserId = null;  // resolved Roblox user ID, if set

        // ---------- FREE QUOTA (localStorage) ----------
        function getFreeQuota() {
            const data = {
                uses: parseInt(localStorage.getItem('malo_free_uses') || MAX_FREE_USES),
                lastReset: parseInt(localStorage.getItem('malo_free_reset') || Date.now()),
            };
            // Cooldown reset
            const now = Date.now();
            if (now - data.lastReset >= COOLDOWN_MS) {
                data.uses = MAX_FREE_USES;
                data.lastReset = now;
                saveFreeQuota(data.uses, data.lastReset);
            }
            return data;
        }

        function saveFreeQuota(uses, lastReset) {
            localStorage.setItem('malo_free_uses', uses);
            localStorage.setItem('malo_free_reset', lastReset);
        }

        function consumeFreeUse() {
            const q = getFreeQuota();
            if (q.uses <= 0) return false;
            q.uses--;
            saveFreeQuota(q.uses, q.lastReset);
            return true;
        }

        function getTimeLeft() {
            const q = getFreeQuota();
            if (q.uses > 0) return 0;
            return COOLDOWN_MS - (Date.now() - q.lastReset);
        }

        function updateFreeQuotaUI() {
            const q = getFreeQuota();
            usesLeftSpan.textContent = q.uses;
            if (q.uses === 0) {
                const left = getTimeLeft();
                if (left > 0) {
                    timerMsg.textContent = `Resets in ${formatTime(left)}`;
                } else {
                    timerMsg.textContent = '';
                    // Should have reset; force reload
                    q.uses = MAX_FREE_USES;
                    q.lastReset = Date.now();
                    saveFreeQuota(q.uses, q.lastReset);
                    usesLeftSpan.textContent = q.uses;
                }
            } else {
                timerMsg.textContent = '';
            }
        }

        function formatTime(ms) {
            const sec = Math.floor(ms / 1000);
            const h = Math.floor(sec / 3600);
            const m = Math.floor((sec % 3600) / 60);
            const s = sec % 60;
            return `${h}h ${m}m ${s}s`;
        }

        // ---------- USER / TOKEN SYSTEM ----------
        async function resolveUserId(username) {
            const res = await fetch(`${TOKEN_WORKER}`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ action: 'resolve-user', query: username })
            });
            const data = await res.json();
            return data.userId || null;
        }

        async function checkTokenBalance(userId) {
            const res = await fetch(`${TOKEN_WORKER}`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ action: 'get-tokens', userId })
            });
            return await res.json();
        }

        async function consumeToken(userId) {
            const res = await fetch(`${TOKEN_WORKER}`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ action: 'consume-token', userId })
            });
            return await res.json();
        }

        // Set user
        setUserBtn.addEventListener('click', async () => {
            const name = usernameInput.value.trim();
            if (!name) {
                userMsg.textContent = 'Enter a username.';
                return;
            }
            userMsg.textContent = 'Resolving...';
            const uid = await resolveUserId(name);
            if (uid) {
                currentUserId = uid;
                localStorage.setItem('malo_user_id', uid);
                localStorage.setItem('malo_username', name);
                userMsg.textContent = `✅ Logged as ${name}. Tokens will be used if available.`;
                updateFreeQuotaUI(); // may change if unlimited
                checkTokenBalance(uid).then(data => {
                    if (data.unlimited) {
                        userMsg.textContent = `✅ Unlimited – no limits.`;
                    } else if (data.tokens > 0) {
                        userMsg.textContent = `✅ ${data.tokens} tokens available.`;
                    }
                });
            } else {
                userMsg.textContent = 'User not found.';
            }
        });

        // Load saved user
        (function loadSavedUser() {
            const savedId = localStorage.getItem('malo_user_id');
            const savedName = localStorage.getItem('malo_username');
            if (savedId && savedName) {
                currentUserId = parseInt(savedId);
                usernameInput.value = savedName;
                userMsg.textContent = `👤 ${savedName} (tokens active)`;
            }
        })();

        // ---------- OBFUSCATION FLOW ----------
        async function handleObfuscate() {
            const code = inputEl.value.trim();
            if (!code) {
                errorMsg.textContent = 'Paste some code first.';
                return;
            }

            // Determine if we can use token
            let canObfuscate = false;
            let usedFree = false;
            let usedToken = false;

            if (currentUserId) {
                const bal = await checkTokenBalance(currentUserId);
                if (bal.unlimited) {
                    canObfuscate = true; // no consumption needed
                } else if (bal.tokens > 0) {
                    const consumeRes = await consumeToken(currentUserId);
                    if (consumeRes.success) {
                        canObfuscate = true;
                        usedToken = true;
                    } else {
                        errorMsg.textContent = consumeRes.message || 'Token consumption failed.';
                        return;
                    }
                }
            }

            if (!canObfuscate) {
                // Fallback to free quota
                if (consumeFreeUse()) {
                    canObfuscate = true;
                    usedFree = true;
                } else {
                    const left = getTimeLeft();
                    if (left > 0) {
                        errorMsg.textContent = `No free uses. Wait ${formatTime(left)}.`;
                    } else {
                        errorMsg.textContent = 'No uses left.';
                    }
                    return;
                }
            }

            // Proceed with obfuscation
            obfBtn.disabled = true;
            errorMsg.textContent = '';
            outputContainer.textContent = 'Obfuscating...';
            copyBtn.disabled = true;
            downloadBtn.disabled = true;

            try {
                const res = await fetch(OBFUSCATION_WORKER, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ code })
                });
                if (!res.ok) {
                    const err = await res.text();
                    throw new Error(err);
                }
                const data = await res.json();
                const obfuscated = data.obfuscated || data.result;
                const header = '--[[ MaloObf | https://discord.gg/jTbY6G6Vh3 --]] ';
                const finalOutput = obfuscated.startsWith('--[[ MaloObf') ? obfuscated : header + obfuscated;
                outputContainer.textContent = finalOutput;
                lastObfuscatedCode = finalOutput;
                copyBtn.disabled = false;
                downloadBtn.disabled = false;
                errorMsg.textContent = '';
            } catch (e) {
                outputContainer.textContent = 'Error: ' + e.message;
                errorMsg.textContent = 'Obfuscation failed.';
            } finally {
                obfBtn.disabled = false;
                updateFreeQuotaUI();
                // If we used token, update display
                if (currentUserId && !usedFree) {
                    const bal = await checkTokenBalance(currentUserId);
                    if (bal.unlimited) {
                        userMsg.textContent = '✅ Unlimited – used.';
                    } else {
                        userMsg.textContent = `✅ ${bal.tokens} tokens left.`;
                    }
                }
            }
        }

        // Copy & download helpers
        copyBtn.addEventListener('click', () => {
            if (!lastObfuscatedCode) return;
            navigator.clipboard.writeText(lastObfuscatedCode).then(() => {
                copyBtn.textContent = '✅ Copied!';
                setTimeout(() => copyBtn.textContent = '📋 Copy', 2000);
            });
        });
        downloadBtn.addEventListener('click', () => {
            if (!lastObfuscatedCode) return;
            const blob = new Blob([lastObfuscatedCode], { type: 'text/plain' });
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = 'obfuscated.lua';
            a.click();
            URL.revokeObjectURL(url);
        });

        obfBtn.addEventListener('click', handleObfuscate);
        inputEl.addEventListener('input', () => { errorMsg.textContent = ''; });

        // Periodic UI update
        setInterval(updateFreeQuotaUI, 1000);
        updateFreeQuotaUI();
    

Requests	IP Address	Location	AS Autonomous System
3	188.114.97.3	United States	AS13335Cloudflare, Inc.
3	1	-	-

Security Scan Report: maloo.pages.dev

Summary

AI Security Verdict

Low Risk

Risk Factors

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

Detected Technologies3

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