technology software

cryptocurrency blockchain

corporate

Chinese

Within the developer-focused generic top-level domain (.dev), 'cloudflare-aog.pages.dev' is registered; it also runs on subdomain 'cloudflare-aog'. The core label 'pages' covers 5 characters with two vowels and 3 consonants. Tokenizing the label suggests one word: pages. No strong language cues emerged from the frequency lists.

html/c2/9d/c29d67e9-b9c8-4af2-82fc-921e58ffee8a.html.gz

2b4dfbf635ac1573ef0df3d8ca1945d821e09573916064bdd22ae8bfb368274a

⚡
在线 CDN vs 源站对比测速工具
Online CDN vs Origin Speed Comparison Tool

24 MB
本站优选节点24MB超级噪点文件能反映优选节点真实速度
推荐 / Recommended

24 MB
源站默认节点24MB超级噪点文件能反映源站节点真实速度
源站 / Origin

24 MB
Cloudflare 官方
Official
全球测速 / Global

500 MB
Cloudflare 官方
Official
全球测速 / Global

1 GB
Cloudflare 官方
Official
全球测速 / Global

viewport

Cloudflare 优选测速是一款免费的网络速度测试工具，使用 24MB 不可压缩文件真实测试优选节点到您的网络速度。支持 CDN vs 源站对比测速，全面评估网络性能。

description

Cloudflare 测速, 网络速度测试, CDN 测速, 源站测速, 优选节点, 网速测试, 带宽测试, 延迟测试, CDN vs 源站, 网络性能测试

keywords

author

robots

Cloudflare 优选测速 - 免费网络速度测试工具

使用 24MB 不可压缩文件真实测试优选节点到您的网络速度，支持 CDN vs 源站对比测速。

twitter:card

twitter:title

twitter:description

html/c2/9d/c29d67e9-b9c8-4af2-82fc-921e58ffee8a_nodriver.html.gz

Cloudflare 优选测速 - 免费网络速度测试工具 | 24MB 真实测速

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


    // 测速主程序
    let currentXhr = null;
    let globalSpeedHistory = [];
    let globalYMax = 10;
    
    // 绘制速度曲线图函数 - 带鼠标交互
    function updateSpeedChart(history) {
      const canvas = document.getElementById('speedChart');
      if (!canvas) return;
      const ctx = canvas.getContext('2d');
      const width = canvas.width;
      const height = canvas.height;
      
      // 保存全局数据用于鼠标交互
      globalSpeedHistory = history;
      
      // 清空画布
      ctx.clearRect(0, 0, width, height);
      
      if (history.length < 1) return;
      
      // Y轴范围
      const speeds = history.map(h => h.speed);
      const maxSpeed = Math.max(...speeds);
      const yMax = Math.max(10, maxSpeed * 1.2);
      globalYMax = yMax;
      
      // 绘制网格线
      ctx.strokeStyle = 'rgba(255, 255, 255, 0.1)';
      ctx.lineWidth = 1;
      for (let i = 0; i <= 4; i++) {
        const y = height - (i / 4) * height;
        ctx.beginPath();
        ctx.moveTo(0, y);
        ctx.lineTo(width, y);
        ctx.stroke();
      }
      
      // 绘制曲线 - 简单直接
      ctx.strokeStyle = '#00ff88';
      ctx.lineWidth = 2;
      ctx.beginPath();
      
      // 按国际标准，自然从第一个点开始
      history.forEach((point, index) => {
        const x = (point.percent / 100) * width;
        const y = height - (point.speed / yMax) * height;
        if (index === 0) {
          ctx.moveTo(x, y);
        } else {
          ctx.lineTo(x, y);
        }
      });
      
      ctx.stroke();
      
      // 渐变填充
      if (history.length > 0) {
        const lastPoint = history[history.length - 1];
        const lastX = (lastPoint.percent / 100) * width;
        ctx.lineTo(lastX, height);
        ctx.lineTo(0, height);
        ctx.closePath();
        const gradient = ctx.createLinearGradient(0, 0, 0, height);
        gradient.addColorStop(0, 'rgba(0, 255, 136, 0.2)');
        gradient.addColorStop(1, 'rgba(0, 255, 136, 0)');
        ctx.fillStyle = gradient;
        ctx.fill();
      }
    }
    
    // 鼠标交互 - 显示速度
    function setupChartHover() {
      const canvas = document.getElementById('speedChart');
      if (!canvas) return;
      
      function drawHoverPoint(x, y, speed) {
        const ctx = canvas.getContext('2d');
        const width = canvas.width;
        const height = canvas.height;
        
        // 重新绘制图表
        updateSpeedChart(globalSpeedHistory);
        
        // 绘制垂直参考线
        ctx.strokeStyle = 'rgba(0, 255, 136, 0.5)';
        ctx.lineWidth = 1;
        ctx.beginPath();
        ctx.moveTo(x, 0);
        ctx.lineTo(x, height);
        ctx.stroke();
        
        // 绘制磁吸小圆点
        ctx.fillStyle = '#00ff88';
        ctx.beginPath();
        ctx.arc(x, y, 6, 0, Math.PI * 2);
        ctx.fill();
        
        // 绘制外圈
        ctx.strokeStyle = '#00ff88';
        ctx.lineWidth = 2;
        ctx.beginPath();
        ctx.arc(x, y, 10, 0, Math.PI * 2);
        ctx.stroke();
        
        // 绘制速度标签
        const label = speed.toFixed(2) + ' Mbps';
        ctx.fillStyle = '#ffffff';
        ctx.font = 'bold 12px sans-serif';
        
        let labelX = x + 15;
        let labelY = y - 10;
        
        if (labelX + 80 > width) labelX = x - 80;
        if (labelY < 15) labelY = y + 20;
        
        ctx.fillText(label, labelX, labelY);
      }
      
      canvas.addEventListener('mousemove', function(e) {
        if (globalSpeedHistory.length < 1) return;
        
        const rect = canvas.getBoundingClientRect();
        const x = e.clientX - rect.left;
        const width = canvas.width;
        const height = canvas.height;
        
        // 找到最接近的点
        let nearestPoint = null;
        let nearestDist = Infinity;
        
        globalSpeedHistory.forEach((point) => {
          const pointX = (point.percent / 100) * width;
          const dist = Math.abs(x - pointX);
          if (dist < nearestDist) {
            nearestDist = dist;
            nearestPoint = point;
          }
        });
        
        if (nearestPoint) {
          const pointX = (nearestPoint.percent / 100) * width;
          const pointY = height - (nearestPoint.speed / globalYMax) * height;
          drawHoverPoint(pointX, pointY, nearestPoint.speed);
        }
      });
      
      canvas.addEventListener('mouseleave', function() {
        updateSpeedChart(globalSpeedHistory);
      });
    }
    
    function startSpeedTest() {
      const totalSize = 24 * 1024 * 1024; // 24MB
      const statusIndicator = document.getElementById('statusIndicator');
      const statusText = document.getElementById('statusText');
      const progressBar = document.getElementById('progressBar');
      const percentEl = document.getElementById('percent');
      const instantSpeedEl = document.getElementById('instantSpeed');
      const avgSpeedEl = document.getElementById('avgSpeed');
      const maxSpeedEl = document.getElementById('maxSpeed');
      const minSpeedEl = document.getElementById('minSpeed');
      const maxSpeedMBEl = document.getElementById('maxSpeedMB');
      const minSpeedMBEl = document.getElementById('minSpeedMB');
      const maxSpeedUnitEl = document.getElementById('maxSpeedUnit');
      const minSpeedUnitEl = document.getElementById('minSpeedUnit');
      const instantSpeedMBEl = document.getElementById('instantSpeedMB');
      const avgSpeedMBEl = document.getElementById('avgSpeedMB');
      const instantSpeedUnitEl = document.getElementById('instantSpeedUnit');
      const avgSpeedUnitEl = document.getElementById('avgSpeedUnit');
      const loadedSizeEl = document.getElementById('loadedSize');
      const elapsedTimeEl = document.getElementById('elapsedTime');

      // 生成随机参数，确保CDN无解
      const randomParam = Math.random().toString(36).substring(2, 15) + Date.now();
      const testUrl = 'https://cfplus.255520.xyz/assets/noise_24mb_uncmp.bin?_=' + randomParam;
      
      const startTime = performance.now();
      let lastTime = startTime;
      let lastLoaded = 0;
      let maxSpeed = 0;
      let minSpeed = Infinity;

      // 定义更新显示函数（放在前面确保可用）
      function updateDisplay(percent, instantSpeed, avgSpeed, loaded, duration) {
        // 更新圆形进度条
        const circumference = 2 * Math.PI * 45;
        const offset = circumference - (percent / 100) * circumference;
        progressBar.style.strokeDashoffset = offset;

        // 更新百分比 - 只显示整数 0-100
        percentEl.textContent = Math.floor(percent);

        // 更新速度 - 确保是数字 (Mbps)
        instantSpeedEl.textContent = Number(instantSpeed).toFixed(2);
        avgSpeedEl.textContent = Number(avgSpeed).toFixed(2);
        
        // 更新最高/最低速度
        if (instantSpeed > 0) {
          if (instantSpeed > maxSpeed) maxSpeed = instantSpeed;
          if (instantSpeed < minSpeed) minSpeed = instantSpeed;
          maxSpeedEl.textContent = maxSpeed.toFixed(2);
          minSpeedEl.textContent = minSpeed === Infinity ? '0.00' : minSpeed.toFixed(2);
          
          // 更新最高/最低速度的 MB/s 或 KB/s
          const maxSpeedMB = maxSpeed / 8;
          const minSpeedMB = minSpeed === Infinity ? 0 : minSpeed / 8;
          
          if (maxSpeedMB >= 1) {
            maxSpeedMBEl.textContent = maxSpeedMB.toFixed(2);
            maxSpeedUnitEl.textContent = 'MB/s';
          } else {
            maxSpeedMBEl.textContent = (maxSpeedMB * 1024).toFixed(2);
            maxSpeedUnitEl.textContent = 'KB/s';
          }
          
          if (minSpeedMB >= 1) {
            minSpeedMBEl.textContent = minSpeedMB.toFixed(2);
            minSpeedUnitEl.textContent = 'MB/s';
          } else {
            minSpeedMBEl.textContent = (minSpeedMB * 1024).toFixed(2);
            minSpeedUnitEl.textContent = 'KB/s';
          }
        }

        // 计算并显示 MB/s 或 KB/s
        // Mbps / 8 = MB/s
        const instantSpeedMB = instantSpeed / 8;
        const avgSpeedMB = avgSpeed / 8;
        
        // 根据速度大小决定显示 MB/s 还是 KB/s
        if (instantSpeedMB >= 1) {
          instantSpeedMBEl.textContent = instantSpeedMB.toFixed(2);
          instantSpeedUnitEl.textContent = 'MB/s';
        } else {
          instantSpeedMBEl.textContent = (instantSpeedMB * 1024).toFixed(2);
          instantSpeedUnitEl.textContent = 'KB/s';
        }
        
        if (avgSpeedMB >= 1) {
          avgSpeedMBEl.textContent = avgSpeedMB.toFixed(2);
          avgSpeedUnitEl.textContent = 'MB/s';
        } else {
          avgSpeedMBEl.textContent = (avgSpeedMB * 1024).toFixed(2);
          avgSpeedUnitEl.textContent = 'KB/s';
        }

        // 更新信息
        loadedSizeEl.textContent = (loaded / 1024 / 1024).toFixed(2);
        elapsedTimeEl.textContent = duration.toFixed(2);
      }
      // 重置显示
      statusIndicator.classList.remove('complete', 'error');
      statusIndicator.classList.add('loading');
      statusText.textContent = '测试中... / Testing';
      
      // 重置最高最低速度
      maxSpeed = 0;
      minSpeed = Infinity;
      maxSpeedEl.textContent = '0.00';
      minSpeedEl.textContent = '0.00';
      maxSpeedMBEl.textContent = '0.00';
      minSpeedMBEl.textContent = '0.00';
      maxSpeedUnitEl.textContent = 'MB/s';
      minSpeedUnitEl.textContent = 'MB/s';
      
      // 重置进度
      updateDisplay(0, 0, 0, 0, 0);

      // 使用 XMLHttpRequest 获取进度
      currentXhr = new XMLHttpRequest();
      
      currentXhr.open('GET', testUrl, true);
      currentXhr.responseType = 'arraybuffer';
      
      // 用于平滑实时速度的指数移动平均
      let smoothedInstantSpeed = 0;
      const alpha = 0.3; // 稍微快一点的响应
      
      // 速度历史数据用于绘制曲线
      const speedHistory = [];
      
      currentXhr.onprogress = function(event) {
        if (event.lengthComputable || event.loaded > 0) {
          const currentTime = performance.now();
          const totalDuration = (currentTime - startTime) / 1000;
          const instantDuration = (currentTime - lastTime) / 1000;
          
          const loaded = event.loaded;
          const percent = Math.min(100, (loaded / totalSize * 100));
          
          // 计算瞬时速度 (Mbps)
          const instantBytes = loaded - lastLoaded;
          let rawInstantSpeed = 0;
          if (instantDuration > 0.02 && instantBytes > 0) {
            rawInstantSpeed = ((instantBytes * 8) / (1024 * 1024) / instantDuration);
          }
          
          // 平滑实时速度
          if (rawInstantSpeed > 0) {
            if (smoothedInstantSpeed === 0) {
              smoothedInstantSpeed = rawInstantSpeed;
            } else {
              smoothedInstantSpeed = alpha * rawInstantSpeed + (1 - alpha) * smoothedInstantSpeed;
            }
          }
          
          // 每次有进度都记录并更新图表 - 完全同步
          if (smoothedInstantSpeed > 0) {
            speedHistory.push({
              time: totalDuration,
              speed: smoothedInstantSpeed,
              percent: percent
            });
            updateSpeedChart(speedHistory);
          }
          
          // 计算平均速度 (Mbps)
          const avgSpeed = totalDuration > 0 ? 
            ((loaded * 8) / (1024 * 1024) / totalDuration) : 0;
          
          // 更新显示
          updateDisplay(percent, smoothedInstantSpeed, avgSpeed, loaded, totalDuration);
          
          lastTime = currentTime;
          lastLoaded = loaded;
        }
      };
      
      currentXhr.onload = function() {
        const endTime = performance.now();
        const totalDuration = (endTime - startTime) / 1000;
        const avgSpeedNum = (totalSize * 8) / (1024 * 1024) / totalDuration;
        
        statusIndicator.classList.remove('loading');
        statusIndicator.classList.add('complete');
        statusText.textContent = '完成 / Complete';
        
        // 确保曲线图显示最终数据
        if (speedHistory.length > 0) {
          updateSpeedChart(speedHistory);
        }
        
        // 更新到100%
        updateDisplay(100, 0, avgSpeedNum, totalSize, totalDuration);
      };
      
      currentXhr.onerror = function() {
        statusIndicator.classList.remove('loading');
        statusIndicator.classList.add('error');
        statusText.textContent = '失败 / Failed';
      };
      
      currentXhr.send();
    }
    
    // 页面加载时自动开始测速
    window.addEventListener('load', function() {
      // 初始化鼠标交互
      setupChartHover();
      // 延迟一点开始，让页面先渲染
      setTimeout(startSpeedTest, 500);
    });
    
    // 测试按钮点击事件 - 任何时候都可以点击重新测速
    document.getElementById('testBtn').addEventListener('click', function() {
      // 取消之前的请求
      if (currentXhr) {
        currentXhr.abort();
      }
      
      // 开始新的测速
      startSpeedTest();
    });

    // 页面加载时间统计
    window.addEventListener('load', function() {
      setTimeout(function() {
        const perfData = performance.timing;
        const pageLoadTime = perfData.loadEventEnd - perfData.navigationStart;
        document.getElementById('pageLoadTime').textContent = 
          '页面加载 / Page Load: ' + (pageLoadTime / 1000).toFixed(2) + 's';
      }, 100);
    });
  

X-UA-Compatible

PoweredBy

Open-Graph-Protocol

HTTP/3

Cloudflare Bot Management

Cloudflare

✅ Low Risk - https://cloudflare-aog.pages.dev/

Requests	IP Address	Location	AS Autonomous System
4	188.114.97.3	United States	AS13335Cloudflare, Inc.
3	198.41.200.200	United States	AS13335Cloudflare, Inc.
7	2	-	-

Security Scan Report: cloudflare-aog.pages.dev

Summary

AI Security Verdict

Moderate Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies5

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