technology software

documentation technical

blog personal website

cryptocurrency blockchain

Chinese

Within the developer-focused generic top-level domain (.dev), 'index-a5v1tcnp4g.edgeone.dev' is registered with subdomain 'index-a5v1tcnp4g'. Count 7 characters in 'edgeone' holding 4 vowels versus 3 consonants. Breaking it apart gives two words: edge, one. Median word length is 3.5 characters. No strong language cues emerged from the frequency lists.

html/24/75/2475d071-197c-406a-a818-84ea96d3c220.html.gz

ec9489c8158ecf535d0b991b4ddd001b51b1f6cf167711ab74c5e3c865fac351

viewport

html/24/75/2475d071-197c-406a-a818-84ea96d3c220_nodriver.html.gz

服务概览

Prudence Malinki

MarkMonitor Inc.

edgeone.dev

IRT-ALISOFT-CN

Li Jia

Guoxin Gao

Guowei Pan

security trouble

ALISOFT


    // 服务配置数组，方便后续增减
    const services = [
      { name: "导航栏", url: "https://vder.cn" },
      { name: "导航栏-Cloudflare", url: "https://ioku.qzz.io/" },
      { name: "导航栏-Aliyun", url: "https://index.12a0ecbf.er.aliyun-esa.net" },
      { name: "导航栏-Landui", url: "https://o.vder.cn" },
      { name: "导航栏-Zeabur", url: "https://index.zeabur.app" },
      { name: "旅游地图", url: "https://map.12a0ecbf.er.aliyun-esa.net" },
      { name: "后端服务", url: "https://api.vder.cn" },
	    { name: "数据服务", url: "https://backserver.fly.dev"},
      { name: "我的博客", url: "https://ioku.net" },
      { name: "每日一图", url: "https://bing.ioku.net" },
      { name: "服务监控", url: "https://jk.ioku.net" },
      { name: "视频媒体", url: "https://mov.fly.dev" },
      { name: "兰空图床", url: "https://imgs.fly.dev" },
      { name: "谷歌地图", url: "https://nba.edu.deal" },
      { name: "三蛋主机", url: "https://literature.serv00.net" },
      
    ];

    // API地址
    const apiUrl = "https://backserver.fly.dev/api/function?key=literature";
    // 数据库图标基础URL
    const dbIconBaseUrl = "https://cdn.jsdelivr.net/gh/devicons/devicon/icons";

    // 改进的Ping服务函数
    function pingService(url, latencyElement) {
      const startTime = Date.now();
      
      // 创建一个 Promise 来处理多种检测方式
      const checkMethods = [
        // 方法1: fetch 检测（不使用 no-cors 模式）
        () => fetch(url, { 
          method: 'HEAD', // 使用 HEAD 请求减少数据传输
          mode: 'no-cors',
          cache: 'no-cache'
        }).then(() => true),
        
        // 方法2: Image 方式检测（原方法优化）
        () => new Promise((resolve, reject) => {
          const img = new Image();
          img.timeout = 5000; // 设置超时时间
          
          img.onload = () => resolve(true);
          img.onerror = () => resolve(false); // 即使出错也认为服务可达
          
          // 尝试加载 favicon 或根路径
          img.src = `${url}/favicon.ico?_=${startTime}`;
          
          // 如果5秒内没有响应，则尝试根路径
          setTimeout(() => {
            if (!img.complete) {
              img.src = `${url}?_=${startTime}_root`;
            }
          }, 2000);
        }),
        
        // 方法3: XMLHttpRequest 检测
        () => new Promise((resolve, reject) => {
          const xhr = new XMLHttpRequest();
          let resolved = false;
          
          xhr.timeout = 5000;
          
          xhr.onreadystatechange = function() {
            if (resolved) return;
            
            // 只要收到响应头就认为服务可达
            if (xhr.readyState >= 2) {
              resolved = true;
              resolve(true);
            }
          };
          
          xhr.ontimeout = () => {
            if (!resolved) {
              resolved = true;
              resolve(false);
            }
          };
          
          xhr.onerror = () => {
            if (!resolved) {
              resolved = true;
              resolve(false);
            }
          };
          
          try {
            xhr.open('HEAD', url, true);
            xhr.send();
          } catch (e) {
            resolved = true;
            resolve(false);
          }
        })
      ];
      
      // 依次尝试不同的检测方法
      const tryMethod = (index) => {
        if (index >= checkMethods.length) {
          // 所有方法都失败
          latencyElement.textContent = '异常';
          latencyElement.className = 'latency error';
          return;
        }
        
        checkMethods[index]()
          .then(result => {
            const endTime = Date.now();
            const latency = endTime - startTime;
            
            if (result) {
              latencyElement.textContent = `${latency}ms`;
              latencyElement.className = 'latency normal';
            } else {
              // 当前方法失败，尝试下一个方法
              tryMethod(index + 1);
            }
          })
          .catch(() => {
            // 当前方法出错，尝试下一个方法
            tryMethod(index + 1);
          });
      };
      
      // 开始尝试第一种方法
      tryMethod(0);
    }

    // 更新所有服务状态
    function updateAllServices() {
      const serviceCards = document.querySelectorAll('.service-card');
      
      serviceCards.forEach((card, index) => {
        const urlElement = card.querySelector('.service-url');
        const latencyElement = card.querySelector('.latency');
        const url = urlElement.textContent;
        
        // 对所有服务进行ping检测
        pingService(url, latencyElement);
      });
    }

    // 动态生成服务卡片
    function renderServices() {
      const servicesGrid = document.querySelector('.services-grid');
      servicesGrid.innerHTML = '';
      
      services.forEach(service => {
        const card = document.createElement('div');
        card.className = 'service-card';
        card.innerHTML = `
          <div class="service-info">
            <div class="service-name">${service.name}</div>
            <div class="service-url">${service.url}</div>
          </div>
          <div class="latency normal">检测中...</div>
        `;
        card.addEventListener('click', () => {
          window.open(service.url, '_blank');
        });
        servicesGrid.appendChild(card);
      });
    }

    // 动态生成存储卡片
    function renderStorages(storages) {
      const storageGrid = document.querySelector('.storage-grid');
      storageGrid.innerHTML = ''; // 清空加载中的内容
      
      if (!storages || storages.length === 0) {
        storageGrid.innerHTML = '<div class="loading"><p>暂无存储数据</p></div>';
        return;
      }
      
      storages.forEach(storage => {
        // 计算使用百分比
        const percentage = Math.round((storage.used / storage.total) * 100);
        
        // 根据使用率确定颜色等级
        let levelClass = 'low';
        if (percentage >= 80 && percentage < 90) {
          levelClass = 'medium';
        } else if (percentage >= 90) {
          levelClass = 'high';
        }
        
        const card = document.createElement('div');
        card.className = 'storage-card';
        card.innerHTML = `
          <div class="storage-name">${storage.name}</div>
          <div class="battery-container">
            <div class="battery-tip"></div>
            <div class="battery-level ${levelClass}" style="height: ${percentage}%"></div>
          </div>
          <div class="storage-info">
            <div>${percentage}% </br>(${storage.used }/${storage.total /1024 }GB)</div>
            <div class="storage-usage">${storage.purpose}</div>
          </div>
        `;
        storageGrid.appendChild(card);
      });
    }

    // 动态生成数据库表格
    function renderDatabases(databases) {
      const tableBody = document.getElementById('database-table-body');
      tableBody.innerHTML = '';
      
      databases.forEach(db => {
        const row = document.createElement('tr');
        
        // 构建数据库图标URL
        let iconUrl = '';
        switch(db.DatabaseType?.toLowerCase()) {
          case 'mysql':
            iconUrl = `${dbIconBaseUrl}/mysql/mysql-original-wordmark.svg`;
            break;
          case 'redis':
            iconUrl = `${dbIconBaseUrl}/redis/redis-original-wordmark.svg`;
            break;
          case 'mongodb':
            iconUrl = `${dbIconBaseUrl}/mongodb/mongodb-original-wordmark.svg`;
            break;
          case 'postgresql':
            iconUrl = `${dbIconBaseUrl}/postgresql/postgresql-original-wordmark.svg`;
            break;
          case 'oracle':
            iconUrl = `${dbIconBaseUrl}/oracle/oracle-original.svg`;
            break;
          default:
            iconUrl = '';
        }
        
        // 处理错误信息
        const errorMessage = db.error || (db.Code !== 200 ? `Error code: ${db.Code}` : '-');
        
        // 提取总数据大小和总存储大小
        let totalDataSize = 'N/A';
        let totalStorageSize = 'N/A';
        
        if (db.DBSpaceUsage) {
          if (db.DBSpaceUsage.TotalDataSizeMB !== undefined) {
            totalDataSize = db.DBSpaceUsage.TotalDataSizeMB.toFixed(2);
          } else if (db.DiskSpaceUsage && db.DiskSpaceUsage.TotalDataSizeMB !== undefined) {
            totalDataSize = db.DiskSpaceUsage.TotalDataSizeMB.toFixed(2);
          } else {
            // 如果有具体数据库名称的数据，计算总和
            const sizes = Object.values(db.DBSpaceUsage).filter(item => typeof item === 'object');
            if (sizes.length > 0) {
              totalDataSize = sizes.reduce((sum, item) => sum + (item.DataSizeMB || 0), 0).toFixed(2);
              totalStorageSize = sizes.reduce((sum, item) => sum + (item.StorageSizeMB || 0), 0).toFixed(2);
            }
          }
        }
        
        if (totalStorageSize === 'N/A' && db.DiskSpaceUsage && db.DiskSpaceUsage.TotalDataSizeMB !== undefined) {
          totalStorageSize = db.DiskSpaceUsage.TotalDataSizeMB.toFixed(2);
        }
        
        // 处理内存使用情况
        let memoryUsage = 'N/A';
        if (db.MemoryUsage) {
          if (db.MemoryUsage.UsedMemoryHuman) {
            memoryUsage = db.MemoryUsage.UsedMemoryHuman;
          } else if (db.MemoryUsage.VirtualMemoryMB !== 'N/A') {
            memoryUsage = `${db.MemoryUsage.ResidentMemoryMB}/${db.MemoryUsage.VirtualMemoryMB} MB`;
          }
        }
        row.innerHTML = `
          <td>${iconUrl ? `<img src="${iconUrl}" alt="${db.DatabaseType}" class="db-icon">` : ''}</td>
          <td>${db.ServiceProvider || 'N/A'}</td>
          <td>${db.CloudServiceProvider || 'N/A'}</td>
          <td>${db.Region || 'N/A'}</td>
          <td>${db.Version || 'N/A'}</td>
          <td>${db.ExpirationDate || 'N/A'}</td>
          <td>${db.DaysOnline || 'N/A'}</td>
          <td>${db.CurrentConnections || 0}</td>
          <td>${memoryUsage}</td>
          <td>${totalDataSize}</td>
          <td>${totalStorageSize}</td>
          <td>${errorMessage}</td>
        `;
        tableBody.appendChild(row);
      });
    }

    // 动态生成域名解析表格
    function renderDomains(domains) {
      const tableBody = document.getElementById('domain-table-body');
      tableBody.innerHTML = '';
      
      domains.forEach(domain => {
        const row = document.createElement('tr');
        
        row.innerHTML = `
          <td>${domain.MainDomain || 'N/A'}</td>
          <td>${domain.ExpirationDate || 'N/A'}</td>
          <td>${domain.ResolveDomain || 'N/A'}</td>
          <td>${domain.ResolveType || 'N/A'}</td>
          <td>${domain.ResolveAddress || 'N/A'}</td>
          <td>${domain.Provider || 'N/A'}</td>
          <td>${domain.Application || 'N/A'}</td>
        `;
        tableBody.appendChild(row);
      });
    }

    // 获取数据的函数
    async function fetchData(dataType) {
      try {
        let requestBody = {};
        
        // 根据数据类型设置请求体
        if (dataType === 'databases') {
          requestBody = {
            fun: "0003"
          };
        } else if (dataType === 'storages') {  // 新增存储数据类型
          requestBody = {
            fun: "0004"
          };
        } else {
          // 其他类型的数据请求
          requestBody = {
            fun: "0004"
          };
        }
        
        const response = await fetch(apiUrl, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(requestBody)
        });
        
        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const data = await response.json();
        
        // 如果是数据库数据，提取body数组
        if (dataType === 'databases' && data.body && Array.isArray(data.body)) {
          return data.body;
        }
        
        // 如果是存储数据，同样提取body数组
        if (dataType === 'storages' && data.body && Array.isArray(data.body)) {
          return data.body;
        }
        
        return data;
      } catch (error) {
        console.error(`获取${dataType}数据失败:`, error);
        return null;
      }
    }

    // 获取域名数据的函数
    async function fetchDomainData() {
      try {
        const requestBody = {
          fun: "0005"  // 获取域名数据的函数编号
        };
        
        const response = await fetch(apiUrl, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(requestBody)
        });
        
        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const data = await response.json();
        
        // 提取域名数据数组
        if (data.body && Array.isArray(data.body)) {
          return data.body;
        }
        
        return data;
      } catch (error) {
        console.error('获取域名数据失败:', error);
        return null;
      }
    }

    // 初始化页面
    document.addEventListener('DOMContentLoaded', async function() {
      renderServices();
      updateAllServices(); // 首次检测
      
      // 并行获取存储、数据库和域名数据
      const [storagesData, databasesData, domainsData] = await Promise.all([
        fetchData('storages'),
        fetchData('databases'),
        fetchDomainData()
      ]);
      
      // 渲染存储数据
      if (storagesData) {
        renderStorages(storagesData);
      } else {
        // 显示错误信息而不是空白
        const storageGrid = document.querySelector('.storage-grid');
        storageGrid.innerHTML = '<div class="loading"><p>加载失败</p></div>';
      }
      
      // 渲染数据库数据
      if (databasesData) {
        renderDatabases(databasesData);
      } else {
        // 显示错误信息而不是空白
        const tableBody = document.getElementById('database-table-body');
        tableBody.innerHTML = `
          <tr>
            <td colspan="14">
              <div class="loading">
                <p>数据库信息加载失败</p>
              </div>
            </td>
          </tr>
        `;
      }
      
      // 渲染域名数据
      if (domainsData) {
        renderDomains(domainsData);
      } else {
        // 显示错误信息而不是空白
        const tableBody = document.getElementById('domain-table-body');
        tableBody.innerHTML = `
          <tr>
            <td colspan="7">
              <div class="loading">
                <p>域名解析信息加载失败</p>
              </div>
            </td>
          </tr>
        `;
      }
      
      // 定时检测（每30秒）
      setInterval(updateAllServices, 30000);
    });
  

✅ Low Risk - https://index-a5v1tcnp4g.edgeone.dev/

Requests	IP Address	Location	AS Autonomous System
8	104.21.40.32	China	AS150436
1	103.47.80.72	China	AS134765CHINANET Yunnan province IDC1 network
1	128.204.218.48	Warsaw, Mazovia, Poland	AS57367Atman Sp. z o.o.
1	104.21.63.198	United States	AS13335Cloudflare, Inc.
1	69.5.7.122	Indonesia	AS150436Byteplus Pte. Ltd.
1	155.102.206.137	United States	AS24429Zhejiang Taobao Network Co.,Ltd
1	120.78.231.211	Shenzhen, Guangdong, China	AS37963Hangzhou Alibaba Advertising Co.,Ltd.
1	66.241.125.254	United States	AS40509Fly.io, Inc.
1	43.174.247.29	Unknown	AS40509
1	66.241.124.227	United States	AS40509Fly.io, Inc.
20	13	-	-

Security Scan Report: index-a5v1tcnp4g.edgeone.dev

Summary

AI Security Verdict

High Risk

Risk Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History