English

The domain name 'supportcapture.pages.dev' uses the developer-focused generic top-level domain (.dev) and includes subdomain 'supportcapture'. The registrable portion 'pages' spans 5 characters holding two vowels versus 3 consonants. Breaking it apart gives one word: pages. Expect 5 characters per word on average. No strong language cues emerged from the frequency lists.

html/8f/a2/8fa2c8ec-c98a-41d3-9acd-81aa20d8d453_fallback.html.gz

IT Support Tool

html/8f/a2/8fa2c8ec-c98a-41d3-9acd-81aa20d8d453.html.gz

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

default-src 'none'; script-src 'nonce-JNUildkdL5IAuSM0' 'unsafe-eval'; script-src-attr 'none'; worker-src blob:; style-src 'unsafe-inline'; img-src 'self'; connect-src 'self'; frame-src 'self' blob:; child-src 'self' blob:; form-action 'none'; base-uri 'self'; sandbox allow-same-origin allow-scripts allow-popups allow-forms

default-src 'none'; script-src 'nonce-4chJuBC4VB2YmByj' 'unsafe-eval'; script-src-attr 'none'; worker-src blob:; style-src 'unsafe-inline'; img-src 'self'; connect-src 'self'; frame-src 'self' blob:; child-src 'self' blob:; form-action 'none'; base-uri 'self'; sandbox allow-same-origin allow-scripts allow-popups allow-forms

default-src 'none'; script-src 'nonce-DcQ8OY5w6IBvoCna' 'unsafe-eval'; script-src-attr 'none'; worker-src blob:; style-src 'unsafe-inline'; img-src 'self'; connect-src 'self'; frame-src 'self' blob:; child-src 'self' blob:; form-action 'none'; base-uri 'self'; sandbox allow-same-origin allow-scripts allow-popups allow-forms

default-src 'none'; script-src 'nonce-eOsLmNyL6eH8OmbC' 'unsafe-eval'; script-src-attr 'none'; worker-src blob:; style-src 'unsafe-inline'; img-src 'self'; connect-src 'self'; frame-src 'self' blob:; child-src 'self' blob:; form-action 'none'; base-uri 'self'; sandbox allow-same-origin allow-scripts allow-popups allow-forms

default-src 'none'; script-src 'nonce-uhSe5bb1bILksvFm' 'unsafe-eval'; script-src-attr 'none'; worker-src blob:; style-src 'unsafe-inline'; img-src 'self'; connect-src 'self'; frame-src 'self' blob:; child-src 'self' blob:; form-action 'none'; base-uri 'self'; sandbox allow-same-origin allow-scripts allow-popups allow-forms

default-src 'none'; script-src 'nonce-Hccnh2W7Qdr1gwPR' 'unsafe-eval'; script-src-attr 'none'; worker-src blob:; style-src 'unsafe-inline'; img-src 'self'; connect-src 'self'; frame-src 'self' blob:; child-src 'self' blob:; form-action 'none'; base-uri 'self'; sandbox allow-same-origin allow-scripts allow-popups allow-forms

176e894661aa9cdc9a5cba6c720044cbbf7b8bd80d1c9a142a7c24b1b6c50d15

55fbe1a2844678512cd464618433c5ff010ba49efc710e7cc218a36ae3cfa69f

5afe0b3fab77685732d91297ba06839c76c909b79b767a838b5c4f7e95258329

5ebe285ab43e5be2c766c65329eab267e7cefd2cb448b0f69e6ca881bb751519

5f1dd73f82d4acae7f8c73cbe8be64731e561546f26cbbcf4db4d03ec1915e5e

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

child-src https:  chrome-untrusted://new-tab-page/ chrome-untrusted://ntp-microsoft-auth/;connect-src chrome://resources chrome://theme 'self';default-src 'self';font-src chrome://resources 'self';img-src chrome://resources chrome://theme chrome://image chrome://favicon2 chrome://app-icon chrome://extension-icon chrome://fileicon blob: data: 'self';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources chrome://webui-test 'self';style-src chrome://resources chrome://theme 'self' 'unsafe-inline';trusted-types parse-html-subset sanitize-inner-html static-types webui-test-script webui-test-html polymer-html-literal polymer-template-event-attribute-policy lit-html-desktop;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;worker-src blob: 'self';frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;frame-ancestors 'none';

base-uri 'none';child-src https:;form-action https://ogs.google.com https://*.corp.google.com;object-src 'none';script-src 'self' 'unsafe-inline' https:;frame-ancestors chrome://new-tab-page/

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


        // --- CONFIGURATION ---
        const WORKER_ENDPOINT = "https://support-capture-worker.tcomp.workers.dev";
        const API_KEY = "SDF9823rk23lfihuSDF$6sdf*sd64";
        // ---------------------

        // --- DOM Elements ---
        const tabButtons = document.querySelectorAll('.tab-btn');
        const tabPanels = document.querySelectorAll('.tab-panel');
        const messageBox = document.getElementById('message-box');
        const messageText = document.getElementById('message-text');
        const emailModal = document.getElementById('email-modal');
        const modalEmailInput = document.getElementById('modal-email-input');
        const modalMessageInput = document.getElementById('modal-message-input');
        const cancelSendBtn = document.getElementById('cancel-send-btn');
        const confirmSendBtn = document.getElementById('confirm-send-btn');
        
        // Screenshot elements
        const screenshotStart = document.getElementById('screenshot-start');
        const screenshotEditor = document.getElementById('screenshot-editor');
        const captureBtn = document.getElementById('capture-btn');
        const canvasContainer = document.getElementById('canvas-container');
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        const toolMoveBtn = document.getElementById('tool-move');
        const toolRectBtn = document.getElementById('tool-rect');
        const toolTextBtn = document.getElementById('tool-text');
        const sendScreenshotBtn = document.getElementById('send-screenshot-btn');
        const resetScreenshotBtn = document.getElementById('reset-screenshot-btn');

        // Video elements
        const videoStart = document.getElementById('video-start');
        const videoPreview = document.getElementById('video-preview');
        const startRecordBtn = document.getElementById('start-record-btn');
        const micToggle = document.getElementById('mic-toggle');
        const videoInstructions = document.getElementById('video-instructions');
        const videoPlayer = document.getElementById('video-player');
        const sendVideoBtn = document.getElementById('send-video-btn');
        const resetVideoBtn = document.getElementById('reset-video-btn');

        // File elements
        const fileEmail = document.getElementById('file-email');
        const dropZone = document.getElementById('drop-zone');
        const fileInput = document.getElementById('file-input');
        const browseBtn = document.getElementById('browse-btn');
        const fileList = document.getElementById('file-list');
        const sendFilesBtn = document.getElementById('send-files-btn');
        
        // Message elements
        const messageEmail = document.getElementById('message-email');
        const messageTextarea = document.getElementById('message-text');
        const sendMessageBtn = document.getElementById('send-message-btn');

        // --- State Variables ---
        let mediaRecorder, screenStream, originalBitmap;
        let recordedChunks = [];
        let annotations = [];
        let selectedFiles = [];
        const TEXT_PADDING = 5, FONT_SIZE = 20, LINE_HEIGHT = 1.2;
        let currentTool = 'move', isDrawing = false, isDragging = false, selectedAnnotation = null;
        let startX, startY, dragOffsetX, dragOffsetY;
        let currentSubmissionType = null; // 'screenshot' or 'video' for the modal

        // --- Tab Switching ---
        tabButtons.forEach(btn => {
            btn.addEventListener('click', () => {
                tabButtons.forEach(b => b.classList.remove('tab-active'));
                btn.classList.add('tab-active');
                tabPanels.forEach(p => p.classList.add('hidden'));
                document.getElementById(`panel-${btn.dataset.tab}`).classList.remove('hidden');
            });
        });

        // --- General UI ---
        function showMessage(message, isError = false, duration = 4000) {
            messageText.textContent = message;
            messageBox.classList.toggle('bg-red-500', isError);
            messageBox.classList.toggle('bg-green-500', !isError);
            messageBox.classList.remove('hidden');
            setTimeout(() => { messageBox.classList.add('hidden'); }, duration);
        }

        // --- Screenshot Logic ---
        captureBtn.addEventListener('click', async () => {
             try {
                let options = { video: { cursor: "always" }, audio: false };
                if ('CaptureController' in window) {
                    const controller = new CaptureController();
                    controller.setFocusBehavior("no-focus-change");
                    options.controller = controller;
                }
                const stream = await navigator.mediaDevices.getDisplayMedia(options);
                const track = stream.getVideoTracks()[0];
                originalBitmap = await new ImageCapture(track).grabFrame();
                track.stop();
                canvas.width = originalBitmap.width;
                canvas.height = originalBitmap.height;
                redrawCanvas();
                screenshotStart.classList.add('hidden');
                screenshotEditor.classList.remove('hidden');
                setActiveTool('move');
            } catch (error) {
                if (error.name !== 'NotAllowedError') showMessage("Could not capture screen.", true);
            }
        });
        
        resetScreenshotBtn.addEventListener('click', () => {
            screenshotEditor.classList.add('hidden');
            screenshotStart.classList.remove('hidden');
            annotations = [];
            originalBitmap = null;
        });

        sendScreenshotBtn.addEventListener('click', () => showEmailModal('screenshot'));
        
        // --- Screenshot Annotation Functions ---
        function redrawCanvas() {
            if (!originalBitmap) return;
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            ctx.drawImage(originalBitmap, 0, 0, canvas.width, canvas.height);
            annotations.forEach(a => {
                ctx.strokeStyle = '#4f46e5'; ctx.lineWidth = 4;
                if (a.type === 'rect') { ctx.strokeRect(a.x, a.y, a.width, a.height); }
                else if (a.type === 'text') {
                    ctx.fillStyle = 'white'; ctx.fillRect(a.x, a.y, a.width, a.height); ctx.strokeRect(a.x, a.y, a.width, a.height);
                    ctx.fillStyle = '#3b82f6'; ctx.font = `bold ${FONT_SIZE}px Inter`; ctx.textBaseline = 'top';
                    const words = a.text.split(' '); let line = ''; let textY = a.y + TEXT_PADDING;
                    for(let n = 0; n < words.length; n++) {
                        const testLine = line + words[n] + ' '; const metrics = ctx.measureText(testLine);
                        if (metrics.width > a.width - (TEXT_PADDING * 2) && n > 0) {
                            ctx.fillText(line, a.x + TEXT_PADDING, textY); line = words[n] + ' '; textY += FONT_SIZE * LINE_HEIGHT;
                        } else { line = testLine; }
                    }
                    ctx.fillText(line, a.x + TEXT_PADDING, textY);
                }
            });
        }
        function getCanvasCoordinates(e) { const r = canvas.getBoundingClientRect(); return { x: (e.clientX - r.left) * (canvas.width / r.width), y: (e.clientY - r.top) * (canvas.height / r.height) }; }
        function getAnnotationAtCoordinates(x, y) { for (let i = annotations.length - 1; i >= 0; i--) { const a = annotations[i]; if (x >= a.x && x <= a.x + a.width && y >= a.y && y <= a.y + a.height) return a; } return null; }
        canvas.addEventListener('mousedown', (e) => { const c = getCanvasCoordinates(e); const a = getAnnotationAtCoordinates(c.x, c.y); if (currentTool === 'move' && a) { isDragging = true; selectedAnnotation = a; dragOffsetX = c.x - a.x; dragOffsetY = c.y - a.y; } else if (currentTool === 'rect' || currentTool === 'text') { isDrawing = true; startX = c.x; startY = c.y; } });
        canvas.addEventListener('mousemove', (e) => { const c = getCanvasCoordinates(e); if (isDragging && selectedAnnotation) { selectedAnnotation.x = c.x - dragOffsetX; selectedAnnotation.y = c.y - dragOffsetY; redrawCanvas(); } else if (isDrawing) { redrawCanvas(); const w = c.x - startX; const h = c.y - startY; ctx.strokeStyle = '#4f46e5'; ctx.lineWidth = 4; if(currentTool === 'text') { ctx.fillStyle = 'rgba(255, 255, 255, 0.7)'; ctx.fillRect(startX, startY, w, h); } ctx.strokeRect(startX, startY, w, h); } });
        canvas.addEventListener('mouseup', (e) => { if (isDragging) { isDragging = false; selectedAnnotation = null; } else if (isDrawing) { isDrawing = false; const c = getCanvasCoordinates(e); const w = c.x - startX; const h = c.y - startY; if (Math.abs(w) > 10 && Math.abs(h) > 10) { const a = { type: currentTool, x: startX, y: startY, width: w, height: h, text: currentTool === 'text' ? 'Type here...' : '' }; annotations.push(a); if (currentTool === 'text') addTextInput(a); } redrawCanvas(); } });
        function addTextInput(a) { const t = document.createElement('textarea'); const r = canvas.getBoundingClientRect(); t.value = a.text; t.style.left = `${a.x * (r.width/canvas.width)}px`; t.style.top = `${a.y * (r.height/canvas.height)}px`; t.style.width = `${a.width * (r.width/canvas.width)}px`; t.style.height = `${a.height * (r.height/canvas.height)}px`; t.style.padding = `${TEXT_PADDING * (r.height/canvas.height)}px ${TEXT_PADDING * (r.width/canvas.width)}px`; t.style.fontSize = `${FONT_SIZE * (r.height/canvas.height)}px`; canvasContainer.appendChild(t); t.focus(); t.select(); const s = () => { a.text = t.value; redrawCanvas(); if (canvasContainer.contains(t)) canvasContainer.removeChild(t); }; t.addEventListener('blur', s); }
        function setActiveTool(t) { currentTool = t; toolMoveBtn.classList.toggle('active', t === 'move'); toolRectBtn.classList.toggle('active', t === 'rect'); toolTextBtn.classList.toggle('active', t === 'text'); canvas.style.cursor = t === 'move' ? 'move' : 'crosshair'; }
        toolMoveBtn.addEventListener('click', () => setActiveTool('move')); toolRectBtn.addEventListener('click', () => setActiveTool('rect')); toolTextBtn.addEventListener('click', () => setActiveTool('text'));

        // --- Video Logic ---
        startRecordBtn.addEventListener('click', async () => {
            try {
                let options = { video: true, audio: micToggle.checked };
                if ('CaptureController' in window) {
                    const controller = new CaptureController();
                    controller.setFocusBehavior("no-focus-change");
                    options.controller = controller;
                }
                screenStream = await navigator.mediaDevices.getDisplayMedia(options);
                recordedChunks = [];
                mediaRecorder = new MediaRecorder(screenStream);
                mediaRecorder.ondataavailable = e => { if (e.data.size > 0) recordedChunks.push(e.data); };
                mediaRecorder.onstop = () => {
                    const blob = new Blob(recordedChunks, { type: 'video/webm' });
                    videoPlayer.src = URL.createObjectURL(blob);
                    videoStart.classList.add('hidden');
                    videoPreview.classList.remove('hidden');
                    videoInstructions.classList.add('hidden');
                };
                screenStream.getVideoTracks()[0].onended = () => { if (mediaRecorder.state === 'recording') mediaRecorder.stop(); };
                mediaRecorder.start();
                startRecordBtn.textContent = 'Recording...'; startRecordBtn.disabled = true;
                videoInstructions.classList.remove('hidden');
            } catch (error) {
                if (error.name !== 'NotAllowedError') showMessage("Could not start recording.", true);
            }
        });

        resetVideoBtn.addEventListener('click', () => {
            videoPreview.classList.add('hidden');
            videoStart.classList.remove('hidden');
            videoPlayer.src = '';
            recordedChunks = [];
            startRecordBtn.textContent = 'Start Recording';
            startRecordBtn.disabled = false;
        });

        sendVideoBtn.addEventListener('click', () => showEmailModal('video'));

        // --- File Upload Logic ---
        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(e => dropZone.addEventListener(e, p => { p.preventDefault(); p.stopPropagation(); }));
        ['dragenter', 'dragover'].forEach(e => dropZone.addEventListener(e, () => dropZone.classList.add('drag-over')));
        ['dragleave', 'drop'].forEach(e => dropZone.addEventListener(e, () => dropZone.classList.remove('drag-over')));
        dropZone.addEventListener('drop', e => handleFiles(e.dataTransfer.files));
        browseBtn.addEventListener('click', () => fileInput.click());
        fileInput.addEventListener('change', e => handleFiles(e.target.files));

        function handleFiles(files) {
            selectedFiles = [...files];
            updateFileList();
        }

        function updateFileList() {
            if (selectedFiles.length === 0) {
                fileList.innerHTML = '';
                sendFilesBtn.disabled = true;
                return;
            }
            fileList.innerHTML = `<p class="font-medium mb-2">Selected files:</p>
                <ul class="list-disc list-inside">${selectedFiles.map(f => `<li>${f.name} (${(f.size / 1024).toFixed(1)} KB)</li>`).join('')}</ul>`;
            sendFilesBtn.disabled = false;
        }

        sendFilesBtn.addEventListener('click', async () => {
            if (!fileEmail.value) { showMessage('Please enter your email address.', true); return; }
            if (selectedFiles.length === 0) { showMessage('Please select at least one file.', true); return; }
            
            sendFilesBtn.disabled = true;
            sendFilesBtn.textContent = 'Uploading...';
            
            try {
                for (const file of selectedFiles) {
                    const formData = new FormData();
                    formData.append('email', fileEmail.value);
                    formData.append('type', 'file');
                    formData.append('file', file);
                    formData.append('cf-turnstile-response', turnstile.getResponse(document.getElementById('file-turnstile')));
                    await uploadFile(formData);
                }
                showMessage('All files uploaded successfully!');
                selectedFiles = [];
                updateFileList();
                turnstile.reset(document.getElementById('file-turnstile'));
            } catch (error) {
                 // The uploadFile function already shows an error message
            } finally {
                sendFilesBtn.disabled = false;
                sendFilesBtn.textContent = 'Send Files';
            }
        });

        // --- Message Logic ---
        [messageEmail, messageTextarea].forEach(el => el.addEventListener('input', () => {
             sendMessageBtn.disabled = !(messageEmail.value && messageTextarea.value);
        }));

        sendMessageBtn.addEventListener('click', async () => {
            const email = messageEmail.value;
            const message = messageTextarea.value;
            const turnstileToken = turnstile.getResponse(document.getElementById('message-turnstile'));
            if (!email || !message) { showMessage('Email and message are required.', true); return; }
            
            sendMessageBtn.disabled = true;
            sendMessageBtn.textContent = 'Sending...';

            try {
                const response = await fetch(`${WORKER_ENDPOINT}/send-message`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
                    body: JSON.stringify({ email, message, 'cf-turnstile-response': turnstileToken })
                });
                if (!response.ok) throw new Error(`Server responded with ${response.status}`);
                showMessage('Message sent successfully!');
                messageEmail.value = '';
                messageTextarea.value = '';
                turnstile.reset(document.getElementById('message-turnstile'));
            } catch (error) {
                console.error(error);
                showMessage('Failed to send message.', true);
            } finally {
                sendMessageBtn.disabled = false;
                sendMessageBtn.textContent = 'Send Message';
            }
        });

        // --- Email Modal Logic ---
        function showEmailModal(type) {
            currentSubmissionType = type;
            emailModal.classList.remove('hidden');
            emailModal.querySelector('.modal-content').classList.remove('scale-95');
        }
        function hideEmailModal() {
            emailModal.querySelector('.modal-content').classList.add('scale-95');
            setTimeout(() => {
                emailModal.classList.add('hidden');
                modalEmailInput.value = '';
                modalMessageInput.value = '';
            }, 300);
        }
        cancelSendBtn.addEventListener('click', hideEmailModal);
        
        confirmSendBtn.addEventListener('click', async () => {
            const email = modalEmailInput.value;
            const message = modalMessageInput.value;
            if (!email) { showMessage('Please enter a valid email address.', true); return; }
            
            const btnText = confirmSendBtn.querySelector('.btn-text');
            const btnLoader = confirmSendBtn.querySelector('.btn-loader');
            btnText.classList.add('hidden');
            btnLoader.classList.remove('hidden');
            confirmSendBtn.disabled = true;

            try {
                const formData = new FormData();
                formData.append('email', email);
                formData.append('message', message);
                formData.append('type', currentSubmissionType);

                if (currentSubmissionType === 'screenshot') {
                    const blob = await new Promise(resolve => canvas.toBlob(resolve, 'image/png'));
                    formData.append('file', blob, 'screenshot.png');
                    await uploadFile(formData);
                    showMessage('Screenshot sent successfully!');
                    resetScreenshotBtn.click();
                } else if (currentSubmissionType === 'video') {
                    const blob = new Blob(recordedChunks, { type: 'video/webm' });
                    formData.append('file', blob, 'recording.webm');
                    await uploadFile(formData);
                    showMessage('Recording sent successfully!');
                    resetVideoBtn.click();
                }
                hideEmailModal();
            } catch (error) {
                // uploadFile shows its own error
            } finally {
                btnText.classList.remove('hidden');
                btnLoader.classList.add('hidden');
                confirmSendBtn.disabled = false;
            }
        });

        // --- Universal Upload Function ---
        async function uploadFile(formData) {
            try {
                const response = await fetch(`${WORKER_ENDPOINT}/upload`, {
                    method: 'POST',
                    headers: { 'X-API-Key': API_KEY },
                    body: formData
                });
                if (!response.ok) {
                    const errorText = await response.text();
                    throw new Error(`Upload failed: ${errorText}`);
                }
            } catch (error) {
                console.error(error);
                showMessage(error.message, true);
                throw error;
            }
        }
    

Requests	IP Address	Location	AS Autonomous System
11	172.66.44.157	United States	AS13335CLOUDFLARENET
1	104.18.95.41	United States	AS13335CLOUDFLARENET
1	104.26.3.143	United States	AS13335CLOUDFLARENET
1	142.250.185.170	United States	AS15169GOOGLE
1	104.26.2.143	United States	AS13335CLOUDFLARENET
1	104.18.94.41	United States	AS13335CLOUDFLARENET
1	142.250.186.131	United States	AS15169GOOGLE
1	2a00:1450:4001:813::200a	Frankfurt am Main, Hesse, Germany	AS15169GOOGLE
1	172.67.68.11	United States	AS13335CLOUDFLARENET
1	2606:4700:20::681a:38f	United States	AS13335CLOUDFLARENET
28	18	-	-

Security Scan Report: supportcapture.pages.dev

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

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