Domain beta.cwa.acs.amazon.dev
United States
AMAZON-02
Software information

AmazonS3 AmazonS3

tcp/443

CloudFront

tcp/80

  • Open service 18.66.192.46:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 8c1abfbb8460bed752668233d296dba8.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: HyQv_kf0KHG-6aSkOmOBjxRA6hKNv_kZecW2bLOK3F0XXOd7wp97NA==
Age: 35645
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:d800:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 ae6c2eb8d653982f5df6a91a4b14b518.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: 0qGEnR7ZQ1gXtIJCwU2yQLisN_dV1g7Dx8HQ5RAf8FCTPgPLwJ2sRw==
Age: 35645
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:5600:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 0f14828b89630f6555c6372e13fc999a.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: LTEH19V5UAdZHEis5Yo7ZUpOSLxlMrBj0Xa28gDpgzTkwZJRZqBLbg==
Age: 35645
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.42:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 8c1abfbb8460bed752668233d296dba8.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: idqCxEiPmkMKFU_gTAb5a5Ao4eajfefdNJucnYfBm6ztGJJA9jAqNA==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:e400:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 ae6c2eb8d653982f5df6a91a4b14b518.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: FiX7xJ9O6GAKuTPNZaki8ROUBHEKA7YfnlaB9zjdULf8AUDCi7NXjw==
Age: 35645
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:5600:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:35 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 badff53d2116a4b3d32a2dd1eb918a48.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: Bdl5TgV5JoViMTeRCYosHwB6zd5AdXtUBjtIPoXPifpHSDR-INjOiw==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:aa00:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:35 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 c414bd1a4ce7ace94cbfdfa8efcbe5a6.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: iepIpGR6UQlfWZMe1qAhDJmgt0s5BIBHeySgpZjI6Ma0pD0vGrQYew==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:e00:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 af1bbc213b3a9ee2f125be77ca3609a0.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: Adx7yOkc_figUS-jbY2VrRYNlCxJxRgcGi2QqbIAiHlEK7MoQOWnGg==
Age: 35645
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:aa00:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 c3f546c2f6132a41e608317139aa8faa.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: Er9VVPi9qmhOvrCPvyiPHsTwDcSYpMzHE4cijCGBB50jffYgmr7cgw==
Age: 35644
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:fe00:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 f4c3162878591c5abd76f8ee1f873476.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: GGipWqmVsID7sffS4Rj9wlmg2fHtRENf-1deFJE4qt8yaXyHZJHvzQ==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:fe00:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 77aa8087323921dee0b130bc0589bda8.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: oUiurCERP9x-CvnHcFex0TdpmJ-5-88Ab23_LHsFfbIaI_o_jhJW_A==
Age: 35644
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:d400:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 ae6c2eb8d653982f5df6a91a4b14b518.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: 03kbXT6govu8AaA4k82NuqcfWgObGhiBSEOHUbvYijZ9JE9WSlj-ig==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:6400:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 c414bd1a4ce7ace94cbfdfa8efcbe5a6.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: tUx7He7HYTPrr2auMbrB3ZEmj76LOmSTXXFe-LAjR_FWazH3zQFQGA==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.64:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 32700c539a5f821aadd3624288c4aeb6.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: tyOVJZB7lOMRaK05RRMvS0ddo3i8t2QPyGWs5B0wDKV65XuE9UTEZQ==
Age: 35644
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:e00:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 29473aa9cc185f2a037ec3a7e2ffd74c.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: CLDt5HgnE39wQzcirtNkPd7JPdz_9cx5VX71aaLqOy57OnqPTly9CQ==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.47:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 77aa8087323921dee0b130bc0589bda8.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: Y2nb-Vct-JFVKSZ65QBIOYb551OlwJQ1NGGUWFFf40xDsKKTOgYA0Q==
Age: 35645
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:6400:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 66ce4848bcf993e3c57b596461cd0b82.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: nKKjgEOaWgxMwGQUTXoGqMS6ec4smHhdkA9Booj1QQFeUkijk5PWfA==
Age: 35644
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.64:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 aedc37d054398c84a361f8542a82efea.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: GCb55QBrJsUa_8Dsnrc9NW8lvoOr3ps0dcMSdRgIA1XnfuzXTUlVCg==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.47:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 f4c3162878591c5abd76f8ee1f873476.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: NyyamOEqtULczwkuuxF0UfpA66_lBgj4dv3J9tYQoNXEweje6q8BoA==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.42:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 ec12d3de4ccd821a7e749609dcc62010.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: 1zJnyqvACv1Sz7ZHLAw1fyEjitP_GoijdoAIeQw68BNx21H20bWQ0g==
Age: 35644
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:d400:f:7e8:fc40:93a1:443 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 403 Forbidden
Content-Type: text/html
Content-Length: 13959
Connection: close
Last-Modified: Wed, 07 Jan 2026 03:15:29 GMT
x-amz-server-side-encryption: AES256
x-amz-version-id: Mv4j76PRbO8c4YZXGcU45MgVDt4s05vC
Accept-Ranges: bytes
Server: AmazonS3
Date: Sun, 11 Jan 2026 17:52:31 GMT
ETag: "4c8575e3a51549f224c24223d9f93ace"
X-Cache: Error from cloudfront
Via: 1.1 0f14828b89630f6555c6372e13fc999a.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: yfa3glt4K7TPCEBd8z7er3OcMVJD6hulkHDX3cUIlLnU9j_S0hYGKQ==
Age: 35644
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=47304000; includeSubDomains
Cache-Control: no-cache, no-store


<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript">
        function getParameterInHashByName(parameterName, url) {
            if (!url) {
                url = window.location.href;
            }

            try {
                const urlFull = new URL(url);
                const urlParameters = new URLSearchParams(urlFull.hash.substring(1));
                const parameterValue = urlParameters.get(parameterName);

                if (parameterValue === null) {
                    return null;
                }

                return decodeURIComponent(parameterValue)
            } catch (e) {
                return null;
            }
        }

        function getValidURL(url) {
            try {
                return new URL(url);
            } catch (e) {
                return null;
            }
        }

        function generateRandomBytes() {
            const array = new Uint8Array(8);
            crypto.getRandomValues(array);

            return Array.from(array)
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        async function generateSha384(val) {
            const encoder = new TextEncoder();
            const msgBuffer = encoder.encode(val);
            const hashBuffer = await crypto.subtle.digest('SHA-384', msgBuffer);

            // Convert hash to hex string
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            return hashArray
                .map(b => b.toString(16).padStart(2, '0'))
                .join('');
        }

        /**
         * Function that compares hash values using a constant-time comparison approach.
         *
         * We use a constant time comparison function, as opposed to the equality operator, to protect
         * against timing attacks. The equality operator returns the moment it detects any mismatched
         * character. Attackers use this vulnerability to discover hints about the strings being compared.
         * For example, if I am comparing two passwords and not using a constant time comparison function,
         * I can identify matching characters since execution times vary respectively to where the first
         * difference occurs.
         *
         * We use the XOR (^) and OR (|) operations, since they are CPU-level instructions that execute in
         * constant time and do not involve conditional branching. The XOR operation returns zero when both
         * inputs are identical, otherwise it returns a non-zero value. The OR operation accumulates the
         * XOR operation's results, totaling to zero when every comparison is identical. Using bitwise
         * operations and evaluating every character ensures that attackers cannot gain information about
         * the strings we compare.
         *
         * @see {@link https://cwe.mitre.org/data/definitions/208.html}
         *
         * @param {string} source - Value to hash and compare.
         * @param {string} targetHash - Hash we compare the source hash against.
         * @returns {boolean} True if the hashes match.
         */
        async function validateSha384(source, targetHash) {
            if (!source || !targetHash) {
                return false;
            }

            const sourceHash = await generateSha384(source);
            const maxLength = Math.max(sourceHash.length, targetHash.length);
            let differences = 0;

            for (let i = 0; i < maxLength; i++) {
                const charCodeA = sourceHash.charCodeAt(i) || 0;
                const charCodeB = targetHash.charCodeAt(i) || 0;
                differences |= charCodeA ^ charCodeB;
            }

            return differences === 0;
        }

        /*! js-cookie v3.0.4 | MIT */
        ;
        (function (global, factory) {
            typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                typeof define === 'function' && define.amd ? define(factory) :
                    (global = typeof globalThis !== 'undefined' ? globalThis : global || s
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 18.66.192.46:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 986e79a1f22b8bf29001818ede5df5c8.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: QyR_LjJjC5DtHJj1C5xwgtRFlMk3bdzS9wVqCLuFCnZdA9kxr3qE9g==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:e400:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 c3f546c2f6132a41e608317139aa8faa.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: C7vjKPcYpBJlxPzNBpm4VQI3pwG89dr1YRbIDzs8LtdpdZh_MmZ4kQ==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report

  • Open service 2600:9000:225b:d800:f:7e8:fc40:93a1:80 · beta.cwa.acs.amazon.dev

    2026-01-12 03:46 

    HTTP/1.1 301 Moved Permanently
Server: CloudFront
Date: Mon, 12 Jan 2026 03:46:34 GMT
Content-Type: text/html
Content-Length: 167
Connection: close
Location: https://beta.cwa.acs.amazon.dev/
X-Cache: Redirect from cloudfront
Via: 1.1 c414bd1a4ce7ace94cbfdfa8efcbe5a6.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: MUC50-P1
X-Amz-Cf-Id: _AiSrDhFeM2tbLNmEi3jiV1cD0IRgGyRpHbVWL0QQP0jG-XErxsWvA==
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Cache-Control: no-cache, no-store

Page title: 301 Moved Permanently

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>CloudFront</center>
</body>
</html>
    Found 2026-01-12 by HttpPlugin
    Create report
beta.cwa.acs.amazon.dev
Fingerprint:
d6a8e2c9f9e56b05e83ba7823fc8ef9429763a794ae5b385ccd4dcba1ed6c8fb
CN:
beta.cwa.acs.amazon.dev
Key:
RSA-2048
Issuer:
Amazon RSA 2048 M02
Not before:
2025-02-10 00:00
Not after:
2026-03-12 23:59
Domain summary

beta.cwa.acs.amazon.dev 23

1 recorded
IP summary

18.66.192.46 1 2600:9000:225b:d800:f:7e8:fc40:93a1 1 2600:9000:225b:5600:f:7e8:fc40:93a1 1 18.66.192.42 1 2600:9000:225b:e400:f:7e8:fc40:93a1 1 2600:9000:225b:aa00:f:7e8:fc40:93a1 1 2600:9000:225b:e00:f:7e8:fc40:93a1 1 2600:9000:225b:fe00:f:7e8:fc40:93a1 1 2600:9000:225b:d400:f:7e8:fc40:93a1 1 2600:9000:225b:6400:f:7e8:fc40:93a1 1 18.66.192.64 1 18.66.192.47 1

12 recorded

© 2026 LeakIX v2.0.49
About LeakIX - Credits - Take-down and blacklist requests - Security issues - Terms and conditions - Cookie policy - Legal notice