HYLUZ

Armbian 斐讯N1 盒子变成 Read-only File System

Sun, 04 Jan 2026 00:39:43 +0800

Armbian 斐讯N1 盒子变成 Read-only File System
原因是 N1 盒子 emmc 出现坏块导致，解决方法：用 U 盘启动 N1 盒子进入 Armbian，然后输入下面的命令：

e2fsck /dev/mmcblk1p2
修复成功后拔掉 U 盘重启 N1 盒子。

飞牛相册获取搜索结果失败处理

Sat, 13 Dec 2025 21:41:22 +0800

飞牛相册获取搜索结果失败处理
相册中可以按地点聚档，但是点击地点后获取搜索结果失败

导出日志报错

time="2025-12-13T21:17:57+08:00" level=error msg="open photo index name:2 error: cannot open index, metadata corrupt"
time="2025-12-13T21:17:57+08:00" level=error msg="add new photo index error:cannot open index, metadata corrupt"
time="2025-12-13T21:17:57+08:00" level=error msg="query user photo id list error: cannot open index, metadata corrupt"

像索引相关问题

在相册设置中重建索引后回复正常

渗透测试中交换机资产的应用

Tue, 04 Nov 2025 21:12:01 +0800

攻防演练打点过程中拿到了一台交换机的ssh权限；需要尝试利用交换机做跳板进入内网

交换机信息收集

可用命令查询

<F100-C-XI>?
User view commands:
  archive             Archive configuration
  backup              Backup operation
  boot-loader         Software image file management
  bootrom             Update/read/backup/restore bootrom
  cd                  Change current directory
  clock               Specify the system clock
  copy                Copy a file
  debugging           Enable system debugging functions
  debugging-auto-off  Automatically turn off all debugging
  delete              Delete a file
  diagnostic          Generic OnLine Diagnostics (GOLD) module
  diagnostic-logfile  Diagnostic log file configuration
  dialer              Specify Dial-on-Demand Routing(DDR) configuration
                      information
  dir                 Display files and directories on the storage media
  display             Display current system information
  erase               Alias for 'delete'
  exception           Exception information configuration
  exit                Alias for 'quit'
  fdisk               Partition a storage medium
  firmware            Firmware management
  fixdisk             Check and repair a storage medium
  format              Format a storage medium
  free                Release a connection
  ftp                 Open an FTP connection
  fuser               Display processes that are using a file system, directory,
                      or file
  gunzip              Decompress file
  gzip                Compress file
  install             Perform package management operation
  issu                In-Service Software Upgrade module
  l2vpn               Layer 2 Virtual Private Network (L2VPN) module
  loadbalance         Load Balancing module
  local-guest         Manage guest users
  locator             Locate devices
  lock                Lock the current line
  logfile             Log file configuration
  md5sum              Compute the hash digest of a file using the MD5 algorithm
  mkdir               Create a new directory
  monitor             System monitor
  more                Display the contents of a file
  mount               Mount a storage medium
  move                Move a file
  no                  Alias for 'undo'
  ping                Ping function
  process             Process management
  pwd                 Display current working directory
  python              Source using python script
  quit                Exit from current command view
  reboot              Reboot operation
  refresh             Do soft reset
  rename              Rename a file or directory
  repeat              Repeat executing history commands
  reset               Reset operation
  restore             Restore operation
  rmdir               Remove an existing directory
  save                Save current configuration
  scheduler           Scheduler configuration
  scp                 Establish an SCP connection to an SCP server
  screen-length       Multiple-screen output function
  security-logfile    Security log file configuration
  send                Send information to other lines
  sftp                Establish an SFTP connection to an SFTP server
  sha256sum           Compute the hash digest of a file using the SHA256
                      algorithm
  show                Alias for 'display'
  ssh2                Establish an Stelnet connection to an Stelnet server
  startup             Specify system startup parameters
  super               Switch to a user role
  system-view         Enter the System View
  tar                 Archive management
  tclquit             Exit from TCL shell
  tclsh               Enter the TCL shell
  telnet              Establish a telnet connection
  terminal            Set the terminal line characteristics
  test-aaa            Perform an AAA test
  tftp                Open a TFTP connection
  tracert             Tracert function
  umount              Unmount a storage medium
  undelete            Recover a deleted file
  undo                Cancel current setting

交换机中可以使用python、sftp
那么可以使用sftp上传脚本后使用python搭建socks代理服务器
确定python版本，交换机使用的python版本为2.7.3，不支持python3的一些新特性。因此代理服务的写法需要使用2.7.3的语法来写。

确定关键模块是否可用
主要用到 socket,select,struct,threading 几个模块
测试模块是否存在

编写代理服务

#coding:utf-8
import socket,select,struct,threading
HOST,PORT='0.0.0.0',10801
def handle(c):
    try:
        if c.recv(3)[0]=='\x05':
            c.send('\x05\x00')
            d=c.recv(1024)
            if d[1]=='\x01':
                r=socket.socket()
                if d[3]=='\x01':
                    ip=socket.inet_ntoa(d[4:8])
                    p=struct.unpack('>H',d[8:10])[0]
                elif d[3]=='\x03':
                    l=ord(d[4])
                    ip=d[5:5+l]
                    p=struct.unpack('>H',d[5+l:7+l])[0]
                r.connect((ip,p))
                c.send('\x05\x00\x00\x01'+socket.inet_aton('0.0.0.0')+struct.pack('>H',1080))
                while 1:
                    rd,_,_=select.select([c,r],[],[],30)
                    if c in rd:
                        data=c.recv(4096)
                        if not data:break
                        r.send(data)
                    if r in rd:
                        data=r.recv(4096)
                        if not data:break
                        c.send(data)
                r.close()
    except:pass
    c.close()
s=socket.socket()
s.bind((HOST,PORT))
s.listen(5)
print("SOCKS5 proxy on %s:%s"%(HOST,PORT))
while 1:
    try:
        c,a=s.accept()
        t=threading.Thread(target=handle,args=(c,))
        t.daemon=True
        t.start()
    except:pass

开启SFTP服务
直接使用SFTP连接发现连不上，交换机默认SFTP服务没打开

上传代理服务脚本
开启sftp以后就可以进行文件管理了，使用winscp连接上传脚本

启动代理

连接测试

goby测试

浏览器代理测试

5ire接入HexStrike AI MCP Agents报错Error Messages with role 'tool' must be a response to a preceding ...

Fri, 10 Oct 2025 20:22:28 +0800

问题现象

在kali上搭好HexStrike服务后使用5ire接入，渗透测试时会报错
Error Messages with role ‘tool’ must be a response to a preceding message with ‘tool_calls’

解决方法

5ire版本太高了，用的是0.14.1

换了0.13.2就正常了（太坑了）

js debugger各种方法的演示

Wed, 27 Aug 2025 11:26:39 +0800

做了个js debugger各种方法的演示，供绕过debugger学习用

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
<title>Debugger 策略与绕过演练台</title>
<style>
  :root {
    --primary:#2563eb;
    --danger:#ef4444;
    --bg:#0b1220;
    --card:#0f172a;
    --muted:#94a3b8;
    --text:#e2e8f0;
    --accent:#22c55e;
  }
  *{box-sizing:border-box}
  body{
    margin:0;
    font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial;
    background: radial-gradient(1200px 600px at 10% -10%, #172554 0%, #0b1220 45%) , var(--bg);
    color:var(--text);
    line-height:1.6;
  }
  header{
    max-width:1080px;margin:32px auto 8px;padding:0 16px;text-align:center;
  }
  h1{margin:0 0 8px 0;font-weight:800;letter-spacing:.2px}
  .sub{color:var(--muted);max-width:800px;margin:0 auto 20px}
  .wrap{max-width:1080px;margin:0 auto;padding:0 16px 32px}
  .card{
    background:linear-gradient(180deg, rgba(148,163,184,.1), transparent 30%) , var(--card);
    border:1px solid rgba(148,163,184,.15);
    border-radius:16px;
    padding:18px;
    margin-bottom:16px;
    box-shadow:0 10px 30px rgba(2,6,23,.4);
  }
  .grid{
    display:grid;
    grid-template-columns: repeat(2, minmax(0,1fr));
    gap:12px;
  }
  @media (min-width:860px){
    .grid{grid-template-columns: repeat(3, minmax(0,1fr));}
  }
  .row{
    display:flex;gap:8px;align-items:center;justify-content:flex-start;flex-wrap:wrap;
    padding:10px;border:1px dashed rgba(148,163,184,.2);border-radius:12px;background:rgba(30,41,59,.35)
  }
  .row h3{
    margin:0 8px 0 0;font-size:15px;font-weight:700;white-space:nowrap
  }
  button{
    padding:9px 12px;font-size:14px;border:none;border-radius:10px;color:white;cursor:pointer;
    background:linear-gradient(180deg, rgba(255,255,255,.06), rgba(0,0,0,.08)), var(--primary);
    transition:filter .2s, transform .02s;
  }
  button.small{padding:8px 10px;font-size:13px;background:#334155}
  button:hover{filter:brightness(1.08)}
  button:active{transform:translateY(1px)}
  button.red{background:linear-gradient(180deg, rgba(255,255,255,.06), rgba(0,0,0,.08)), var(--danger)}
  .log{
    height:200px;overflow:auto;background:rgba(15,23,42,.7);border-radius:12px;border:1px solid rgba(148,163,184,.15);
    padding:10px;font-family:ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;font-size:13px;
  }
  .log p{margin:4px 0}
  .hint{color:var(--muted);font-size:13px;margin:-6px 0 8px}
  /* Modal */
  .modal-backdrop{
    position:fixed;inset:0;background:rgba(2,6,23,.6);backdrop-filter: blur(3px);
    display:none;align-items:center;justify-content:center;padding:16px;z-index:40;
  }
  .modal{
    max-width:820px;width:100%;
    background:var(--card);border:1px solid rgba(148,163,184,.2);border-radius:14px;
    box-shadow:0 20px 60px rgba(2,6,23,.6);
    overflow:hidden;
  }
  .modal header{
    padding:14px 16px 0;margin:0;text-align:left;
  }
  .modal h2{margin:0 0 4px 0;font-size:18px}
  .modal .content{
    padding:4px 16px 16px;max-height:60vh;overflow:auto;color:#dbeafe;
  }
  .modal .content ul{padding-left:18px;margin:6px 0 0 0}
  .modal .content li{margin:4px 0}
  .modal .footer{
    padding:12px 16px;border-top:1px solid rgba(148,163,184,.2);display:flex;justify-content:flex-end;gap:8px
  }
  .badge{
    display:inline-block;padding:2px 8px;border-radius:999px;font-size:12px;color:white;background:#0ea5e9;margin-left:6px
  }
</style>
</head>
<body>
  <header>
    <h1>Debugger 策略与绕过演练台</h1>
    <p class="sub">点击任意触发按钮开启对应的 <code>debugger</code> 策略；旁边的“绕过提示”会给出常见规避方案与工具路径。适合在 DevTools 中练习反调试绕过。</p>
  </header>

  <div class="wrap">
    <section class="card">
      <div class="hint">▶ 建议开启 DevTools 的 <em>Pause on debugger</em>，并试试条件断点、覆盖脚本、CSP 调整等。</div>
      <div class="grid" id="btnGrid">
        <!-- 按钮行通过 JS 注入，见下方 config -->
      </div>
      <div style="display:flex;gap:8px;margin-top:12px;flex-wrap:wrap">
        <button id="stopAllBtn" class="red">停止所有触发</button>
        <button id="clearLogBtn" class="small">清空日志</button>
      </div>
    </section>

    <section class="card">
      <h3 style="margin:0 0 8px 0">日志</h3>
      <div class="log" id="logContainer"><p>日志输出区域...</p></div>
    </section>
  </div>

  <!-- Modal -->
  <div class="modal-backdrop" id="modal">
    <div class="modal">
      <header>
        <h2 id="modalTitle">绕过提示</h2>
      </header>
      <div class="content" id="modalContent">
        <!-- 动态填充 -->
      </div>
      <div class="footer">
        <button id="copyTipsBtn" class="small">复制内容</button>
        <button id="closeModalBtn">关闭</button>
      </div>
    </div>
  </div>

<script>
/* ========= 日志 / 公共 ========= */
function log(message){
  const box = document.getElementById('logContainer');
  const p = document.createElement('p');
  p.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
  box.appendChild(p);
  box.scrollTop = box.scrollHeight;
}
window.log = log; // 供 new Function / Worker 使用

// 可清理资源的引用
const timers = {
  explicit:null, eval:null, fn:null, ctor:null, mixed:null,
  raf:null, timeout:null, promise:false, observer:null, getterInt:null, idle:null, worker:null,
  evThrottler:{ last:0, handler:null }
};

function jitter(base=1200, spread=600){
  return base - spread/2 + Math.random()*spread;
}

/* ========= 触发策略配置（名称、触发器、绕过指南） ========= */
const strategies = [
  {
    key:'explicit',
    name:'显式 setInterval',
    trigger(){
      if (timers.explicit) return log('显式已在运行');
      log('启动：显式 setInterval');
      function tick(){ debugger; log('显式 debugger 触发'); }
      timers.explicit = setInterval(tick, 1000);
    },
    tips:`
<ul>
  <li>在 DevTools 勾选「从不在异常处暂停」/关闭 Pause on debugger。</li>
  <li>临时把 <code>debugger</code> 改成空语句：在 Sources 里覆盖脚本（Override/Local Overrides）。</li>
  <li>在运行时重写 <code>window.Function.prototype.constructor</code>/<code>debugger</code> 触发点（若可控）。</li>
  <li>全局禁用定时器：把 <code>setInterval</code> 指向空函数（慎用，影响面大）。</li>
</ul>`
  },
  {
    key:'eval',
    name:'eval 调用',
    trigger(){
      if (timers.eval) return log('eval 已在运行');
      log('启动：eval 调用');
      timers.eval = setInterval(()=>{
        try { eval("debugger; window.log('eval debugger 触发')"); }
        catch(e){ debugger; log('eval 被 CSP 限制，降级显式触发'); }
      }, 1000);
    },
    tips:`
<ul>
  <li>站点有 CSP：在 Response Header 放宽 <code>script-src 'unsafe-eval'</code> 或调整 DevTools 的 Overrides 以去除限制（仅在可控环境调试）。</li>
  <li>直接将 <code>eval</code> 指向安全实现：<code>window.eval = ()=>{}</code>（可能影响站点其他逻辑）。</li>
  <li>改为条件断点：只在特定堆栈/URL 时暂停。</li>
</ul>`
  },
  {
    key:'fn',
    name:'new Function',
    trigger(){
      if (timers.fn) return log('Function 已在运行');
      log('启动：new Function');
      timers.fn = setInterval(()=>{
        try { new Function("debugger; window.log('Function debugger 触发')")(); }
        catch(e){ debugger; log('new Function 被 CSP 限制，降级显式触发'); }
      }, 1000);
    },
    tips:`
<ul>
  <li>CSP 下常被拦截：同 <code>eval</code> 绕过。</li>
  <li>在模块脚本中，它无法捕获局部变量；将依赖挂到 <code>window</code>。</li>
  <li>可用 DevTools「黑盒」脚本避免进入该文件。</li>
</ul>`
  },
  {
    key:'ctor',
    name:'Function.prototype.constructor',
    trigger(){
      if (timers.ctor) return log('Constructor 已在运行');
      log('启动：Function.prototype.constructor');
      timers.ctor = setInterval(()=>{
        try { (function(){}).constructor("debugger; window.log('Constructor debugger 触发')")(); }
        catch(e){ debugger; log('constructor 被 CSP 限制，降级显式触发'); }
      }, 1000);
    },
    tips:`
<ul>
  <li>与 <code>new Function</code> 等价，亦受 CSP 约束。</li>
  <li>可以在运行时替换 <code>Function.prototype.constructor</code> 返回的实现。</li>
</ul>`
  },
  {
    key:'mixed',
    name:'混合随机',
    trigger(){
      if (timers.mixed) return log('混合已在运行');
      log('启动：混合随机（含降级、抖动）');
      function once(){
        const arr = [
          ()=>{ debugger; log('显式 触发'); },
          ()=>{ try{ eval("debugger; window.log('eval 触发')"); }catch{ debugger; log('eval 降级'); } },
          ()=>{ try{ new Function("debugger; window.log('Function 触发')")(); }catch{ debugger; log('Function 降级'); } },
          ()=>{ try{ (function(){}).constructor("debugger; window.log('Ctor 触发')")(); }catch{ debugger; log('Ctor 降级'); } }
        ];
        arr[Math.floor(Math.random()*arr.length)]();
      }
      (function loop(){
        once();
        timers.mixed = setTimeout(loop, jitter());
      })();
    },
    tips:`
<ul>
  <li>随机调度+多路径：用条件断点限制只在感兴趣的路径暂停。</li>
  <li>在 Overrides 中批量删改所有 <code>debugger;</code>（正则查找）。</li>
</ul>`
  },
  {
    key:'raf',
    name:'requestAnimationFrame',
    trigger(){
      if (timers.raf) return log('rAF 已在运行');
      log('启动：requestAnimationFrame 循环');
      const loop=()=>{ debugger; log('rAF 触发'); timers.raf = requestAnimationFrame(loop); };
      timers.raf = requestAnimationFrame(loop);
    },
    tips:`
<ul>
  <li>后台标签页 rAF 会暂停：切后台临时规避。</li>
  <li>DevTools「黑盒脚本」+ 移除 <code>debugger</code>。</li>
</ul>`
  },
  {
    key:'timeout',
    name:'setTimeout 递归（抖动）',
    trigger(){
      if (timers.timeout) return log('Timeout 已在运行');
      log('启动：setTimeout 递归（抖动）');
      const run = ()=>{ debugger; log('Timeout 触发'); timers.timeout = setTimeout(run, jitter()); };
      timers.timeout = setTimeout(run, 600);
    },
    tips:`
<ul>
  <li>重写 <code>setTimeout</code>，拦截特定回调。</li>
  <li>条件断点过滤调用栈/脚本 URL。</li>
</ul>`
  },
  {
    key:'promise',
    name:'Promise/Microtask',
    trigger(){
      if (timers.promise) return log('Promise 已在运行');
      log('启动：Promise/Microtask');
      timers.promise = true;
      (function schedule(){
        if (!timers.promise) return;
        Promise.resolve().then(()=>{ debugger; log('Promise 微任务触发'); })
          .finally(()=> setTimeout(schedule, 800));
      })();
    },
    tips:`
<ul>
  <li>微任务频繁：在 DevTools 里使用「Async 堆栈」辅助溯源。</li>
  <li>禁用/替换 <code>Promise</code> 的 then 包装（风险大，不推荐生产）。</li>
</ul>`
  },
  {
    key:'mo',
    name:'MutationObserver',
    trigger(){
      if (timers.observer) return log('MO 已在运行');
      log('启动：MutationObserver');
      const target = document.getElementById('logContainer');
      const mo = new MutationObserver(()=>{ debugger; log('MO 触发'); });
      mo.observe(target, {childList:true, characterData:true, subtree:true});
      timers.observer = mo;
      let i=0;
      (function poke(){
        if (!timers.observer) return;
        const p=document.createElement('p'); p.textContent='MO 心跳 '+(++i); target.appendChild(p);
        setTimeout(poke, 1500);
      })();
    },
    tips:`
<ul>
  <li>临时断开观察者：覆盖 <code>MutationObserver.prototype.observe</code>/<code>disconnect</code>。</li>
  <li>避免 DOM 变更（若可控数据源）。</li>
</ul>`
  },
  {
    key:'getter',
    name:'Getter/Proxy 访问',
    trigger(){
      if (timers.getterInt) return log('Getter 已在运行');
      log('启动：Getter/Proxy');
      const carrier = {};
      Object.defineProperty(carrier,'x',{get(){ debugger; log('Getter 触发'); return 1; }});
      timers.getterInt = setInterval(()=>{ void carrier.x; }, 1000);
    },
    tips:`
<ul>
  <li>用 <code>Object.defineProperty</code> 重新定义该属性，无副作用 getter。</li>
  <li>若为 Proxy，可替换 <code>Proxy</code> 构造/handler。</li>
</ul>`
  },
  {
    key:'idle',
    name:'requestIdleCallback',
    trigger(){
      if (timers.idle) return log('Idle 已在运行');
      if (!('requestIdleCallback' in window)){
        log('不支持 requestIdleCallback，降级 setTimeout');
        timers.idle = setTimeout(function tick(){ debugger; log('Idle 降级触发'); timers.idle=setTimeout(tick,1200); }, 800);
        return;
      }
      log('启动：requestIdleCallback');
      const loop=()=>{ timers.idle = requestIdleCallback(()=>{ debugger; log('Idle 触发'); loop(); }, {timeout:2000}); };
      loop();
    },
    tips:`
<ul>
  <li>空闲触发：让页面保持忙碌（动画/网络）以推迟触发。</li>
  <li>替换 <code>requestIdleCallback</code> 为 no-op（仅测试用）。</li>
</ul>`
  },
  {
    key:'worker',
    name:'Web Worker',
    trigger(){
      if (timers.worker) return log('Worker 已在运行');
      log('启动：Web Worker（需 DevTools 开启 Worker 源码调试）');
      try{
        const blob=new Blob([`
          self.onmessage=()=>{};
          setInterval(()=>{ debugger; self.postMessage('tick'); }, 1000);
        `],{type:'application/javascript'});
        const url=URL.createObjectURL(blob);
        const w=new Worker(url);
        w.onmessage = e => { /* 占位 */ };
        timers.worker=w;
      }catch(e){
        log('创建 Worker 失败（可能被 CSP 的 worker-src / blob 禁止）：'+e);
      }
    },
    tips:`
<ul>
  <li>Sources 面板展开「Workers」，单独禁用暂停或黑盒 worker 脚本。</li>
  <li>CSP 严格下可禁用 blob/worker-src，阻止加载（仅自测环境）。</li>
</ul>`
  },
  {
    key:'event',
    name:'事件监听（mousemove/keydown）',
    trigger(){
      if (timers.evThrottler.handler) return log('事件监听已在运行');
      log('启动：事件监听（1s 节流）');
      const throttled = (e)=>{
        const now=Date.now(); if (now - timers.evThrottler.last < 1000) return;
        timers.evThrottler.last = now; debugger; log(`事件 ${e.type} 触发`);
      };
      timers.evThrottler.handler = throttled;
      window.addEventListener('mousemove', throttled, {passive:true});
      window.addEventListener('keydown', throttled, {passive:true});
    },
    tips:`
<ul>
  <li>避免触发相关事件（或在控制台移除监听）。</li>
  <li>运行时用 <code>getEventListeners(window)</code>（Chrome）查找并 <code>removeEventListener</code>。</li>
</ul>`
  }
];

/* ========= 注入按钮行 ========= */
const grid = document.getElementById('btnGrid');
strategies.forEach(s=>{
  const row = document.createElement('div');
  row.className = 'row';
  row.innerHTML = `
    <h3>${s.name}</h3>
    <button data-key="${s.key}">触发</button>
    <button class="small" data-tip="${s.key}">绕过提示</button>
    <span class="badge">ID: ${s.key}</span>
  `;
  grid.appendChild(row);
});
grid.addEventListener('click',(e)=>{
  const triggerKey = e.target.getAttribute('data-key');
  const tipKey = e.target.getAttribute('data-tip');
  if (triggerKey){
    const s = strategies.find(x=>x.key===triggerKey);
    if (s) s.trigger();
  } else if (tipKey){
    const s = strategies.find(x=>x.key===tipKey);
    if (s) openTips(s.name, s.tips);
  }
});

/* ========= 停止/清理 ========= */
document.getElementById('stopAllBtn').addEventListener('click', ()=>{
  // interval 类
  ['explicit','eval','fn','ctor','getterInt'].forEach(k=>{
    if (timers[k]){ clearInterval(timers[k]); timers[k]=null; }
  });
  // timeout / mixed
  if (timers.timeout){ clearTimeout(timers.timeout); timers.timeout=null; }
  if (timers.mixed){ clearTimeout(timers.mixed); timers.mixed=null; }
  // rAF
  if (timers.raf){ cancelAnimationFrame(timers.raf); timers.raf=null; }
  // Promise 循环标志
  timers.promise = false;
  // MO
  if (timers.observer){ timers.observer.disconnect(); timers.observer=null; }
  // idle
  if (timers.idle){
    if ('cancelIdleCallback' in window) cancelIdleCallback(timers.idle);
    else clearTimeout(timers.idle);
    timers.idle=null;
  }
  // Worker
  if (timers.worker){ timers.worker.terminate(); timers.worker=null; }
  // 事件监听
  if (timers.evThrottler.handler){
    window.removeEventListener('mousemove', timers.evThrottler.handler);
    window.removeEventListener('keydown',  timers.evThrottler.handler);
    timers.evThrottler.handler=null; timers.evThrottler.last=0;
  }
  log('已停止所有触发');
});
document.getElementById('clearLogBtn').addEventListener('click', ()=>{
  const box=document.getElementById('logContainer');
  box.innerHTML = '<p>日志输出区域...</p>';
});

/* ========= Modal（绕过提示） ========= */
const modal = document.getElementById('modal');
const modalTitle = document.getElementById('modalTitle');
const modalContent = document.getElementById('modalContent');
const closeModalBtn = document.getElementById('closeModalBtn');
const copyTipsBtn  = document.getElementById('copyTipsBtn');

function openTips(title, html){
  modalTitle.textContent = `绕过提示 · ${title}`;
  modalContent.innerHTML = html + `
    <hr style="border-color:rgba(148,163,184,.2)">
    <p style="margin:6px 0 0 0;color:#93c5fd;font-size:13px">
    通用思路：条件断点（过滤堆栈/URL/调用参数） · 覆盖脚本移除 <code>debugger</code> · 黑盒脚本 · 临时替换 API（<code>eval</code>/<code>Function</code>/<code>setInterval</code>/Observers 等） · 关闭 Pause on debugger。
    </p>`;
  modal.style.display = 'flex';
}
function closeTips(){ modal.style.display = 'none'; }

closeModalBtn.addEventListener('click', closeTips);
modal.addEventListener('click',(e)=>{ if (e.target===modal) closeTips(); });
copyTipsBtn.addEventListener('click', async ()=>{
  const tmp = modalContent.innerText;
  try{
    await navigator.clipboard.writeText(tmp);
    log('已复制绕过提示到剪贴板');
  }catch{
    log('复制失败：可能缺少权限');
  }
});

</script>
</body>
</html>

E01镜像仿真（E01镜像转VMware虚拟机）

Fri, 11 Jul 2025 13:02:31 +0800

电子取证中，经常见到硬盘分区直接打包成的E01镜像；有时候需要模拟一下镜像启动（仿真），但是所有的仿真软件都是收费的。因此做了这个脚本，可以把E01镜像转成VMDK磁盘镜像，同时生成VMX文件用于虚拟机启动。

代码

import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import subprocess
import os
import shutil
from pathlib import Path

# --- 配置区 ---
# 请根据您的实际情况修改以下路径
EWFEXPORT_PATH = r"D:\ewfexport.exe"  # ewfexport.exe
QEMU_IMG_PATH = r"C:\qemu-img.exe"    # qemu-img.exe
# --- 配置区结束 ---

class E01ConverterApp:
    def __init__(self, root):
        self.root = root
        self.root.title("E01 到 VMDK 转换器")
        self.root.geometry("600x580")
        self.root.resizable(False, False)

        # 样式
        self.style = ttk.Style()
        self.style.configure("TFrame", padding=10, relief="flat")
        self.style.configure("TLabel", font=("Segoe UI", 10))
        self.style.configure("TButton", font=("Segoe UI", 10, "bold"))
        self.style.configure("TEntry", font=("Segoe UI", 10))
        self.style.configure("TCombobox", font=("Segoe UI", 10))
        self.style.configure("TProgressbar", thickness=15)

        # 主框架
        main_frame = ttk.Frame(root, padding="15 15 15 15")
        main_frame.pack(fill=tk.BOTH, expand=True)

        # E01文件路径选择
        path_frame = ttk.LabelFrame(main_frame, text="1. E01 文件路径", padding="10")
        path_frame.pack(fill=tk.X, pady=10)

        self.e01_path_entry = ttk.Entry(path_frame, width=60)
        self.e01_path_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
        self.browse_button = ttk.Button(path_frame, text="浏览...", command=self.browse_e01_file)
        self.browse_button.pack(side=tk.RIGHT)

        # 输出目录选择
        output_frame = ttk.LabelFrame(main_frame, text="2. 输出目录 (VMDK和VMX将生成在此)", padding="10")
        output_frame.pack(fill=tk.X, pady=10)

        self.output_dir_entry = ttk.Entry(output_frame, width=60)
        self.output_dir_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
        self.browse_output_button = ttk.Button(output_frame, text="选择目录...", command=self.browse_output_dir)
        self.browse_output_button.pack(side=tk.RIGHT)

        # 操作系统和启动方式选择
        vm_config_frame = ttk.LabelFrame(main_frame, text="3. 虚拟机配置 (用于生成VMX)", padding="10")
        vm_config_frame.pack(fill=tk.X, pady=10)

        # 操作系统类型
        ttk.Label(vm_config_frame, text="操作系统类型:").grid(row=0, column=0, padx=5, pady=5, sticky=tk.W)
        self.os_type_options = [
            "Windows 10 64-bit", "Windows 8 64-bit", "Windows 7 64-bit",
            "Windows XP 32-bit", "Windows 2003 Server 32-bit",
            "Ubuntu 64-bit", "Debian 64-bit", "CentOS 64-bit", "Other Linux 64-bit",
            "Other 64-bit", "Other 32-bit"
        ]
        self.os_type_var = tk.StringVar(root)
        self.os_type_var.set(self.os_type_options[0]) # 默认值
        self.os_type_menu = ttk.Combobox(vm_config_frame, textvariable=self.os_type_var,
                                         values=self.os_type_options, state="readonly", width=30)
        self.os_type_menu.grid(row=0, column=1, padx=5, pady=5, sticky=tk.W)

        # 启动方式
        ttk.Label(vm_config_frame, text="启动方式:").grid(row=1, column=0, padx=5, pady=5, sticky=tk.W)
        self.boot_type_options = ["BIOS", "EFI (UEFI)"]
        self.boot_type_var = tk.StringVar(root)
        self.boot_type_var.set(self.boot_type_options[0]) # 默认值
        self.boot_type_menu = ttk.Combobox(vm_config_frame, textvariable=self.boot_type_var,
                                           values=self.boot_type_options, state="readonly", width=30)
        self.boot_type_menu.grid(row=1, column=1, padx=5, pady=5, sticky=tk.W)

        # 转换按钮
        self.convert_button = ttk.Button(main_frame, text="开始转换", command=self.start_conversion, style="TButton")
        self.convert_button.pack(pady=20, ipadx=20, ipady=10)

        # 进度条
        self.progress_bar = ttk.Progressbar(main_frame, orient="horizontal", length=500, mode="determinate", style="TProgressbar")
        self.progress_bar.pack(pady=10)

        # 日志输出
        log_frame = ttk.LabelFrame(main_frame, text="日志输出", padding="10")
        log_frame.pack(fill=tk.BOTH, expand=True, pady=10)

        self.log_text = tk.Text(log_frame, height=8, state="disabled", font=("Consolas", 9), bg="#f0f0f0")
        self.log_text.pack(fill=tk.BOTH, expand=True)
        self.log_text_scrollbar = ttk.Scrollbar(self.log_text, command=self.log_text.yview)
        self.log_text_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.log_text.config(yscrollcommand=self.log_text_scrollbar.set)

        self.initial_dir_set = False # 标记是否已设置初始输出目录

    def log_message(self, message):
        """向日志框输出信息"""
        self.log_text.config(state="normal")
        self.log_text.insert(tk.END, message + "\n")
        self.log_text.see(tk.END) # 自动滚动到底部
        self.log_text.config(state="disabled")
        self.root.update_idletasks() # 立即更新GUI

    def browse_e01_file(self):
        """选择E01文件"""
        file_path = filedialog.askopenfilename(
            title="选择 E01 文件",
            filetypes=[("E01 Files", "*.e01"), ("All Files", "*.*")]
        )
        if file_path:
            self.e01_path_entry.delete(0, tk.END)
            self.e01_path_entry.insert(0, file_path)
            # 自动设置输出目录为E01文件所在目录
            if not self.initial_dir_set:
                output_dir = Path(file_path).parent
                self.output_dir_entry.delete(0, tk.END)
                self.output_dir_entry.insert(0, str(output_dir))
                self.initial_dir_set = True

    def browse_output_dir(self):
        """选择输出目录"""
        dir_path = filedialog.askdirectory(title="选择输出目录")
        if dir_path:
            self.output_dir_entry.delete(0, tk.END)
            self.output_dir_entry.insert(0, dir_path)
            self.initial_dir_set = True

    def run_command(self, command, description, input_data=None, cwd=None):
        """执行外部命令并记录日志，支持传入输入数据"""
        self.log_message(f"--- 正在执行: {description} ---")
        self.log_message(f"命令: {' '.join(command)}")
        try:
            process = subprocess.Popen(
                command,
                stdin=subprocess.PIPE,  # 允许写入标准输入
                stdout=subprocess.PIPE, # 捕获标准输出
                stderr=subprocess.PIPE, # 捕获标准错误
                text=True,              # 以文本模式处理输入输出
                encoding='utf-8',       # 尝试使用UTF-8编码，如果不行再尝试gbk
                errors='replace',       # 编码错误时替换字符
                cwd=cwd                 # 设置工作目录
            )

            # 写入输入数据（如果有）
            stdout, stderr = process.communicate(input=input_data)

            if process.returncode != 0:
                self.log_message(f"错误: {description} 命令执行失败，返回码 {process.returncode}")
                self.log_message("标准输出:\n" + stdout)
                self.log_message("标准错误:\n" + stderr)
                # 尝试用gbk再次解码stderr，因为有些工具可能默认gbk
                try:
                    # 注意：这里是将已解码的字符串重新编码成UTF-8字节，再解码成GBK字符串
                    # 更好的方法是直接尝试不同的解码方式，但因为原始subprocess.run的编码问题，这里保持一致
                    stderr_gbk = stderr.encode('utf-8').decode('gbk', errors='replace')
                    if stderr_gbk != stderr: # 如果gbk解码不同，说明可能是编码问题
                         self.log_message("标准错误 (GBK 解码尝试):\n" + stderr_gbk)
                except Exception:
                    pass

                messagebox.showerror("错误", f"{description} 失败！\n请检查日志获取详情。")
                return False
            else:
                self.log_message("命令执行成功！")
                self.log_message("标准输出:\n" + stdout)
                if stderr:
                    self.log_message("标准错误 (可能包含信息，非错误):\n" + stderr)
                return True
        except FileNotFoundError:
            self.log_message(f"错误: 找不到 {command[0]}。请检查配置中的工具路径是否正确。")
            messagebox.showerror("错误", f"找不到 {command[0]}。\n请检查配置中的工具路径是否正确。")
            return False
        except Exception as e:
            self.log_message(f"执行 {description} 时发生未知错误: {e}")
            messagebox.showerror("错误", f"未知错误: {e}")
            return False

    def generate_vmx_content(self, vmdk_filename, os_type_selected, boot_type_selected):
        """根据选择生成VMX文件内容"""
        # 将用户友好的OS类型映射到VMware的guestOS标识符
        os_type_map = {
            "Windows 10 64-bit": "windows9-64",
            "Windows 8 64-bit": "windows8-64",
            "Windows 7 64-bit": "windows7-64",
            "Windows XP 32-bit": "winxp",
            "Windows 2003 Server 32-bit": "winnetstandard",
            "Ubuntu 64-bit": "ubuntu-64",
            "Debian 64-bit": "debian9-64", # 较新的Debian
            "CentOS 64-bit": "centos7-64", # 较新的CentOS
            "Other Linux 64-bit": "otherlinux-64",
            "Other 64-bit": "other-64",
            "Other 32-bit": "other"
        }
        vmware_guest_os = os_type_map.get(os_type_selected, "other-64")

        # 根据启动方式设置firmware
        firmware_setting = ""
        if boot_type_selected == "EFI (UEFI)":
            firmware_setting = "firmware = \"efi\""

        # VMX 模板
        # 提供了常见的配置，您可以根据需要进行调整
        vmx_content = f"""
.encoding = "GBK"
config.version = "8"
virtualHW.version = "17" # 可以是 10, 11, 12, 14, 15, 16, 17 (对应不同VMware版本)
vmci0.present = "TRUE"
memsize = "4096" # 内存大小，单位MB
numvcpus = "2"   # CPU核心数
displayName = "{Path(vmdk_filename).stem}_converted_vm" # 虚拟机显示名称
guestOS = "{vmware_guest_os}" # 操作系统类型

{firmware_setting} # UEFI 或 BIOS 设置

# 硬盘
ide0:0.fileName = "{vmdk_filename}"
ide0:0.present = "TRUE"
ide0:0.redo = "" # 如果您希望保留快照功能，可以移除此行或设置为"auto"
# scsi0:0.fileName = "{vmdk_filename}" # 如果是SCSI磁盘，请使用此行并注释掉IDE行
# scsi0:0.present = "TRUE"
# scsi0:0.redo = ""
# scsi0.virtualDev = "lsilogic" # LSI Logic for SCSI

# 网络适配器 (NAT模式)
ethernet0.present = "TRUE"
ethernet0.connectionType = "nat"
ethernet0.virtualDev = "e1000" # 或 "vmxnet3" 获取更好性能 (需要安装VMware Tools)
ethernet0.wakeOnPcktRcv = "FALSE"

# USB 控制器
usb.present = "TRUE"
usb.autoConnect.enabled = "TRUE"

# 声音
sound.present = "TRUE"
sound.virtualDev = "hdaudio"

# CD/DVD 驱动器 (自动检测物理驱动器)
ide1:0.present = "TRUE"
ide1:0.deviceType = "atapi-cdrom"
ide1:0.startConnected = "FALSE"
ide1:0.autodetect = "TRUE"

# 其他设置
isolation.tools.hgfs.disable = "TRUE" # 禁用共享文件夹，提高安全性
mks.enable3d = "TRUE" # 启用3D加速
bios.bootdelay = "2000" # 启动时延迟2秒，方便进入BIOS/EFI设置

# 工具
tools.syncTime = "TRUE"
tools.upgrade.policy = "manual"

# 快照 (如果不需要快照，可以禁用)
snapshot.action = "autoCommit"
snapshot.numSnapshots = "0"

"""
        return vmx_content.strip()

    def start_conversion(self):
        """开始整个转换流程"""
        e01_path_str = self.e01_path_entry.get().strip()
        output_dir_str = self.output_dir_entry.get().strip()
        os_type_selected = self.os_type_var.get()
        boot_type_selected = self.boot_type_var.get()

        if not e01_path_str:
            messagebox.showwarning("输入错误", "请选择 E01 文件。")
            return
        if not output_dir_str:
            messagebox.showwarning("输入错误", "请选择输出目录。")
            return
        if not Path(EWFEXPORT_PATH).is_file():
            messagebox.showerror("工具错误", f"找不到 ewfexport.exe。请检查配置中的路径: {EWFEXPORT_PATH}")
            return
        if not Path(QEMU_IMG_PATH).is_file():
            messagebox.showerror("工具错误", f"找不到 qemu-img.exe。请检查配置中的路径: {QEMU_IMG_PATH}")
            return

        e01_path = Path(e01_path_str)
        output_dir = Path(output_dir_str)
        output_dir.mkdir(parents=True, exist_ok=True)

        # 基于E01文件名生成中间RAW和最终VMDK的文件名
        base_name = e01_path.stem # 获取不带扩展名的文件名
        raw_path = output_dir / f"{base_name}.raw" # 完整的raw文件路径
        vmdk_path = output_dir / f"{base_name}.vmdk"
        vmx_path = output_dir / f"{base_name}.vmx"

        self.log_text.config(state="normal")
        self.log_text.delete(1.0, tk.END) # 清空日志
        self.log_text.config(state="disabled")
        self.log_message("--- 开始转换流程 ---")
        self.progress_bar["value"] = 0
        self.convert_button.config(state="disabled") # 禁用按钮防止重复点击

        try:
            # 1. 调用 ewfexport.exe 将 E01 转换为 RAW
            self.log_message(f"阶段1/3: 正在将 E01 转换为 RAW ({raw_path})...")
            # ewfexport 的输入数据：
            # 1. 格式选择 (raw) - 直接回车，因为 -f raw 已经指定
            # 2. 目标文件名 (Windows_Server) - raw_path.stem
            # 3. 段大小 (0 B) - 回车
            # 4. 起始偏移 (0) - 回车
            # 5. 导出字节数 (全部) - 回车
            ewf_input_data = f"\n{raw_path.stem}\n\n\n\n" # 5个换行符

            ewf_command = [
                EWFEXPORT_PATH,
                str(e01_path),
                "-f", "raw",  # 指定输出格式为 raw
                # 注意：这里不再包含 -o 参数，我们将通过 stdin 提供文件名
            ]
            # 运行 ewfexport，并将工作目录设置为输出目录，同时提供输入数据
            if not self.run_command(ewf_command, "E01 到 RAW 转换", input_data=ewf_input_data, cwd=output_dir):
                raise Exception("E01 转换失败")
            self.progress_bar["value"] = 33

            # 2. 调用 qemu-img.exe 将 RAW 转换为 VMDK
            self.log_message(f"阶段2/3: 正在将 RAW 转换为 VMDK ({vmdk_path})...")
            qemu_command = [
                QEMU_IMG_PATH,
                "convert",
                "-f", "raw",
                "-O", "vmdk",
                str(raw_path),
                str(vmdk_path)
            ]
            if not self.run_command(qemu_command, "RAW 到 VMDK 转换"):
                raise Exception("RAW 转换失败")
            self.progress_bar["value"] = 66

            # 3. 生成 VMX 文件
            self.log_message(f"阶段3/3: 正在生成 VMX 文件 ({vmx_path})...")
            vmx_content = self.generate_vmx_content(vmdk_path.name, os_type_selected, boot_type_selected)
            try:
                with open(vmx_path, "w", encoding="utf-8") as f:
                    f.write(vmx_content)
                self.log_message(f"VMX 文件已成功生成: {vmx_path}")
            except Exception as e:
                self.log_message(f"错误: 生成 VMX 文件失败: {e}")
                raise Exception("VMX 生成失败")
            self.progress_bar["value"] = 90

            # 4. 删除中间产物 RAW 文件
            self.log_message(f"正在删除中间产物 RAW 文件 ({raw_path})...")
            try:
                os.remove(raw_path)
                self.log_message("RAW 文件删除成功。")
            except OSError as e:
                self.log_message(f"警告: 删除 RAW 文件失败: {e}")
                messagebox.showwarning("警告", f"删除中间产物 RAW 文件失败。\n请手动删除: {raw_path}")
            self.progress_bar["value"] = 100

            self.log_message("--- 所有操作完成！ ---")
            messagebox.showinfo("完成", f"E01 文件已成功转换为 VMDK，并生成 VMX 文件！\n\nVMDK: {vmdk_path}\nVMX: {vmx_path}")

        except Exception as e:
            self.log_message(f"流程中断: {e}")
            self.log_message("--- 转换流程失败 ---")
        finally:
            self.convert_button.config(state="normal") # 重新启用按钮

if __name__ == "__main__":
    root = tk.Tk()
    app = E01ConverterApp(root)
    root.mainloop()

需要下载ewfexport和qemu，路径替换完就可以用了

运行截图

HTTP走私原理及应用

Tue, 25 Mar 2025 11:40:31 +0800

关键原因：协议解析差异

HTTP请求的解析涉及两个层面：

前端服务器（如CDN/代理）：通常基于标准HTTP规范（如RFC 7230）解析请求。
后端服务器（如源站）：可能采用非标准解析（如容忍畸形请求）。

当两者对请求边界（如Content-Length和Transfer-Encoding头）的解析不一致时，攻击者可构造特殊请求，使前后端服务器对“一个请求的结束和下一个请求的开始”产生分歧，导致请求走私。

主要攻击类型

(1) CL-TE走私（前端用Content-Length，后端用Transfer-Encoding）

POST / HTTP/1.1
Host: example.com
Content-Length: 13
Transfer-Encoding: chunked

0

 smuggled

前端：以Content-Length: 13为准，认为整个请求体长度为13字节（包括0\r\n\r\n）。
后端：启用分块编码（Transfer-Encoding），遇到0\r\n\r\n认为请求结束，剩余部分smuggled被当作下一个请求的起始。

(2) TE-CL走私（前端用Transfer-Encoding，后端用Content-Length）

POST / HTTP/1.1
Host: example.com
Content-Length: 3
Transfer-Encoding: chunked

8
 smuggled
0

前端：处理分块编码，读取8\r\n smuggled\r\n0\r\n\r\n后结束。
后端：忽略分块编码，以Content-Length: 3读取前3字节（8\r\n），剩余部分smuggled\r\n0\r\n\r\n被当作后续请求。

(3) TE-TE走私（前后端均用Transfer-Encoding，但处理不一致）

通过混淆分块编码格式（如重复头、非标准终止符），诱使后端忽略分块边界。

你的疑问非常关键！确实，如果用户尚未登录，即使通过HTTP走私将GET /index注入到请求流中，后端服务器通常仍会要求身份验证。但HTTP走私的绕过能力依赖于具体场景，以下是更详细的解释：

为什么“绕过权限检查”可能成立？

(1) 假设条件

前端代理的权限检查：某些架构中，代理层（如CDN/WAF）会先验证Cookie或Authorization头，合法请求才转发到后端。
后端信任代理：后端可能默认“所有到达的请求已通过代理验证”，不再重复检查权限。

如果攻击者通过走私注入的请求被后端视为独立请求，且代理未正确拦截，则可能绕过前端的权限验证。

(2) 典型场景示例

POST /api HTTP/1.1
Host: target.com
Content-Length: 50
Transfer-Encoding: chunked
Cookie: valid-user-token=...  # 合法用户的Cookie（攻击者无此权限）

0

GET /admin HTTP/1.1  # 走私的恶意请求
X-Forwarded-For: 127.0.0.1

前端代理：检查第一个请求的Cookie合法，放行整个请求（未发现走私部分）。
后端服务器：将GET /admin视为独立请求，且可能因信任代理或X-Forwarded-For头误判为内部请求，直接返回数据。

用户未登录时的利用限制

如果所有请求均需身份验证（无论前后端），且攻击者无法获取合法凭证，单纯走私未授权的GET /index确实无效。但以下情况仍可能存在风险：

(1) 端点权限配置错误

某些API路径（如/healthcheck、/static/files）可能未强制验证身份，攻击者通过走私访问这些端点。
例如：走私请求访问/admin/export?user=*导出所有用户数据（假设该端点仅限IP白名单，但后端误判走私请求为内部IP）。

(2) 会话混淆（Session Confusion）

如果后端使用连接复用（如HTTP Keep-Alive），走私请求可能“继承”前一个合法请求的会话上下文。
例如：
1. 合法用户登录后，连接未关闭。
2. 攻击者通过同一连接走私请求，后端误认为该请求属于已认证会话。

(3) 缓存欺骗（Cache Poisoning）

走私请求可能触发缓存（如CDN）存储恶意响应，后续其他用户访问同一URL时收到恶意内容（无需登录）。

攻击影响

绕过安全控制：如WAF规则、IP限制或身份验证。
缓存投毒：污染CDN缓存，返回恶意内容。
会话劫持：窃取其他用户的请求数据。
反射型攻击：将恶意请求转发给其他用户。

防御措施

标准化解析：强制前后端使用一致的协议解析逻辑。
禁用畸形请求：拒绝含冲突头（如Content-Length和Transfer-Encoding共存）的请求。
严格验证：对请求边界进行严格校验（如分块编码的终止符）。
更新中间件：修复已知的解析漏洞（如Apache/CVE-2022-22721、Nginx配置错误）。

示例场景

假设前端代理（Nginx）和后端（Apache）对以下请求解析不同：

POST /admin HTTP/1.1
Host: target.com
Content-Length: 10
Transfer-Encoding: chunked

2
xx
0

GET /index HTTP/1.1

后端可能将GET /index视为独立请求，从而绕过前端的权限检查。

HTTP smuggling的复杂性在于不同服务器实现的细微差异，攻击者通过精心构造请求利用这些差异实现恶意目的。防御需全面审查HTTP请求处理链路的每一环节。

远程桌面 Windows Server 音频服务未运行

Thu, 13 Feb 2025 15:22:35 +0800

远程桌面没有声音，声卡驱动是正常的

但是状态栏音频这里是个叉，提示音频服务未运行

处理办法

打开服务

启动Windows Audio服务

正常了，也有声音了

多选题-烈士公祭是()而毕生奋斗、英勇牺牲的烈士的活动。

Fri, 20 Dec 2024 13:35:26 +0800

多选题-烈士公祭是()而毕生奋斗、英勇牺牲的烈士的活动。 answer：['国家缅怀纪念为争取民族独立和人民解放', '实现国家富强和人民幸福', '促进世界和平和人类进步']

单选题-甲公司认为某电商平台内的网店销售的商品假冒其商标,通知该平台经营者采取必要措施,则该通知应当包括的证据要求是()。

Fri, 20 Dec 2024 13:35:24 +0800

单选题-甲公司认为某电商平台内的网店销售的商品假冒其商标,通知该平台经营者采取必要措施,则该通知应当包括的证据要求是()。 answer：['通知应当包括构成侵权的初步证据']