English

Within the application-focused generic top-level domain (.app), 'caboose-2mkikkm7jl.edgeone.app' is registered, featuring subdomain 'caboose-2mkikkm7jl'. The core label 'edgeone' covers 7 characters split between four vowels and three consonants. Splitting it apart reveals 2 words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/a6/d8/a6d81cfc-8119-48f9-bfab-31339a9a4b88.html.gz

4c5ef147e48622f8131f54e6878f9913ef3f447c08c5d37111b2081ecdd2aebc

ff0bd133ea71ca5742844efcd6f4ea60aead4b5592827c0e755805a3ef56bcc6

de88fbd7d65b7de34e1a3dcaf1d2a387a66acef88b19e29dda1ad139faed27c9

d861591ff8adb48832df8bc7fdd4257bcdcba8ab4d2802d87b6148d52102af0f

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

viewport

html/a6/d8/a6d81cfc-8119-48f9-bfab-31339a9a4b88_nodriver.html.gz

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse Account

Fastly RIR Administrator

Fastly Network Operations

Fastly, Inc.

SKYCA-3


  async function fetchAndCombineZip(binUrls) {
    const responses = await Promise.all(binUrls.map(url => fetch(url)));
    const buffers = await Promise.all(responses.map(res => res.arrayBuffer()));
    let totalLength = buffers.reduce((acc, buf) => acc + buf.byteLength, 0);
    let combined = new Uint8Array(totalLength);
    let offset = 0;
    for (let buf of buffers) {
        combined.set(new Uint8Array(buf), offset);
        offset += buf.byteLength;
    }
    return combined;
}

async function unzipWebpFromExternalBins(binUrls) {
    const blobUrls = {};
    const bytes = await fetchAndCombineZip(binUrls);
    const zip = await JSZip.loadAsync(bytes);
    for (const [filename, file] of Object.entries(zip.files)) {
        if (!file.dir) {
            let mime = '';
            if (filename.endsWith('.js') || filename.endsWith('.mjs')) {
                mime = 'text/javascript';
            } else if (filename.endsWith('.css')) {
                mime = 'text/css';
            } else if (filename.endsWith('.html')) {
                mime = 'text/html';
            } else if (filename.endsWith('.wasm.br')) {
                mime = 'application/wasm';
            } else if (filename.endsWith('.js.br')) {
                mime = 'application/javascript';
            } else if (filename.endsWith('.jpg') || filename.endsWith('.jpeg')) {
                mime = 'image/jpeg';
            }
            const rawBlob = await file.async("blob");
            const blob = mime ? new Blob([rawBlob], { type: mime }) : rawBlob;
            const blobUrl = URL.createObjectURL(blob);
            console.log("Extracted:", filename);
            blobUrls[filename] = blobUrl;
        }
    }
    return blobUrls;
}

let blobUrlss = "";
let binParts = [
  "parts_1.bin",
  "parts_2.bin",
  "parts_3.bin",
  "parts_4.bin",
];

unzipWebpFromExternalBins(binParts).then(blobUrls => {
    blobUrlss = blobUrls;
    const ORIGINAL_CREATE_ELEMENT = document.createElement;
    const ORIGINAL_SET_ATTRIBUTE = Element.prototype.setAttribute;

    document.createElement = function(tagName) {
        const el = ORIGINAL_CREATE_ELEMENT.call(this, tagName);

        if (tagName.toLowerCase() === 'script') {
            Object.defineProperty(el, 'src', {
                set(newSrc) {
                    const filename = extractFilename(newSrc);
                    const replacement = blobUrlss[filename];
                    if (replacement) {
                        ORIGINAL_SET_ATTRIBUTE.call(el, 'src', replacement);
                    } else {
                        ORIGINAL_SET_ATTRIBUTE.call(el, 'src', newSrc);
                    }
                },
                get() {
                    return el.getAttribute('src');
                },
                configurable: true
            });
        }

        return el;
    };

    Element.prototype.setAttribute = function(name, value) {
        if (this.tagName === 'SCRIPT' && name === 'src') {
            const filename = extractFilename(value);
            const replacement = blobUrlss[filename];
            if (replacement) {
                return ORIGINAL_SET_ATTRIBUTE.call(this, name, replacement);
            }
        }
        return ORIGINAL_SET_ATTRIBUTE.call(this, name, value);
    };

    function extractFilename(url) {
        try {
            return new URL(url, location.href).pathname.split('/').pop();
        } catch {
            return url.split('/').pop(); 
        }
    }

    const imageSrcDescriptor = Object.getOwnPropertyDescriptor(Image.prototype, 'src');
    Object.defineProperty(Image.prototype, 'src', {
      set(value) {
        const newURL = rewriteURL(value);
        imageSrcDescriptor.set.call(this, newURL);
      },
      get: imageSrcDescriptor.get,
      configurable: true,
      enumerable: true,
    });

    const scriptSrcDescriptor = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src');
    Object.defineProperty(HTMLScriptElement.prototype, 'src', {
      set(value) {
        const newURL = rewriteURL(value);
        scriptSrcDescriptor.set.call(this, newURL);
      },
      get: scriptSrcDescriptor.get,
      configurable: true,
      enumerable: true,
    });

    const linkHrefDescriptor = Object.getOwnPropertyDescriptor(HTMLLinkElement.prototype, 'href');
    Object.defineProperty(HTMLLinkElement.prototype, 'href', {
      set(value) {
        const newURL = rewriteURL(value);
        linkHrefDescriptor.set.call(this, newURL);
      },
      get: linkHrefDescriptor.get,
      configurable: true,
      enumerable: true,
    });

    const mediaSrcDescriptor = Object.getOwnPropertyDescriptor(HTMLMediaElement.prototype, 'src');
    Object.defineProperty(HTMLMediaElement.prototype, 'src', {
      set(value) {
        const newURL = rewriteURL(value);
        mediaSrcDescriptor.set.call(this, newURL);
      },
      get: mediaSrcDescriptor.get,
      configurable: true,
      enumerable: true,
    });

    // fetch
    const originalFetch = window.fetch;
    window.fetch = function(resource, init) {
      if (typeof resource === "string") {
        resource = rewriteURL(resource);
      } else if (resource instanceof Request) {
        resource = new Request(rewriteURL(resource.url), resource);
      }
      return originalFetch.call(this, resource, init);
    };

    // XMLHttpRequest
    const originalOpen = XMLHttpRequest.prototype.open;
    XMLHttpRequest.prototype.open = function(method, url, ...rest) {
      const newURL = rewriteURL(url);
      return originalOpen.call(this, method, newURL, ...rest);
    };

    const OriginalAudio = window.Audio;
    window.Audio = function(src) {
      const audio = new OriginalAudio();
      if (src) {
        audio.src = rewriteURL(src);
      }
      return audio;
    };
    window.Audio.prototype = OriginalAudio.prototype;

    function rewriteURL(original) {
      var trimmed = original.split("/").pop();
      if (trimmed.includes("?")) trimmed = trimmed.split("?")[0]
      return blobUrlss[trimmed] || original;
    }

    window.addEventListener("load", function () {
      if ("serviceWorker" in navigator) {
        navigator.serviceWorker.register("ServiceWorker.js");
      }
    });

    const canvas = document.querySelector("#unity-canvas");
    const buildUrl = "Build";
    const loaderUrl = buildUrl + "/build.loader-edit3.js";
    const config = {
      dataUrl: buildUrl + "/a2513a5aa7d939d35b7ce57299d8ee17.data.br",
      frameworkUrl: buildUrl + "/64151c8d9473352a0777c93b9711db55.framework.js.br",
      codeUrl: buildUrl + "/7e3da7fb06a6d1a4fe4174ebc1f12c5f.wasm.br",
      streamingAssetsUrl: "StreamingAssets",
      companyName: "Something",
      productName: "Hype",
      productVersion: "6.40"
    };
    
    var gameInstance;
    var script = document.createElement("script");
    script.src = loaderUrl;
    script.onload = () => {
      createUnityInstance(canvas, config, (progress) => {
        
      }).then((unityInstance) => {
        console.log("<do.G> Unity inited");
        gameInstance = unityInstance;
      }).catch((message) => {
        alert(message);
      });
    };
    document.body.appendChild(script);

    function setFocus() {
      window.focus();
      canvas.focus();
    }
    window.addEventListener("touchstart", setFocus);
    window.addEventListener("pointerdown", setFocus);
    window.addEventListener("resize", setFocus);
});
    


function resizeCanvas() {
    const canvas = document.getElementById("unity-canvas");
   
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
    
    canvas.style.width = window.innerWidth + "px";
    canvas.style.height = window.innerHeight + "px";
}


window.addEventListener("load", resizeCanvas);
window.addEventListener("resize", resizeCanvas);


✅ Low Risk - https://caboose-2mkikkm7jl.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
4	104.16.174.226	Singapore	AS54113
3	43.152.26.58	Singapore	AS139341ACE
7	2	-	-

Security Scan Report: caboose-2mkikkm7jl.edgeone.app

Summary

AI Security Verdict

Moderate 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

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