news media journalism

cryptocurrency blockchain

technology software

entertainment media

government public service

Danish

The domain 'hypper-1sapxt7duw.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'hypper-1sapxt7duw'. The second-level label 'edgeone' is 7 characters long split between 4 vowels and 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/a1/7d/a17d08b4-0f6e-4eaa-8819-ed94939e6194.html.gz

4c5ef147e48622f8131f54e6878f9913ef3f447c08c5d37111b2081ecdd2aebc

ff0bd133ea71ca5742844efcd6f4ea60aead4b5592827c0e755805a3ef56bcc6

de88fbd7d65b7de34e1a3dcaf1d2a387a66acef88b19e29dda1ad139faed27c9

d861591ff8adb48832df8bc7fdd4257bcdcba8ab4d2802d87b6148d52102af0f

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

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

html/a1/7d/a17d08b4-0f6e-4eaa-8819-ed94939e6194_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://hypper-1sapxt7duw.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
4	151.101.193.229	United States	AS54113Fastly, Inc.
3	43.152.26.58	Singapore	AS139341ACE
7	2	-	-

Security Scan Report: hypper-1sapxt7duw.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