technology software

documentation technical

cryptocurrency blockchain

download file sharing

government public service

Chinese

Domain 'ymodem-tools.pages.dev' uses the developer-focused generic top-level domain (.dev) with subdomain 'ymodem-tools'. Its registrable label 'pages' stretches across 5 characters split between 2 vowels and 3 consonants. Segmentation suggests one word: pages. No strong language cues emerged from the frequency lists.

html/5e/c1/5ec1dbd1-27ea-4e18-b82c-aed83aae66a9.html.gz

05ab93c14a48c244b128caf1e8febd31d7097b031c1a6087a86aa7b81c1c11e5

viewport

Abuse Team

CloudFlare, Inc.

pages.dev

Cloudflare Abuse Contact

MNT-CLOUDFLARE

Cloudflare Technical Contact

CLOUDFLARENET-EU


/* -------------------- 常量与工具（与脚本对齐） -------------------- */
const YMD_SOH = 0x01;
const YMD_STX = 0x02;
const YMD_EOT = 0x04;
const YMD_ACK = 0x06;
const YMD_NAK = 0x15;
const YMD_CAN = 0x18;
const YMD_CHC = 0x43; // 'C'
const YMD_BLK128 = 128;
const YMD_BLK1K  = 1024;

function crc16_ccitt(arr /* Uint8Array */) {
  let crc = 0; // XMODEM: init 0x0000
  for (let i=0;i<arr.length;i++) {
    crc ^= (arr[i] << 8) & 0xFFFF;
    for (let b=0;b<8;b++) {
      if (crc & 0x8000) crc = ((crc << 1) ^ 0x1021) & 0xFFFF;
      else crc = (crc << 1) & 0xFFFF;
    }
  }
  return crc & 0xFFFF;
}
function humanBytes(v) {
  const u = ["B","KB","MB","GB"]; let i=0;
  while (v>=1024 && i<3) { v/=1024; i++; }
  if (v>=100) return `${v.toFixed(0)} ${u[i]}`;
  if (v>=10) return `${v.toFixed(1)} ${u[i]}`;
  return `${v.toFixed(2)} ${u[i]}`;
}

/* -------------------- 简易字节队列（串口读缓冲 + 超时） -------------------- */
class ByteQueue {
  constructor(){ this.chunks=[]; this.length=0; this.waiters=[]; }
  push(u8){
    if (!u8 || u8.length===0) return;
    this.chunks.push(u8); this.length += u8.length;
    this._tryFulfill();
  }
  _tryFulfill(){
    for (let i=0;i<this.waiters.length;i++){
      const w = this.waiters[i];
      if (this.length >= w.n) {
        // 取 n 字节
        const out = new Uint8Array(w.n);
        let off = 0;
        while (off < w.n) {
          const c = this.chunks[0];
          const take = Math.min(c.length, w.n - off);
          out.set(c.subarray(0, take), off);
          off += take;
          if (take === c.length) this.chunks.shift();
          else this.chunks[0] = c.subarray(take);
        }
        this.length -= w.n;
        // 移除此 waiter 并 resolve
        this.waiters.splice(i,1); i--;
        w.resolve(out);
      }
    }
  }
  readExact(n, timeoutMs){
    if (this.length >= n) {
      // 快速路径
      return Promise.resolve(this._pop(n));
    }
    return new Promise((resolve) => {
      let done = false;
      const timer = setTimeout(() => {
        if (!done) { done = true; this._cancelWaiter(waiter); resolve(null); }
      }, timeoutMs);
      const waiter = { n, resolve:(val)=>{ if (!done){ done=true; clearTimeout(timer); resolve(val);} } };
      this.waiters.push(waiter);
    });
  }
  _cancelWaiter(waiter){
    const i = this.waiters.indexOf(waiter);
    if (i>=0) this.waiters.splice(i,1);
  }
  _pop(n){
    const out = new Uint8Array(n);
    let off=0;
    while (off<n) {
      const c=this.chunks[0];
      const take=Math.min(c.length, n-off);
      out.set(c.subarray(0,take), off);
      off+=take;
      if (take===c.length) this.chunks.shift();
      else this.chunks[0]=c.subarray(take);
    }
    this.length -= n;
    return out;
  }
}

/* -------------------- Web Serial 包装 -------------------- */
class SerialPortWrapper {
  constructor(log){ this.log = log; this.port=null; this.reader=null; this.writer=null; this.queue=new ByteQueue(); this.readLoopRunning=false; }
  async open(opts){
    this.port = await navigator.serial.requestPort();
    await this.port.open({
      baudRate: opts.baudRate,
      dataBits: parseInt(opts.dataBits||8,10),
      parity: (opts.parity||'none'),
      stopBits: parseInt(opts.stopBits||1,10),
      flowControl: 'none'
    });
    // 可选 DTR/RTS
    try { await this.port.setSignals({ dataTerminalReady: !!opts.dtr, requestToSend: !!opts.rts }); } catch(e){}
    this.writer = this.port.writable.getWriter();
    this.reader = this.port.readable.getReader();
    this.readLoopRunning = true;
    (async()=>{
      try {
        while (this.readLoopRunning) {
          const { value, done } = await this.reader.read();
          if (done) break;
          if (value) this.queue.push(value);
        }
      } catch(e) {
        // 断开等情况
      }
    })();
    return this.port.getInfo ? this.port.getInfo() : {};
  }
  async close(){
    try { this.readLoopRunning=false; if (this.reader) { await this.reader.cancel(); this.reader.releaseLock(); } } catch(e){}
    try { if (this.writer) { this.writer.releaseLock(); } } catch(e){}
    try { if (this.port) { await this.port.close(); } } catch(e){}
    this.reader=this.writer=null; this.port=null;
  }
  async write(bytes /* Uint8Array */){ await this.writer.write(bytes); }
  async putc(b){ await this.write(new Uint8Array([b & 0xFF])); }
  async writeFull(bufs /* Array of Uint8Array | Uint8Array */){
    if (bufs instanceof Uint8Array) return this.write(bufs);
    for (const b of bufs) await this.write(b);
  }
  async getc(timeoutMs){ const r = await this.queue.readExact(1, timeoutMs); return r ? r[0] : -1; }
  async readExact(n, timeoutMs){ const r = await this.queue.readExact(n, timeoutMs); return r; } // Uint8Array or null
}

/* -------------------- YMODEM 主体（与脚本语义对齐） -------------------- */
class YModem {
  constructor(sp, log, progress){ this.sp=sp; this.log=log; this.progress=progress; this.stopFlag=false; }

  async _send_block(seq, payload /* Uint8Array 长度 128 或 1024 */){
    const code = (payload.length===YMD_BLK1K) ? YMD_STX : YMD_SOH;
    const hdr = new Uint8Array([code, seq & 0xFF, (~seq) & 0xFF]);
    const crc = crc16_ccitt(payload);
    const crc2 = new Uint8Array([(crc>>8)&0xFF, crc & 0xFF]);

    for (let attempt=0; attempt<10; attempt++){
      await this.sp.writeFull([hdr, payload, crc2]);
      const r = await this.sp.getc(5000);
      if (r === YMD_ACK) return true;
      if (r === YMD_CAN) return false;
      // 其它（NAK/杂字节）重试
    }
    return false;
  }

  async _send_block0(filename, size){
    const buf = new Uint8Array(YMD_BLK128);
    let p=0;
    if (filename) {
      const enc = new TextEncoder();
      const nameBytes = enc.encode(filename).slice(0, YMD_BLK128-2);
      buf.set(nameBytes, p); p += nameBytes.length;
      buf[p++] = 0;
      const sz = new TextEncoder().encode(String(Math.max(0, size)));
      const m = Math.min(sz.length, YMD_BLK128 - p - 1);
      buf.set(sz.slice(0,m), p); p+=m;
      buf[p] = 0;
    } else {
      buf[0] = 0; // 空名 => 会话结束
    }
    return await this._send_block(0x00, buf);
  }

  async send(files /* File[] */){
    try {
      this.log("[TX] waiting for 'C' from receiver ...");
      const t0 = performance.now();
      let ch = -1;
      while (performance.now() - t0 < 20000) {
        ch = await this.sp.getc(1000);
        if (ch === YMD_CHC) break;
      }
      if (ch !== YMD_CHC) { this.log("[TX] no 'C' from receiver"); return -2; }

      for (const file of files){
        if (this.stopFlag) throw new Error("stopped");
        const base = file.name;
        const size = file.size|0;
        this.log(`[TX] Sending ${base} (${size} bytes)`);

        // block0
        if (!await this._send_block0(base, size)) {
          this.log("[TX] send block0 fail"); return -3;
        }

        // 吞掉可能的 'C'
        await this.sp.getc(300);

        let seq = 1, sent = 0;
        const prefer1k = true;
        const plen = prefer1k ? YMD_BLK1K : YMD_BLK128;
        const tStart = performance.now();

        let pos = 0;
        while (pos < size) {
          if (this.stopFlag) throw new Error("stopped");
          const end = Math.min(pos + plen, size);
          const slice = new Uint8Array(await file.slice(pos, end).arrayBuffer());
          let payload;
          if (slice.length < plen) {
            payload = new Uint8Array(plen);
            payload.set(slice, 0);
            payload.fill(0x1A, slice.length); // 填充 SUB
          } else {
            payload = slice;
          }
          if (!await this._send_block(seq, payload)) {
            this.log("[TX] data block fail"); return -4;
          }
          seq = (seq + 1) & 0xFF;
          sent += Math.min(plen, size - sent);
          const elapsed = Math.max(1e-3, (performance.now()-tStart)/1000);
          const bps = sent/elapsed;
          this.progress("[TX]", base, sent, size);
          pos = end;
        }

        // EOT 序列（EOT -> 等 NAK -> 再发 EOT -> 等 ACK）
        await this.sp.putc(YMD_EOT);
        let ok = false; {
          const t1 = performance.now();
          while (performance.now()-t1 < 3000){
            const r = await this.sp.getc(200);
            if (r === YMD_NAK) { ok=true; break; }
            if (r === YMD_CAN) { this.log("[TX] canceled during EOT"); return -5; }
          }
        }
        if (!ok) { this.log("[TX] EOT/NAK mismatch"); return -6; }

        await this.sp.putc(YMD_EOT);
        ok = false; {
          const t2 = performance.now();
          while (performance.now()-t2 < 3000){
            const r = await this.sp.getc(200);
            if (r === YMD_ACK) { ok=true; break; }
            if (r === YMD_CAN) { this.log("[TX] canceled during EOT#2"); return -7; }
          }
        }
        if (!ok) { this.log("[TX] EOT/ACK mismatch"); return -8; }

        // 吞掉可能的 'C'
        await this.sp.getc(200);
        this.progress("[TX]", base, size, size);
        this.log(`[TX] Done: ${base}`);
      }

      // 会话结束：空名 block0
      if (!await this._send_block0("", 0)) { this.log("[TX] final empty block0 fail"); return -9; }
      await this.sp.getc(100);
      this.log("[TX] session finished");
      return 0;

    } catch (e) {
      this.log(`[TX] exception: ${e}`);
      try { for (let i=0;i<7;i++) await this.sp.putc(YMD_CAN); } catch(_){}
      return -99;
    }
  }

  async _read_packet_rest(code, timeoutMs){
    let payload;
    if (code === YMD_SOH) payload = YMD_BLK128;
    else if (code === YMD_STX) payload = YMD_BLK1K;
    else return { rest: null, payload: 0 };
    const rest = await this.sp.readExact(2 + payload + 2, timeoutMs); // seq, inv, data, crc
    if (!rest) return { rest: null, payload: 0 };
    return { rest, payload };
  }

  async receive(fileSink /* { create: async(name)->writer, done: async() } */){
    let fileCnt = 0;
    try {
      for(;;){
        // 等 block0：周期发 'C'
        this.log("[RX] waiting block0 ...");
        const t0 = performance.now();
        let got0 = false, code = -1;
        for(;;){
          if (this.stopFlag) throw new Error("stopped");
          await this.sp.putc(YMD_CHC);
          code = await this.sp.getc(1000);
          if (code === YMD_SOH || code === YMD_STX) { got0 = true; break; }
          if (code === YMD_CAN) { this.log("[RX] canceled by sender"); return -2; }
          if (performance.now() - t0 > 15000){
            if (fileCnt > 0) { this.log("[RX] tail idle -> session end"); return 0; }
            else { this.log("[RX] wait block0 timeout"); return -3; }
          }
        }
        // 读 block0 剩余
        const { rest, payload } = await this._read_packet_rest(code, 3000);
        if (!rest) { this.log("[RX] block0 rest timeout"); return -4; }
        const seq = rest[0], inv = rest[1];
        if (((seq + inv) & 0xFF) !== 0xFF || seq !== 0x00) { this.log("[RX] block0 seq err"); return -5; }
        const data = rest.subarray(2, 2+payload);
        const rxcrc = (rest[2+payload]<<8) | rest[2+payload+1];
        if (rxcrc !== crc16_ccitt(data)) { this.log("[RX] block0 CRC err"); return -6; }

        // 解析文件名/大小
        let zero1 = data.indexOf(0);
        if (zero1 < 0) zero1 = data.length;
        const dec = new TextDecoder('utf-8', {fatal:false});
        const name = dec.decode(data.subarray(0, zero1).filter(x=>x));
        let sizeStr="";
        if (zero1+1 < data.length){
          let zero2 = data.indexOf(0, zero1+1);
          if (zero2 < 0) zero2 = data.length;
          sizeStr = dec.decode(data.subarray(zero1+1, zero2).filter(x=>x));
        }
        let fsz = 0; try { fsz = sizeStr ? parseInt(sizeStr,10) : 0; } catch(_){ fsz = 0; }

        if (!name) {
          // 空名 => 完成
          await this.sp.putc(YMD_ACK);
          this.log("[RX] session finished"); 
          return 0;
        }

        this.log(`[RX] Receiving ${name} (${fsz} bytes)`);
        const writer = await fileSink.create(name);

        await this.sp.putc(YMD_ACK);
        await this.sp.putc(YMD_CHC);

        let done = 0;
        const tStart = performance.now();

        for(;;){
          if (this.stopFlag) { await writer.abort?.(); throw new Error("stopped"); }
          const c = await this.sp.getc(3000);
          if (c === YMD_SOH || c === YMD_STX) {
            const { rest, payload } = await this._read_packet_rest(c, 3000);
            if (!rest) { await writer.abort?.(); this.log("[RX] data rest timeout"); return -7; }
            const s1 = rest[0], s2 = rest[1];
            if (((s1+s2)&0xFF) !== 0xFF) { await this.sp.putc(YMD_NAK); continue; }
            const data = rest.subarray(2, 2+payload);
            const rxcrc = (rest[2+payload]<<8) | rest[2+payload+1];
            if (rxcrc !== crc16_ccitt(data)) { await this.sp.putc(YMD_NAK); continue; }
            let w = payload;
            if (fsz>0 && (done + w) > fsz) w = fsz - done;
            if (w > 0) {
              await writer.write(data.subarray(0,w));
              done += w;
              this.progress("[RX]", name, done, fsz>0 ? fsz : -1);
            }
            await this.sp.putc(YMD_ACK);
          } else if (c === YMD_EOT) {
            // EOT 双次
            await this.sp.putc(YMD_NAK);
            let ok = false;
            const t1 = performance.now();
            while (performance.now()-t1 < 6000){
              const e2 = await this.sp.getc(200);
              if (e2 === YMD_EOT) { ok = true; break; }
              if (e2 === YMD_CAN) { await writer.abort?.(); this.log("[RX] canceled during EOT"); return -8; }
            }
            if (!ok) { await writer.abort?.(); this.log("[RX] EOT seq err"); return -9; }
            await this.sp.putc(YMD_ACK);
            await this.sp.putc(YMD_CHC);
            await writer.close?.();
            this.progress("[RX]", name, fsz, fsz>0 ? fsz : fsz);
            this.log(`[RX] Done: ${name}`);
            fileCnt++;
            break; // 下一个文件（回到等待 block0）
          } else if (c === YMD_CAN) {
            await writer.abort?.();
            this.log("[RX] canceled by sender");
            return -10;
          } else {
            // 忽略杂字节
          }
        }
      }

    } catch(e){
      this.log(`[RX] exception: ${e}`);
      try { for (let i=0;i<7;i++) await this.sp.putc(YMD_CAN); } catch(_){}
      return -99;
    } finally {
      await fileSink.done?.();
    }
  }
}

/* -------------------- 文件保存策略（目录授权 or 下载） -------------------- */
function makeFileSinkWithFSAccess(dirHandle){
  // 目录已授权：逐文件创建
  return {
    async create(name){
      // 简单清理非法字符
      const safe = name.replace(/[\\\/:*?"<>|]/g, '_');
      const fileHandle = await dirHandle.getFileHandle(safe, { create:true });
      const stream = await fileHandle.createWritable();
      return {
        async write(u8){ await stream.write(u8); },
        async close(){ await stream.close(); },
        async abort(){ try{ await stream.abort(); }catch(_){ try{ await stream.close(); }catch(_){}} }
      };
    },
    async done(){}
  };
}
function makeFileSinkByDownload() {
  // 累积到内存，然后触发下载
  const opened = new Map();
  return {
    async create(name){
      const safe = name || `rx_${Date.now()}`;
      const parts = [];
      return {
        async write(u8){ parts.push(new Uint8Array(u8)); },
        async close(){
          const blob = new Blob(parts, { type: "application/octet-stream" });
          const url = URL.createObjectURL(blob);
          const a = document.createElement('a');
          a.href = url; a.download = safe;
          document.body.appendChild(a); a.click(); a.remove();
          URL.revokeObjectURL(url);
        },
        async abort(){ /* 丢弃 */ }
      };
    },
    async done(){}
  };
}

/* -------------------- UI 逻辑 -------------------- */
const el = (id)=>document.getElementById(id);
const logView = el('log'), bar = el('bar'), prog = el('prog'), status = el('status'), portInfo = el('portInfo');

function log(msg){ const s = `[${(new Date()).toLocaleTimeString()}] ${msg}\n`; logView.textContent += s; logView.scrollTop = logView.scrollHeight; }
function setProgress(tag, name, done, total){
  if (total && total>0) {
    const pct = Math.floor(done*100/total);
    bar.style.width = `${pct}%`;
    prog.textContent = `${tag} ${name}: ${humanBytes(done)} / ${humanBytes(total)}  ${pct}%`;
  } else {
    prog.textContent = `${tag} ${name}: ${humanBytes(done)}`;
  }
}
function setStatus(s){ status.textContent = s; }

const sp = new SerialPortWrapper(log);
let ymodem = new YModem(sp, log, setProgress);
let dirHandle = null;
let running = false;

function setRunning(run){
  running = run;
  el('btnSend').disabled = run;
  el('btnRecv').disabled = run;
  el('btnStop').disabled = !run;
}

el('btnClearLog').onclick = ()=>{ logView.textContent = ""; };
el('btnConnect').onclick = async()=>{
  try{
    const inf = await sp.open({
      baudRate: parseInt(el('baud').value,10),
      dataBits: el('databits').value,
      parity: el('parity').value,
      stopBits: el('stopbits').value,
      dtr: el('dtr').checked, rts: el('rts').checked
    });
    portInfo.textContent = `已连接 ${inf.usbVendorId?('VID:'+inf.usbVendorId.toString(16)):'(未知设备)'}`;
    portInfo.classList.remove('bad'); portInfo.classList.add('ok');
    setStatus("Connected");
    log("[*] 串口已打开");
  }catch(e){
    log(`[!] 打开失败：${e}`);
  }
};
el('btnDisconnect').onclick = async()=>{
  try{ await sp.close(); portInfo.textContent = "未连接"; portInfo.classList.remove('ok'); setStatus("Disconnected"); log("[*] 串口已关闭"); }catch(e){}
};

el('btnPickDir').onclick = async()=>{
  try{
    if (!window.showDirectoryPicker) { el('saveMode').textContent = "当前：下载保存（浏览器不支持目录写入）"; return; }
    dirHandle = await window.showDirectoryPicker({ mode:'readwrite' });
    el('saveMode').textContent = "当前：目录直写";
  }catch(e){
    dirHandle = null;
    el('saveMode').textContent = "当前：下载保存";
  }
};

el('btnSend').onclick = async()=>{
  if (!sp.port) { log("[!] 请先连接串口"); return; }
  const input = el('files');
  if (!input.files || input.files.length===0) { log("[!] 请选择要发送的文件"); return; }
  setStatus("Sending..."); bar.style.width = "0%"; setProgress("","",0,0); setRunning(true);
  ymodem.stopFlag = false;
  const files = Array.from(input.files);
  const rc = await ymodem.send(files);
  setRunning(false);
  if (rc===0) log(`[OK] rc=${rc}`); else log(`[ERR] rc=${rc}`);
  setStatus("Idle");
};

el('btnRecv').onclick = async()=>{
  if (!sp.port) { log("[!] 请先连接串口"); return; }
  setStatus("Receiving..."); bar.style.width = "0%"; setProgress("","",0,0); setRunning(true);
  ymodem.stopFlag = false;
  const sink = dirHandle ? makeFileSinkWithFSAccess(dirHandle) : makeFileSinkByDownload();
  const rc = await ymodem.receive(sink);
  setRunning(false);
  if (rc===0) log(`[OK] rc=${rc}`); else log(`[ERR] rc=${rc}`);
  setStatus("Idle");
};

el('btnStop').onclick = async()=>{
  ymodem.stopFlag = true;
  // 尝试送出若干 CAN，结束当前会话阶段（与脚本说明保持一致）
  try { for (let i=0;i<7;i++) await sp.putc(YMD_CAN); } catch(_){}
  setRunning(false);
  log("[*] Stop pressed (let current step finish)");
};


Requests	IP Address	Location	AS Autonomous System
2	188.114.97.3	United States	AS13335Cloudflare, Inc.
2	1	-	-

Security Scan Report: ymodem-tools.pages.dev

Summary

AI Security Verdict

Low 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 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